file_name
stringlengths 5
52
| name
stringlengths 4
95
| original_source_type
stringlengths 0
23k
| source_type
stringlengths 9
23k
| source_definition
stringlengths 9
57.9k
| source
dict | source_range
dict | file_context
stringlengths 0
721k
| dependencies
dict | opens_and_abbrevs
listlengths 2
94
| vconfig
dict | interleaved
bool 1
class | verbose_type
stringlengths 1
7.42k
| effect
stringclasses 118
values | effect_flags
sequencelengths 0
2
| mutual_with
sequencelengths 0
11
| ideal_premises
sequencelengths 0
236
| proof_features
sequencelengths 0
1
| is_simple_lemma
bool 2
classes | is_div
bool 2
classes | is_proof
bool 2
classes | is_simply_typed
bool 2
classes | is_type
bool 2
classes | partial_definition
stringlengths 5
3.99k
| completed_definiton
stringlengths 1
1.63M
| isa_cross_project_example
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Hacl.SHA2.Scalar32.fst | Hacl.SHA2.Scalar32.sha224_update_nblocks | val sha224_update_nblocks: update_nblocks_vec_t' SHA2_224 M32 | val sha224_update_nblocks: update_nblocks_vec_t' SHA2_224 M32 | let sha224_update_nblocks len b st =
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_nblocks_vec_224_256 len (as_seq_multi h0 b) (as_seq h0 st);
sha256_update_nblocks len b st | {
"file_name": "code/sha2-mb/Hacl.SHA2.Scalar32.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 32,
"end_line": 46,
"start_col": 0,
"start_line": 43
} | module Hacl.SHA2.Scalar32
open FStar.HyperStack.ST
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.NTuple
open Lib.Buffer
open Lib.MultiBuffer
open Spec.Hash.Definitions
open Spec.Agile.Hash
open Hacl.Spec.SHA2.Vec
module SpecVec = Hacl.Spec.SHA2.Vec
open Hacl.Impl.SHA2.Generic
// This module only contains internal helpers that are in support of either the
// full hash function, or the streaming functor. The top-level API is now
// exposed in Hacl.Streaming.SHA2.fst
[@CInline] let sha256_init = init #SHA2_256 #M32
[@CInline] let sha256_update = update #SHA2_256 #M32
[@CInline] let sha256_update_nblocks: update_nblocks_vec_t' SHA2_256 M32 =
update_nblocks #SHA2_256 #M32 sha256_update
[@CInline] let sha256_update_last = update_last #SHA2_256 #M32 sha256_update
[@CInline] let sha256_finish = finish #SHA2_256 #M32
[@CInline] let sha224_init = init #SHA2_224 #M32
inline_for_extraction noextract
val sha224_update: update_vec_t SHA2_224 M32
#push-options "--fuel 0 --ifuel 0 --z3rlimit 20"
let sha224_update b st =
let open Hacl.SHA2.Scalar32.Lemmas in
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_vec_224_256 (as_seq_multi h0 b) (as_seq h0 st);
sha256_update b st
[@CInline] | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.MultiBuffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.SHA2.Vec.fst.checked",
"Hacl.SHA2.Scalar32.Lemmas.fst.checked",
"Hacl.Impl.SHA2.Generic.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.SHA2.Scalar32.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Impl.SHA2.Generic",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.SHA2.Vec",
"short_module": "SpecVec"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.SHA2.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.MultiBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NTuple",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 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": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Hacl.Impl.SHA2.Generic.update_nblocks_vec_t' Spec.Hash.Definitions.SHA2_224 Hacl.Spec.SHA2.Vec.M32 | Prims.Tot | [
"total"
] | [] | [
"Lib.IntTypes.size_t",
"Lib.MultiBuffer.multibuf",
"Hacl.Spec.SHA2.Vec.lanes",
"Spec.Hash.Definitions.SHA2_224",
"Hacl.Spec.SHA2.Vec.M32",
"Hacl.Impl.SHA2.Core.state_t",
"Hacl.SHA2.Scalar32.sha256_update_nblocks",
"Prims.unit",
"Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_nblocks_vec_224_256",
"Lib.MultiBuffer.as_seq_multi",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Hacl.Spec.SHA2.Vec.element_t",
"FStar.UInt32.__uint_to_t",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get"
] | [] | false | false | false | true | false | let sha224_update_nblocks len b st =
| let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_nblocks_vec_224_256 len
(as_seq_multi h0 b)
(as_seq h0 st);
sha256_update_nblocks len b st | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.skey_len_pre | val skey_len_pre : t: Hacl.Spec.Bignum.Definitions.limb_t ->
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat ->
dBits: Lib.IntTypes.size_nat
-> Prims.logical | let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 79,
"end_line": 107,
"start_col": 0,
"start_line": 103
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
t: Hacl.Spec.Bignum.Definitions.limb_t ->
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat ->
dBits: Lib.IntTypes.size_nat
-> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Hacl.Spec.RSAPSS.pkey_len_pre",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.max_size_t",
"Prims.op_Addition",
"Prims.int",
"Lib.IntTypes.bits",
"Prims.logical"
] | [] | false | false | false | true | true | let skey_len_pre (t: limb_t) (modBits eBits dBits: size_nat) =
| let bits = bits t in
pkey_len_pre t modBits eBits /\ 0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t | false |
|
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.bn_lt_pow2 | val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool | val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool | let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1)) | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 63,
"end_line": 33,
"start_col": 0,
"start_line": 31
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = () | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
modBits: Lib.IntTypes.size_pos{1 < modBits} ->
m:
Hacl.Spec.Bignum.Definitions.lbignum t
(Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t))
-> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.bits",
"Prims.op_disEquality",
"Prims.int",
"Prims.op_Modulus",
"Prims.op_Subtraction",
"Prims.bool",
"Hacl.Spec.Bignum.Base.unsafe_bool_of_limb0",
"Hacl.Spec.Bignum.bn_get_ith_bit"
] | [] | false | false | false | false | false | let bn_lt_pow2 #t modBits m =
| if (modBits - 1) % 8 <> 0 then true else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1)) | false |
Hacl.SHA2.Scalar32.fst | Hacl.SHA2.Scalar32.sha384_update_nblocks | val sha384_update_nblocks: update_nblocks_vec_t' SHA2_384 M32 | val sha384_update_nblocks: update_nblocks_vec_t' SHA2_384 M32 | let sha384_update_nblocks len b st =
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_nblocks_vec_384_512 len (as_seq_multi h0 b) (as_seq h0 st);
sha512_update_nblocks len b st | {
"file_name": "code/sha2-mb/Hacl.SHA2.Scalar32.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 32,
"end_line": 85,
"start_col": 0,
"start_line": 82
} | module Hacl.SHA2.Scalar32
open FStar.HyperStack.ST
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.NTuple
open Lib.Buffer
open Lib.MultiBuffer
open Spec.Hash.Definitions
open Spec.Agile.Hash
open Hacl.Spec.SHA2.Vec
module SpecVec = Hacl.Spec.SHA2.Vec
open Hacl.Impl.SHA2.Generic
// This module only contains internal helpers that are in support of either the
// full hash function, or the streaming functor. The top-level API is now
// exposed in Hacl.Streaming.SHA2.fst
[@CInline] let sha256_init = init #SHA2_256 #M32
[@CInline] let sha256_update = update #SHA2_256 #M32
[@CInline] let sha256_update_nblocks: update_nblocks_vec_t' SHA2_256 M32 =
update_nblocks #SHA2_256 #M32 sha256_update
[@CInline] let sha256_update_last = update_last #SHA2_256 #M32 sha256_update
[@CInline] let sha256_finish = finish #SHA2_256 #M32
[@CInline] let sha224_init = init #SHA2_224 #M32
inline_for_extraction noextract
val sha224_update: update_vec_t SHA2_224 M32
#push-options "--fuel 0 --ifuel 0 --z3rlimit 20"
let sha224_update b st =
let open Hacl.SHA2.Scalar32.Lemmas in
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_vec_224_256 (as_seq_multi h0 b) (as_seq h0 st);
sha256_update b st
[@CInline]
val sha224_update_nblocks: update_nblocks_vec_t' SHA2_224 M32
let sha224_update_nblocks len b st =
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_nblocks_vec_224_256 len (as_seq_multi h0 b) (as_seq h0 st);
sha256_update_nblocks len b st
val sha224_update_last: update_last_vec_t' SHA2_224 M32
let sha224_update_last totlen len b st =
let open Lib.Sequence in
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_last_vec_224_256
totlen len (as_seq_multi h0 b) (as_seq h0 st);
sha256_update_last totlen len b st
#pop-options
[@CInline] let sha224_finish = finish #SHA2_224 #M32
let sha512_init = init #SHA2_512 #M32
[@CInline] let sha512_update = update #SHA2_512 #M32
[@CInline] let sha512_update_nblocks: update_nblocks_vec_t' SHA2_512 M32 =
update_nblocks #SHA2_512 #M32 sha512_update
[@CInline] let sha512_update_last = update_last #SHA2_512 #M32 sha512_update
[@CInline] let sha512_finish = finish #SHA2_512 #M32
[@CInline] let sha384_init = init #SHA2_384 #M32
inline_for_extraction noextract
val sha384_update: update_vec_t SHA2_384 M32
#push-options "--fuel 0 --ifuel 0 --z3rlimit 20"
let sha384_update b st =
let open Hacl.SHA2.Scalar32.Lemmas in
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_vec_384_512 (as_seq_multi h0 b) (as_seq h0 st);
sha512_update b st
[@CInline] | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.MultiBuffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.SHA2.Vec.fst.checked",
"Hacl.SHA2.Scalar32.Lemmas.fst.checked",
"Hacl.Impl.SHA2.Generic.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.SHA2.Scalar32.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Impl.SHA2.Generic",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.SHA2.Vec",
"short_module": "SpecVec"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.SHA2.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.MultiBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NTuple",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 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": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Hacl.Impl.SHA2.Generic.update_nblocks_vec_t' Spec.Hash.Definitions.SHA2_384 Hacl.Spec.SHA2.Vec.M32 | Prims.Tot | [
"total"
] | [] | [
"Lib.IntTypes.size_t",
"Lib.MultiBuffer.multibuf",
"Hacl.Spec.SHA2.Vec.lanes",
"Spec.Hash.Definitions.SHA2_384",
"Hacl.Spec.SHA2.Vec.M32",
"Hacl.Impl.SHA2.Core.state_t",
"Hacl.SHA2.Scalar32.sha512_update_nblocks",
"Prims.unit",
"Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_nblocks_vec_384_512",
"Lib.MultiBuffer.as_seq_multi",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Hacl.Spec.SHA2.Vec.element_t",
"FStar.UInt32.__uint_to_t",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get"
] | [] | false | false | false | true | false | let sha384_update_nblocks len b st =
| let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_nblocks_vec_384_512 len
(as_seq_multi h0 b)
(as_seq h0 st);
sha512_update_nblocks len b st | false |
Hacl.SHA2.Scalar32.fst | Hacl.SHA2.Scalar32.finish | val finish: #a:sha2_alg -> finish_vec_t a Hacl.Spec.SHA2.Vec.M32 | val finish: #a:sha2_alg -> finish_vec_t a Hacl.Spec.SHA2.Vec.M32 | let finish #a =
match a with
| SHA2_224 -> coerce sha224_finish
| SHA2_256 -> coerce sha256_finish
| SHA2_384 -> coerce sha384_finish
| SHA2_512 -> coerce sha512_finish | {
"file_name": "code/sha2-mb/Hacl.SHA2.Scalar32.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 36,
"end_line": 138,
"start_col": 0,
"start_line": 133
} | module Hacl.SHA2.Scalar32
open FStar.HyperStack.ST
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.NTuple
open Lib.Buffer
open Lib.MultiBuffer
open Spec.Hash.Definitions
open Spec.Agile.Hash
open Hacl.Spec.SHA2.Vec
module SpecVec = Hacl.Spec.SHA2.Vec
open Hacl.Impl.SHA2.Generic
// This module only contains internal helpers that are in support of either the
// full hash function, or the streaming functor. The top-level API is now
// exposed in Hacl.Streaming.SHA2.fst
[@CInline] let sha256_init = init #SHA2_256 #M32
[@CInline] let sha256_update = update #SHA2_256 #M32
[@CInline] let sha256_update_nblocks: update_nblocks_vec_t' SHA2_256 M32 =
update_nblocks #SHA2_256 #M32 sha256_update
[@CInline] let sha256_update_last = update_last #SHA2_256 #M32 sha256_update
[@CInline] let sha256_finish = finish #SHA2_256 #M32
[@CInline] let sha224_init = init #SHA2_224 #M32
inline_for_extraction noextract
val sha224_update: update_vec_t SHA2_224 M32
#push-options "--fuel 0 --ifuel 0 --z3rlimit 20"
let sha224_update b st =
let open Hacl.SHA2.Scalar32.Lemmas in
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_vec_224_256 (as_seq_multi h0 b) (as_seq h0 st);
sha256_update b st
[@CInline]
val sha224_update_nblocks: update_nblocks_vec_t' SHA2_224 M32
let sha224_update_nblocks len b st =
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_nblocks_vec_224_256 len (as_seq_multi h0 b) (as_seq h0 st);
sha256_update_nblocks len b st
val sha224_update_last: update_last_vec_t' SHA2_224 M32
let sha224_update_last totlen len b st =
let open Lib.Sequence in
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_last_vec_224_256
totlen len (as_seq_multi h0 b) (as_seq h0 st);
sha256_update_last totlen len b st
#pop-options
[@CInline] let sha224_finish = finish #SHA2_224 #M32
let sha512_init = init #SHA2_512 #M32
[@CInline] let sha512_update = update #SHA2_512 #M32
[@CInline] let sha512_update_nblocks: update_nblocks_vec_t' SHA2_512 M32 =
update_nblocks #SHA2_512 #M32 sha512_update
[@CInline] let sha512_update_last = update_last #SHA2_512 #M32 sha512_update
[@CInline] let sha512_finish = finish #SHA2_512 #M32
[@CInline] let sha384_init = init #SHA2_384 #M32
inline_for_extraction noextract
val sha384_update: update_vec_t SHA2_384 M32
#push-options "--fuel 0 --ifuel 0 --z3rlimit 20"
let sha384_update b st =
let open Hacl.SHA2.Scalar32.Lemmas in
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_vec_384_512 (as_seq_multi h0 b) (as_seq h0 st);
sha512_update b st
[@CInline]
val sha384_update_nblocks: update_nblocks_vec_t' SHA2_384 M32
let sha384_update_nblocks len b st =
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_nblocks_vec_384_512 len (as_seq_multi h0 b) (as_seq h0 st);
sha512_update_nblocks len b st
val sha384_update_last: update_last_vec_t' SHA2_384 M32
let sha384_update_last totlen len b st =
let open Lib.Sequence in
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_last_vec_384_512
totlen len (as_seq_multi h0 b) (as_seq h0 st);
sha512_update_last totlen len b st
#pop-options
[@CInline] let sha384_finish = finish #SHA2_384 #M32
// Big up for Aymeric who dug this one to help me make the coercion work.
unfold let coerce (#b #a:Type) (x:a{a == b}) : b = x
// Agility patterns for the streaming functor
inline_for_extraction noextract
val init: #a:sha2_alg -> init_vec_t a Hacl.Spec.SHA2.Vec.M32
let init #a =
match a with
| SHA2_224 -> coerce sha224_init
| SHA2_256 -> coerce sha256_init
| SHA2_384 -> coerce sha384_init
| SHA2_512 -> coerce sha512_init
inline_for_extraction noextract
val update_nblocks: #a:sha2_alg -> update_nblocks_vec_t' a Hacl.Spec.SHA2.Vec.M32
let update_nblocks #a =
match a with
| SHA2_224 -> coerce sha224_update_nblocks
| SHA2_256 -> coerce sha256_update_nblocks
| SHA2_384 -> coerce sha384_update_nblocks
| SHA2_512 -> coerce sha512_update_nblocks
inline_for_extraction noextract
val update_last: #a:sha2_alg -> update_last_vec_t' a Hacl.Spec.SHA2.Vec.M32
let update_last #a =
match a with
| SHA2_224 -> coerce sha224_update_last
| SHA2_256 -> coerce sha256_update_last
| SHA2_384 -> coerce sha384_update_last
| SHA2_512 -> coerce sha512_update_last
inline_for_extraction noextract | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.MultiBuffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.SHA2.Vec.fst.checked",
"Hacl.SHA2.Scalar32.Lemmas.fst.checked",
"Hacl.Impl.SHA2.Generic.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.SHA2.Scalar32.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Impl.SHA2.Generic",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.SHA2.Vec",
"short_module": "SpecVec"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.SHA2.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.MultiBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NTuple",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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"
} | false | Hacl.Impl.SHA2.Generic.finish_vec_t a Hacl.Spec.SHA2.Vec.M32 | Prims.Tot | [
"total"
] | [] | [
"Spec.Hash.Definitions.sha2_alg",
"Hacl.SHA2.Scalar32.coerce",
"Hacl.Impl.SHA2.Generic.finish_vec_t",
"Hacl.Spec.SHA2.Vec.M32",
"Spec.Hash.Definitions.SHA2_224",
"Hacl.SHA2.Scalar32.sha224_finish",
"Spec.Hash.Definitions.SHA2_256",
"Hacl.SHA2.Scalar32.sha256_finish",
"Spec.Hash.Definitions.SHA2_384",
"Hacl.SHA2.Scalar32.sha384_finish",
"Spec.Hash.Definitions.SHA2_512",
"Hacl.SHA2.Scalar32.sha512_finish"
] | [] | false | false | false | false | false | let finish #a =
| match a with
| SHA2_224 -> coerce sha224_finish
| SHA2_256 -> coerce sha256_finish
| SHA2_384 -> coerce sha384_finish
| SHA2_512 -> coerce sha512_finish | false |
Hacl.SHA2.Scalar32.fst | Hacl.SHA2.Scalar32.update_last | val update_last: #a:sha2_alg -> update_last_vec_t' a Hacl.Spec.SHA2.Vec.M32 | val update_last: #a:sha2_alg -> update_last_vec_t' a Hacl.Spec.SHA2.Vec.M32 | let update_last #a =
match a with
| SHA2_224 -> coerce sha224_update_last
| SHA2_256 -> coerce sha256_update_last
| SHA2_384 -> coerce sha384_update_last
| SHA2_512 -> coerce sha512_update_last | {
"file_name": "code/sha2-mb/Hacl.SHA2.Scalar32.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 41,
"end_line": 129,
"start_col": 0,
"start_line": 124
} | module Hacl.SHA2.Scalar32
open FStar.HyperStack.ST
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.NTuple
open Lib.Buffer
open Lib.MultiBuffer
open Spec.Hash.Definitions
open Spec.Agile.Hash
open Hacl.Spec.SHA2.Vec
module SpecVec = Hacl.Spec.SHA2.Vec
open Hacl.Impl.SHA2.Generic
// This module only contains internal helpers that are in support of either the
// full hash function, or the streaming functor. The top-level API is now
// exposed in Hacl.Streaming.SHA2.fst
[@CInline] let sha256_init = init #SHA2_256 #M32
[@CInline] let sha256_update = update #SHA2_256 #M32
[@CInline] let sha256_update_nblocks: update_nblocks_vec_t' SHA2_256 M32 =
update_nblocks #SHA2_256 #M32 sha256_update
[@CInline] let sha256_update_last = update_last #SHA2_256 #M32 sha256_update
[@CInline] let sha256_finish = finish #SHA2_256 #M32
[@CInline] let sha224_init = init #SHA2_224 #M32
inline_for_extraction noextract
val sha224_update: update_vec_t SHA2_224 M32
#push-options "--fuel 0 --ifuel 0 --z3rlimit 20"
let sha224_update b st =
let open Hacl.SHA2.Scalar32.Lemmas in
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_vec_224_256 (as_seq_multi h0 b) (as_seq h0 st);
sha256_update b st
[@CInline]
val sha224_update_nblocks: update_nblocks_vec_t' SHA2_224 M32
let sha224_update_nblocks len b st =
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_nblocks_vec_224_256 len (as_seq_multi h0 b) (as_seq h0 st);
sha256_update_nblocks len b st
val sha224_update_last: update_last_vec_t' SHA2_224 M32
let sha224_update_last totlen len b st =
let open Lib.Sequence in
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_last_vec_224_256
totlen len (as_seq_multi h0 b) (as_seq h0 st);
sha256_update_last totlen len b st
#pop-options
[@CInline] let sha224_finish = finish #SHA2_224 #M32
let sha512_init = init #SHA2_512 #M32
[@CInline] let sha512_update = update #SHA2_512 #M32
[@CInline] let sha512_update_nblocks: update_nblocks_vec_t' SHA2_512 M32 =
update_nblocks #SHA2_512 #M32 sha512_update
[@CInline] let sha512_update_last = update_last #SHA2_512 #M32 sha512_update
[@CInline] let sha512_finish = finish #SHA2_512 #M32
[@CInline] let sha384_init = init #SHA2_384 #M32
inline_for_extraction noextract
val sha384_update: update_vec_t SHA2_384 M32
#push-options "--fuel 0 --ifuel 0 --z3rlimit 20"
let sha384_update b st =
let open Hacl.SHA2.Scalar32.Lemmas in
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_vec_384_512 (as_seq_multi h0 b) (as_seq h0 st);
sha512_update b st
[@CInline]
val sha384_update_nblocks: update_nblocks_vec_t' SHA2_384 M32
let sha384_update_nblocks len b st =
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_nblocks_vec_384_512 len (as_seq_multi h0 b) (as_seq h0 st);
sha512_update_nblocks len b st
val sha384_update_last: update_last_vec_t' SHA2_384 M32
let sha384_update_last totlen len b st =
let open Lib.Sequence in
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_last_vec_384_512
totlen len (as_seq_multi h0 b) (as_seq h0 st);
sha512_update_last totlen len b st
#pop-options
[@CInline] let sha384_finish = finish #SHA2_384 #M32
// Big up for Aymeric who dug this one to help me make the coercion work.
unfold let coerce (#b #a:Type) (x:a{a == b}) : b = x
// Agility patterns for the streaming functor
inline_for_extraction noextract
val init: #a:sha2_alg -> init_vec_t a Hacl.Spec.SHA2.Vec.M32
let init #a =
match a with
| SHA2_224 -> coerce sha224_init
| SHA2_256 -> coerce sha256_init
| SHA2_384 -> coerce sha384_init
| SHA2_512 -> coerce sha512_init
inline_for_extraction noextract
val update_nblocks: #a:sha2_alg -> update_nblocks_vec_t' a Hacl.Spec.SHA2.Vec.M32
let update_nblocks #a =
match a with
| SHA2_224 -> coerce sha224_update_nblocks
| SHA2_256 -> coerce sha256_update_nblocks
| SHA2_384 -> coerce sha384_update_nblocks
| SHA2_512 -> coerce sha512_update_nblocks
inline_for_extraction noextract | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.MultiBuffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.SHA2.Vec.fst.checked",
"Hacl.SHA2.Scalar32.Lemmas.fst.checked",
"Hacl.Impl.SHA2.Generic.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.SHA2.Scalar32.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Impl.SHA2.Generic",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.SHA2.Vec",
"short_module": "SpecVec"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.SHA2.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.MultiBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NTuple",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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"
} | false | Hacl.Impl.SHA2.Generic.update_last_vec_t' a Hacl.Spec.SHA2.Vec.M32 | Prims.Tot | [
"total"
] | [] | [
"Spec.Hash.Definitions.sha2_alg",
"Hacl.SHA2.Scalar32.coerce",
"Hacl.Impl.SHA2.Generic.update_last_vec_t'",
"Hacl.Spec.SHA2.Vec.M32",
"Spec.Hash.Definitions.SHA2_224",
"Hacl.SHA2.Scalar32.sha224_update_last",
"Spec.Hash.Definitions.SHA2_256",
"Hacl.SHA2.Scalar32.sha256_update_last",
"Spec.Hash.Definitions.SHA2_384",
"Hacl.SHA2.Scalar32.sha384_update_last",
"Spec.Hash.Definitions.SHA2_512",
"Hacl.SHA2.Scalar32.sha512_update_last"
] | [] | false | false | false | false | false | let update_last #a =
| match a with
| SHA2_224 -> coerce sha224_update_last
| SHA2_256 -> coerce sha256_update_last
| SHA2_384 -> coerce sha384_update_last
| SHA2_512 -> coerce sha512_update_last | false |
Hacl.SHA2.Scalar32.fst | Hacl.SHA2.Scalar32.sha384_update | val sha384_update: update_vec_t SHA2_384 M32 | val sha384_update: update_vec_t SHA2_384 M32 | let sha384_update b st =
let open Hacl.SHA2.Scalar32.Lemmas in
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_vec_384_512 (as_seq_multi h0 b) (as_seq h0 st);
sha512_update b st | {
"file_name": "code/sha2-mb/Hacl.SHA2.Scalar32.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 20,
"end_line": 78,
"start_col": 0,
"start_line": 74
} | module Hacl.SHA2.Scalar32
open FStar.HyperStack.ST
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.NTuple
open Lib.Buffer
open Lib.MultiBuffer
open Spec.Hash.Definitions
open Spec.Agile.Hash
open Hacl.Spec.SHA2.Vec
module SpecVec = Hacl.Spec.SHA2.Vec
open Hacl.Impl.SHA2.Generic
// This module only contains internal helpers that are in support of either the
// full hash function, or the streaming functor. The top-level API is now
// exposed in Hacl.Streaming.SHA2.fst
[@CInline] let sha256_init = init #SHA2_256 #M32
[@CInline] let sha256_update = update #SHA2_256 #M32
[@CInline] let sha256_update_nblocks: update_nblocks_vec_t' SHA2_256 M32 =
update_nblocks #SHA2_256 #M32 sha256_update
[@CInline] let sha256_update_last = update_last #SHA2_256 #M32 sha256_update
[@CInline] let sha256_finish = finish #SHA2_256 #M32
[@CInline] let sha224_init = init #SHA2_224 #M32
inline_for_extraction noextract
val sha224_update: update_vec_t SHA2_224 M32
#push-options "--fuel 0 --ifuel 0 --z3rlimit 20"
let sha224_update b st =
let open Hacl.SHA2.Scalar32.Lemmas in
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_vec_224_256 (as_seq_multi h0 b) (as_seq h0 st);
sha256_update b st
[@CInline]
val sha224_update_nblocks: update_nblocks_vec_t' SHA2_224 M32
let sha224_update_nblocks len b st =
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_nblocks_vec_224_256 len (as_seq_multi h0 b) (as_seq h0 st);
sha256_update_nblocks len b st
val sha224_update_last: update_last_vec_t' SHA2_224 M32
let sha224_update_last totlen len b st =
let open Lib.Sequence in
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_last_vec_224_256
totlen len (as_seq_multi h0 b) (as_seq h0 st);
sha256_update_last totlen len b st
#pop-options
[@CInline] let sha224_finish = finish #SHA2_224 #M32
let sha512_init = init #SHA2_512 #M32
[@CInline] let sha512_update = update #SHA2_512 #M32
[@CInline] let sha512_update_nblocks: update_nblocks_vec_t' SHA2_512 M32 =
update_nblocks #SHA2_512 #M32 sha512_update
[@CInline] let sha512_update_last = update_last #SHA2_512 #M32 sha512_update
[@CInline] let sha512_finish = finish #SHA2_512 #M32
[@CInline] let sha384_init = init #SHA2_384 #M32
inline_for_extraction noextract
val sha384_update: update_vec_t SHA2_384 M32 | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.MultiBuffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.SHA2.Vec.fst.checked",
"Hacl.SHA2.Scalar32.Lemmas.fst.checked",
"Hacl.Impl.SHA2.Generic.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.SHA2.Scalar32.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Impl.SHA2.Generic",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.SHA2.Vec",
"short_module": "SpecVec"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.SHA2.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.MultiBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NTuple",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 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": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Hacl.Impl.SHA2.Generic.update_vec_t Spec.Hash.Definitions.SHA2_384 Hacl.Spec.SHA2.Vec.M32 | Prims.Tot | [
"total"
] | [] | [
"Lib.MultiBuffer.multibuf",
"Hacl.Spec.SHA2.Vec.lanes",
"Spec.Hash.Definitions.SHA2_384",
"Hacl.Spec.SHA2.Vec.M32",
"Hacl.Hash.Definitions.block_len",
"Hacl.Impl.SHA2.Core.state_t",
"Hacl.SHA2.Scalar32.sha512_update",
"Prims.unit",
"Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_vec_384_512",
"Lib.MultiBuffer.as_seq_multi",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Hacl.Spec.SHA2.Vec.element_t",
"FStar.UInt32.__uint_to_t",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get"
] | [] | false | false | false | true | false | let sha384_update b st =
| let open Hacl.SHA2.Scalar32.Lemmas in
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_vec_384_512 (as_seq_multi h0 b) (as_seq h0 st);
sha512_update b st | false |
Hacl.SHA2.Scalar32.fst | Hacl.SHA2.Scalar32.sha384_update_last | val sha384_update_last: update_last_vec_t' SHA2_384 M32 | val sha384_update_last: update_last_vec_t' SHA2_384 M32 | let sha384_update_last totlen len b st =
let open Lib.Sequence in
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_last_vec_384_512
totlen len (as_seq_multi h0 b) (as_seq h0 st);
sha512_update_last totlen len b st | {
"file_name": "code/sha2-mb/Hacl.SHA2.Scalar32.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 36,
"end_line": 94,
"start_col": 0,
"start_line": 89
} | module Hacl.SHA2.Scalar32
open FStar.HyperStack.ST
module ST = FStar.HyperStack.ST
open Lib.IntTypes
open Lib.NTuple
open Lib.Buffer
open Lib.MultiBuffer
open Spec.Hash.Definitions
open Spec.Agile.Hash
open Hacl.Spec.SHA2.Vec
module SpecVec = Hacl.Spec.SHA2.Vec
open Hacl.Impl.SHA2.Generic
// This module only contains internal helpers that are in support of either the
// full hash function, or the streaming functor. The top-level API is now
// exposed in Hacl.Streaming.SHA2.fst
[@CInline] let sha256_init = init #SHA2_256 #M32
[@CInline] let sha256_update = update #SHA2_256 #M32
[@CInline] let sha256_update_nblocks: update_nblocks_vec_t' SHA2_256 M32 =
update_nblocks #SHA2_256 #M32 sha256_update
[@CInline] let sha256_update_last = update_last #SHA2_256 #M32 sha256_update
[@CInline] let sha256_finish = finish #SHA2_256 #M32
[@CInline] let sha224_init = init #SHA2_224 #M32
inline_for_extraction noextract
val sha224_update: update_vec_t SHA2_224 M32
#push-options "--fuel 0 --ifuel 0 --z3rlimit 20"
let sha224_update b st =
let open Hacl.SHA2.Scalar32.Lemmas in
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_vec_224_256 (as_seq_multi h0 b) (as_seq h0 st);
sha256_update b st
[@CInline]
val sha224_update_nblocks: update_nblocks_vec_t' SHA2_224 M32
let sha224_update_nblocks len b st =
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_nblocks_vec_224_256 len (as_seq_multi h0 b) (as_seq h0 st);
sha256_update_nblocks len b st
val sha224_update_last: update_last_vec_t' SHA2_224 M32
let sha224_update_last totlen len b st =
let open Lib.Sequence in
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_last_vec_224_256
totlen len (as_seq_multi h0 b) (as_seq h0 st);
sha256_update_last totlen len b st
#pop-options
[@CInline] let sha224_finish = finish #SHA2_224 #M32
let sha512_init = init #SHA2_512 #M32
[@CInline] let sha512_update = update #SHA2_512 #M32
[@CInline] let sha512_update_nblocks: update_nblocks_vec_t' SHA2_512 M32 =
update_nblocks #SHA2_512 #M32 sha512_update
[@CInline] let sha512_update_last = update_last #SHA2_512 #M32 sha512_update
[@CInline] let sha512_finish = finish #SHA2_512 #M32
[@CInline] let sha384_init = init #SHA2_384 #M32
inline_for_extraction noextract
val sha384_update: update_vec_t SHA2_384 M32
#push-options "--fuel 0 --ifuel 0 --z3rlimit 20"
let sha384_update b st =
let open Hacl.SHA2.Scalar32.Lemmas in
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_vec_384_512 (as_seq_multi h0 b) (as_seq h0 st);
sha512_update b st
[@CInline]
val sha384_update_nblocks: update_nblocks_vec_t' SHA2_384 M32
let sha384_update_nblocks len b st =
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_nblocks_vec_384_512 len (as_seq_multi h0 b) (as_seq h0 st);
sha512_update_nblocks len b st
val sha384_update_last: update_last_vec_t' SHA2_384 M32 | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.MultiBuffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.SHA2.Vec.fst.checked",
"Hacl.SHA2.Scalar32.Lemmas.fst.checked",
"Hacl.Impl.SHA2.Generic.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.SHA2.Scalar32.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Impl.SHA2.Generic",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.SHA2.Vec",
"short_module": "SpecVec"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.SHA2.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.MultiBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NTuple",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 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": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Hacl.Impl.SHA2.Generic.update_last_vec_t' Spec.Hash.Definitions.SHA2_384 Hacl.Spec.SHA2.Vec.M32 | Prims.Tot | [
"total"
] | [] | [
"Spec.Hash.Definitions.len_t",
"Spec.Hash.Definitions.SHA2_384",
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Spec.Hash.Definitions.block_length",
"Lib.MultiBuffer.multibuf",
"Hacl.Spec.SHA2.Vec.lanes",
"Hacl.Spec.SHA2.Vec.M32",
"Hacl.Impl.SHA2.Core.state_t",
"Hacl.SHA2.Scalar32.sha512_update_last",
"Prims.unit",
"Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_last_vec_384_512",
"Lib.MultiBuffer.as_seq_multi",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Hacl.Spec.SHA2.Vec.element_t",
"FStar.UInt32.__uint_to_t",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get"
] | [] | false | false | false | true | false | let sha384_update_last totlen len b st =
| let open Lib.Sequence in
let h0 = ST.get () in
Hacl.SHA2.Scalar32.Lemmas.lemma_spec_update_last_vec_384_512 totlen
len
(as_seq_multi h0 b)
(as_seq h0 st);
sha512_update_last totlen len b st | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.bn_eval_sub | val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t)))) | val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t)))) | let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen) | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 56,
"end_line": 92,
"start_col": 0,
"start_line": 82
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t)))) | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
modBits: Lib.IntTypes.size_pos{1 < modBits} ->
m:
Hacl.Spec.Bignum.Definitions.lbignum t
(Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t))
-> FStar.Pervasives.Lemma
(requires
Hacl.Spec.Bignum.Definitions.bn_v m <
Prims.pow2 (8 * Hacl.Spec.Bignum.Definitions.blocks (modBits - 1) 8))
(ensures
Hacl.Spec.Bignum.Definitions.bn_v m ==
Hacl.Spec.Bignum.Definitions.bn_v (Lib.Sequence.sub m
0
(Hacl.Spec.Bignum.Definitions.blocks (Hacl.Spec.Bignum.Definitions.blocks (modBits - 1
)
8)
(Lib.IntTypes.numbytes t)))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.bits",
"FStar.Math.Lemmas.pow2_le_compat",
"FStar.Mul.op_Star",
"Prims.unit",
"Prims._assert",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.pow2",
"Hacl.Spec.Bignum.Definitions.bn_eval_bound",
"Prims.eq2",
"Prims.int",
"Prims.op_Addition",
"Prims.op_Subtraction",
"Lib.Sequence.slice",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Definitions.bn_eval_split_i",
"Lib.Sequence.lseq",
"Prims.l_and",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.Sequence.sub",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"Prims.op_Multiply",
"Lib.IntTypes.numbytes"
] | [] | true | false | true | false | false | let bn_eval_sub #t modBits m =
| let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen) | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_verify_pre | val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0 | val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0 | let rsapss_verify_pre a sLen msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 39,
"end_line": 238,
"start_col": 0,
"start_line": 235
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)
val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0 | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
sLen: Lib.IntTypes.size_nat ->
msgLen: Prims.nat ->
msg: Lib.Sequence.seq Lib.IntTypes.uint8 {Lib.Sequence.length msg == msgLen}
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Lib.IntTypes.size_nat",
"Prims.nat",
"Lib.Sequence.seq",
"Lib.IntTypes.uint8",
"Prims.eq2",
"Lib.Sequence.length",
"Prims.l_and",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Spec.Hash.Definitions.hash_length",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.RSAPSS.less_than_max_input_length"
] | [] | false | false | false | false | true | let rsapss_verify_pre a sLen msgLen msg =
| sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_verify_post | val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0 | val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0 | let rsapss_verify_post #t a modBits eBits pkey sLen sgnt msgLen msg verify =
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify_ a modBits pkeys sLen sgnt msgLen msg) | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 66,
"end_line": 263,
"start_col": 0,
"start_line": 253
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)
val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
let rsapss_verify_pre a sLen msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a
val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0 | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat{Hacl.Spec.RSAPSS.pkey_len_pre t modBits eBits} ->
pkey:
Hacl.Spec.Bignum.Definitions.lbignum t
(2 * Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks eBits (Lib.IntTypes.bits t)) ->
sLen: Lib.IntTypes.size_nat ->
sgnt: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks modBits 8) ->
msgLen: Prims.nat ->
msg: Lib.Sequence.seq Lib.IntTypes.uint8 {Lib.Sequence.length msg == msgLen} ->
verify: Prims.bool
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Lib.IntTypes.size_nat",
"Hacl.Spec.RSAPSS.pkey_len_pre",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.bits",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Prims.nat",
"Lib.Sequence.seq",
"Prims.eq2",
"Lib.Sequence.length",
"Prims.bool",
"Prims.l_and",
"Hacl.Spec.RSAPSS.rsapss_verify_pre",
"Hacl.Spec.RSAPSS.rsapss_pkey_pre",
"Spec.RSAPSS.rsapss_verify_",
"Spec.RSAPSS.rsapss_pkey",
"Spec.RSAPSS.Mk_rsapss_pkey",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Lib.Sequence.sub",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_Multiply",
"Prims.int"
] | [] | false | false | false | false | true | let rsapss_verify_post #t a modBits eBits pkey sLen sgnt msgLen msg verify =
| rsapss_verify_pre a sLen msgLen msg /\ rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys:S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify_ a modBits pkeys sLen sgnt msgLen msg) | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_verify_post1 | val rsapss_verify_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0 | val rsapss_verify_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0 | let rsapss_verify_post1 #t a modBits eBits pkey sLen k sgnt msgLen msg verify =
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify a modBits pkeys sLen k sgnt msgLen msg) | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 67,
"end_line": 288,
"start_col": 0,
"start_line": 279
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)
val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
let rsapss_verify_pre a sLen msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a
val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post #t a modBits eBits pkey sLen sgnt msgLen msg verify =
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify_ a modBits pkeys sLen sgnt msgLen msg)
val rsapss_verify_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0 | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat{Hacl.Spec.RSAPSS.pkey_len_pre t modBits eBits} ->
pkey:
Hacl.Spec.Bignum.Definitions.lbignum t
(2 * Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks eBits (Lib.IntTypes.bits t)) ->
sLen: Lib.IntTypes.size_nat ->
k: Lib.IntTypes.size_nat ->
sgnt: Lib.Sequence.lseq Lib.IntTypes.uint8 k ->
msgLen: Prims.nat ->
msg: Lib.Sequence.seq Lib.IntTypes.uint8 {Lib.Sequence.length msg == msgLen} ->
verify: Prims.bool
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Lib.IntTypes.size_nat",
"Hacl.Spec.RSAPSS.pkey_len_pre",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.bits",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Prims.nat",
"Lib.Sequence.seq",
"Prims.eq2",
"Lib.Sequence.length",
"Prims.bool",
"Prims.l_and",
"Hacl.Spec.RSAPSS.rsapss_pkey_pre",
"Spec.RSAPSS.rsapss_verify",
"Spec.RSAPSS.rsapss_pkey",
"Spec.RSAPSS.Mk_rsapss_pkey",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Lib.Sequence.sub",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_Multiply",
"Prims.int"
] | [] | false | false | false | false | true | let rsapss_verify_post1 #t a modBits eBits pkey sLen k sgnt msgLen msg verify =
| rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys:S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify a modBits pkeys sLen k sgnt msgLen msg) | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_sign_post1 | val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0 | val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0 | let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s) | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 72,
"end_line": 226,
"start_col": 0,
"start_line": 213
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0 | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat ->
dBits: Lib.IntTypes.size_nat{Hacl.Spec.RSAPSS.skey_len_pre t modBits eBits dBits} ->
skey:
Hacl.Spec.Bignum.Definitions.lbignum t
(2 * Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks eBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks dBits (Lib.IntTypes.bits t)) ->
sLen: Lib.IntTypes.size_nat ->
salt: Lib.Sequence.lseq Lib.IntTypes.uint8 sLen ->
msgLen: Prims.nat ->
msg: Lib.Sequence.seq Lib.IntTypes.uint8 {Lib.Sequence.length msg == msgLen} ->
eq_m: Prims.bool ->
sgnt: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks modBits 8)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Lib.IntTypes.size_nat",
"Hacl.Spec.RSAPSS.skey_len_pre",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.bits",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Prims.nat",
"Lib.Sequence.seq",
"Prims.eq2",
"Lib.Sequence.length",
"Prims.bool",
"Prims.l_and",
"Hacl.Spec.RSAPSS.rsapss_skey_pre",
"FStar.Pervasives.Native.uu___is_Some",
"Lib.ByteSequence.lbytes",
"Spec.RSAPSS.blocks",
"FStar.Pervasives.Native.__proj__Some__item__v",
"FStar.Pervasives.Native.uu___is_None",
"Prims.logical",
"FStar.Pervasives.Native.option",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.RSAPSS.rsapss_sign",
"Spec.RSAPSS.rsapss_skey",
"Spec.RSAPSS.Mk_rsapss_skey",
"Spec.RSAPSS.rsapss_pkey",
"Spec.RSAPSS.Mk_rsapss_pkey",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Lib.Sequence.sub",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_Multiply",
"Prims.int"
] | [] | false | false | false | false | true | let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
| rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys:S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys:S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s) | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.bn_lt_pow2_lemma | val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8))) | val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8))) | let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 44,
"end_line": 75,
"start_col": 0,
"start_line": 61
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8))) | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
modBits: Lib.IntTypes.size_pos{1 < modBits} ->
m:
Hacl.Spec.Bignum.Definitions.lbignum t
(Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t))
-> FStar.Pervasives.Lemma (requires Hacl.Spec.Bignum.Definitions.bn_v m < Prims.pow2 modBits)
(ensures
Hacl.Spec.RSAPSS.bn_lt_pow2 modBits m ==
(Hacl.Spec.Bignum.Definitions.bn_v m <
Prims.pow2 (8 * Hacl.Spec.Bignum.Definitions.blocks (modBits - 1) 8))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.bits",
"Prims.op_disEquality",
"Prims.int",
"Prims.op_Modulus",
"Prims.op_Subtraction",
"FStar.Math.Lemmas.pow2_le_compat",
"FStar.Mul.op_Star",
"Prims.bool",
"Hacl.Spec.Bignum.bn_get_ith_bit_lemma",
"Prims.unit",
"Hacl.Spec.RSAPSS.bn_eval_lt_pow2_modBits",
"Prims._assert",
"Prims.eq2",
"Prims.op_Addition",
"Hacl.Spec.Bignum.Definitions.bn_eval_unfold_i",
"Prims.l_or",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.numbytes",
"Prims.pos",
"Prims.pow2",
"Prims.op_Multiply"
] | [] | false | false | true | false | false | let bn_lt_pow2_lemma #t modBits m =
| let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0
then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else
(assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1)) | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_pkey_pre | val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0 | val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0 | let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 35,
"end_line": 127,
"start_col": 0,
"start_line": 116
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0 | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat{Hacl.Spec.RSAPSS.pkey_len_pre t modBits eBits} ->
pkey:
Hacl.Spec.Bignum.Definitions.lbignum t
(2 * Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks eBits (Lib.IntTypes.bits t))
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.RSAPSS.pkey_len_pre",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.bits",
"Prims.l_and",
"Prims.eq2",
"Lib.Sequence.lseq",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Montgomery.bn_precomp_r2_mod_n",
"Prims.op_Subtraction",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.op_LessThan",
"Prims.pow2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.op_Multiply",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.Sequence.sub",
"Prims.pos",
"Prims.op_LessThanOrEqual"
] | [] | false | false | false | false | true | let rsapss_pkey_pre #t modBits eBits pkey =
| let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\ bn_v n % 2 = 1 /\ pow2 (modBits - 1) < bn_v n /\
bn_v n < pow2 modBits /\ 0 < bn_v e /\ bn_v e < pow2 eBits | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.bn_eval_lt_pow2_modBits | val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1)) | val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1)) | let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
} | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 54,
"start_col": 0,
"start_line": 43
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1)) | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
modBits: Lib.IntTypes.size_pos{1 < modBits} ->
m:
Hacl.Spec.Bignum.Definitions.lbignum t
(Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t))
-> FStar.Pervasives.Lemma (requires Hacl.Spec.Bignum.Definitions.bn_v m < Prims.pow2 modBits)
(ensures
Hacl.Spec.Bignum.Definitions.bn_v m ==
(Hacl.Spec.Bignum.Definitions.bn_v m / Prims.pow2 (modBits - 1) % 2) *
Prims.pow2 (modBits - 1) +
Hacl.Spec.Bignum.Definitions.bn_v m % Prims.pow2 (modBits - 1)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.bits",
"FStar.Calc.calc_finish",
"Prims.nat",
"Prims.eq2",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.op_Modulus",
"Prims.op_Division",
"Prims.pow2",
"Prims.op_Subtraction",
"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.pow2_plus",
"FStar.Math.Lemmas.division_multiplication_lemma",
"FStar.Math.Lemmas.small_division_lemma_1"
] | [] | false | false | true | false | false | let bn_eval_lt_pow2_modBits #t modBits m =
| calc ( == ) {
bn_v m;
( == ) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
(bn_v m / pow2 (modBits - 1)) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
( == ) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
((bn_v m / pow2 (modBits - 1) / 2) * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) +
bn_v m % pow2 (modBits - 1);
( == ) { (Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2;
Math.Lemmas.pow2_plus (modBits - 1) 1) }
((bn_v m / pow2 modBits) * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) +
bn_v m % pow2 (modBits - 1);
( == ) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
} | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.igsub_inj | val igsub_inj : b1:
LowStar.Monotonic.Buffer.mbuffer a
(LowStar.ImmutableBuffer.immutable_preorder a)
(LowStar.ImmutableBuffer.immutable_preorder a) ->
b2:
LowStar.Monotonic.Buffer.mbuffer a
(LowStar.ImmutableBuffer.immutable_preorder a)
(LowStar.ImmutableBuffer.immutable_preorder a) ->
i1: FStar.UInt32.t ->
i2: FStar.UInt32.t ->
len1: FStar.UInt32.t ->
len2: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
FStar.UInt32.v i1 + FStar.UInt32.v len1 <= LowStar.Monotonic.Buffer.length b1 /\
FStar.UInt32.v i2 + FStar.UInt32.v len2 <= LowStar.Monotonic.Buffer.length b2 /\
LowStar.Monotonic.Buffer.mgsub (LowStar.ImmutableBuffer.immutable_preorder a) b1 i1 len1 ===
LowStar.Monotonic.Buffer.mgsub (LowStar.ImmutableBuffer.immutable_preorder a) b2 i2 len2)
(ensures
len1 == len2 /\ (b1 == b2 ==> i1 == i2) /\
(i1 == i2 /\ LowStar.Monotonic.Buffer.length b1 == LowStar.Monotonic.Buffer.length b2 ==>
b1 == b2)) | let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a) | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 140,
"end_line": 36,
"start_col": 7,
"start_line": 36
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a)
unfold let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b1:
LowStar.Monotonic.Buffer.mbuffer a
(LowStar.ImmutableBuffer.immutable_preorder a)
(LowStar.ImmutableBuffer.immutable_preorder a) ->
b2:
LowStar.Monotonic.Buffer.mbuffer a
(LowStar.ImmutableBuffer.immutable_preorder a)
(LowStar.ImmutableBuffer.immutable_preorder a) ->
i1: FStar.UInt32.t ->
i2: FStar.UInt32.t ->
len1: FStar.UInt32.t ->
len2: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
FStar.UInt32.v i1 + FStar.UInt32.v len1 <= LowStar.Monotonic.Buffer.length b1 /\
FStar.UInt32.v i2 + FStar.UInt32.v len2 <= LowStar.Monotonic.Buffer.length b2 /\
LowStar.Monotonic.Buffer.mgsub (LowStar.ImmutableBuffer.immutable_preorder a) b1 i1 len1 ===
LowStar.Monotonic.Buffer.mgsub (LowStar.ImmutableBuffer.immutable_preorder a) b2 i2 len2)
(ensures
len1 == len2 /\ (b1 == b2 ==> i1 == i2) /\
(i1 == i2 /\ LowStar.Monotonic.Buffer.length b1 == LowStar.Monotonic.Buffer.length b2 ==>
b1 == b2)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.Monotonic.Buffer.mgsub_inj",
"LowStar.ImmutableBuffer.immutable_preorder",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"FStar.UInt32.v",
"LowStar.Monotonic.Buffer.length",
"Prims.op_Equals_Equals_Equals",
"LowStar.Monotonic.Buffer.mgsub",
"Prims.squash",
"Prims.eq2",
"Prims.l_imp",
"Prims.nat",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let igsub_inj (#a: Type0) =
| mgsub_inj #a
#(immutable_preorder a)
#(immutable_preorder a)
(immutable_preorder a)
(immutable_preorder a) | false |
|
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_sign_post | val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0 | val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0 | let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s) | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 35,
"end_line": 196,
"start_col": 0,
"start_line": 182
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0 | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat ->
dBits: Lib.IntTypes.size_nat{Hacl.Spec.RSAPSS.skey_len_pre t modBits eBits dBits} ->
skey:
Hacl.Spec.Bignum.Definitions.lbignum t
(2 * Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks eBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks dBits (Lib.IntTypes.bits t)) ->
sLen: Lib.IntTypes.size_nat ->
salt: Lib.Sequence.lseq Lib.IntTypes.uint8 sLen ->
msgLen: Prims.nat ->
msg: Lib.Sequence.seq Lib.IntTypes.uint8 {Lib.Sequence.length msg == msgLen} ->
eq_m: Prims.bool ->
sgnt: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks modBits 8)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Lib.IntTypes.size_nat",
"Hacl.Spec.RSAPSS.skey_len_pre",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.bits",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Prims.nat",
"Lib.Sequence.seq",
"Prims.eq2",
"Lib.Sequence.length",
"Prims.bool",
"Prims.l_and",
"Hacl.Spec.RSAPSS.rsapss_sign_pre",
"Hacl.Spec.RSAPSS.rsapss_skey_pre",
"Lib.ByteSequence.lbytes",
"Spec.RSAPSS.blocks",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.logical",
"FStar.Pervasives.Native.tuple2",
"Lib.IntTypes.int_t",
"Spec.RSAPSS.rsapss_sign_",
"Spec.RSAPSS.rsapss_skey",
"Spec.RSAPSS.Mk_rsapss_skey",
"Spec.RSAPSS.rsapss_pkey",
"Spec.RSAPSS.Mk_rsapss_pkey",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Lib.Sequence.sub",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_Multiply",
"Prims.int"
] | [] | false | false | false | false | true | let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
| rsapss_sign_pre a modBits sLen salt msgLen msg /\ rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys:S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys:S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s) | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.inull | val inull (#a: Type0) : ibuffer a | val inull (#a: Type0) : ibuffer a | let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a) | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 97,
"end_line": 32,
"start_col": 7,
"start_line": 32
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | LowStar.ImmutableBuffer.ibuffer a | Prims.Tot | [
"total"
] | [] | [
"LowStar.Monotonic.Buffer.mnull",
"LowStar.ImmutableBuffer.immutable_preorder",
"LowStar.ImmutableBuffer.ibuffer"
] | [] | false | false | false | true | false | let inull (#a: Type0) : ibuffer a =
| mnull #a #(immutable_preorder a) #(immutable_preorder a) | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.igsub | val igsub : b:
LowStar.Monotonic.Buffer.mbuffer a
(LowStar.ImmutableBuffer.immutable_preorder a)
(LowStar.ImmutableBuffer.immutable_preorder a) ->
i: FStar.UInt32.t ->
len: FStar.UInt32.t
-> Prims.Ghost
(LowStar.Monotonic.Buffer.mbuffer a
(LowStar.ImmutableBuffer.immutable_preorder a)
(LowStar.ImmutableBuffer.immutable_preorder a)) | let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 109,
"end_line": 34,
"start_col": 7,
"start_line": 34
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b:
LowStar.Monotonic.Buffer.mbuffer a
(LowStar.ImmutableBuffer.immutable_preorder a)
(LowStar.ImmutableBuffer.immutable_preorder a) ->
i: FStar.UInt32.t ->
len: FStar.UInt32.t
-> Prims.Ghost
(LowStar.Monotonic.Buffer.mbuffer a
(LowStar.ImmutableBuffer.immutable_preorder a)
(LowStar.ImmutableBuffer.immutable_preorder a)) | Prims.Ghost | [] | [] | [
"LowStar.Monotonic.Buffer.mgsub",
"LowStar.ImmutableBuffer.immutable_preorder",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"FStar.UInt32.v",
"LowStar.Monotonic.Buffer.length",
"Prims.l_True"
] | [] | false | false | false | false | false | let igsub (#a: Type0) =
| mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) | false |
|
Steel.ST.MonotonicReference.fst | Steel.ST.MonotonicReference.ref | val ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0 | val ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0 | let ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0
= MR.ref a p | {
"file_name": "lib/steel/Steel.ST.MonotonicReference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 14,
"end_line": 26,
"start_col": 0,
"start_line": 24
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.ST.MonotonicReference
open FStar.Ghost
open Steel.ST.Util
open Steel.ST.Coercions
module Preorder = FStar.Preorder
module MR = Steel.MonotonicReference | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Coercions.fsti.checked",
"Steel.MonotonicReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.MonotonicReference.fst"
} | [
{
"abbrev": true,
"full_module": "Steel.MonotonicReference",
"short_module": "MR"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Coercions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Type0 -> p: FStar.Preorder.preorder a -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Preorder.preorder",
"Steel.MonotonicReference.ref"
] | [] | false | false | false | true | true | let ref (a: Type u#0) (p: Preorder.preorder a) : Type u#0 =
| MR.ref a p | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.isub | val isub : b:
LowStar.Monotonic.Buffer.mbuffer a
(LowStar.ImmutableBuffer.immutable_preorder a)
(LowStar.ImmutableBuffer.immutable_preorder a) ->
i: FStar.UInt32.t ->
len: FStar.Ghost.erased FStar.UInt32.t
-> FStar.HyperStack.ST.Stack
(LowStar.Monotonic.Buffer.mbuffer a
(LowStar.ImmutableBuffer.immutable_preorder a)
(LowStar.ImmutableBuffer.immutable_preorder a)) | let isub (#a:Type0) = msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 122,
"end_line": 44,
"start_col": 22,
"start_line": 44
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a)
unfold let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
unfold let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a)
inline_for_extraction
type ipointer (a:Type0) = b:ibuffer a{length b == 1}
inline_for_extraction
type ipointer_or_null (a:Type0) = b:ibuffer a{if g_is_null b then True else length b == 1} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b:
LowStar.Monotonic.Buffer.mbuffer a
(LowStar.ImmutableBuffer.immutable_preorder a)
(LowStar.ImmutableBuffer.immutable_preorder a) ->
i: FStar.UInt32.t ->
len: FStar.Ghost.erased FStar.UInt32.t
-> FStar.HyperStack.ST.Stack
(LowStar.Monotonic.Buffer.mbuffer a
(LowStar.ImmutableBuffer.immutable_preorder a)
(LowStar.ImmutableBuffer.immutable_preorder a)) | FStar.HyperStack.ST.Stack | [] | [] | [
"LowStar.Monotonic.Buffer.msub",
"LowStar.ImmutableBuffer.immutable_preorder",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"FStar.Ghost.erased",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"FStar.UInt32.v",
"FStar.Ghost.reveal",
"LowStar.Monotonic.Buffer.length",
"Prims.l_Forall",
"FStar.Seq.Base.seq",
"Prims.l_imp",
"Prims.eq2",
"Prims.nat",
"FStar.Seq.Base.length",
"FStar.Seq.Base.slice",
"Prims.int",
"Prims.op_Subtraction",
"FStar.Seq.Properties.replace_subseq",
"LowStar.Monotonic.Buffer.live",
"LowStar.Monotonic.Buffer.mgsub"
] | [] | false | true | false | false | false | let isub (#a: Type0) =
| msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) | false |
|
Steel.ST.MonotonicReference.fst | Steel.ST.MonotonicReference.witnessed | val witnessed (#a:Type u#0) (#p:Preorder.preorder a) (r:ref a p) (fact:property a)
: Type0 | val witnessed (#a:Type u#0) (#p:Preorder.preorder a) (r:ref a p) (fact:property a)
: Type0 | let witnessed (#a:Type u#0)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:property a)
: Type0
= MR.witnessed r fact | {
"file_name": "lib/steel/Steel.ST.MonotonicReference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 23,
"end_line": 55,
"start_col": 0,
"start_line": 50
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.ST.MonotonicReference
open FStar.Ghost
open Steel.ST.Util
open Steel.ST.Coercions
module Preorder = FStar.Preorder
module MR = Steel.MonotonicReference
let ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0
= MR.ref a p
let pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
([@@@smt_fallback]f:perm)
([@@@smt_fallback]v:a)
: vprop
= MR.pts_to #a #p r f v
let alloc (#a:Type) (p:Preorder.preorder a) (v:a)
: STT (ref a p) emp (fun r -> pts_to r full_perm v)
= let x = coerce_steel (fun _ -> MR.alloc p v) in
return x
let write (#a:Type) (#p:Preorder.preorder a) (#v:erased a)
(r:ref a p) (x:a)
: ST unit
(pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires p v x)
(ensures fun _ -> True)
= coerce_steel (fun _ -> MR.write r x) | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Coercions.fsti.checked",
"Steel.MonotonicReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.MonotonicReference.fst"
} | [
{
"abbrev": true,
"full_module": "Steel.MonotonicReference",
"short_module": "MR"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Coercions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.ST.MonotonicReference.ref a p -> fact: Steel.ST.MonotonicReference.property a -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Preorder.preorder",
"Steel.ST.MonotonicReference.ref",
"Steel.ST.MonotonicReference.property",
"Steel.MonotonicReference.witnessed"
] | [] | false | false | false | false | true | let witnessed (#a: Type u#0) (#p: Preorder.preorder a) (r: ref a p) (fact: property a) : Type0 =
| MR.witnessed r fact | false |
Steel.ST.MonotonicReference.fst | Steel.ST.MonotonicReference.pts_to | val pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
([@@@smt_fallback]f:perm)
([@@@smt_fallback]v:a)
: vprop | val pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
([@@@smt_fallback]f:perm)
([@@@smt_fallback]v:a)
: vprop | let pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
([@@@smt_fallback]f:perm)
([@@@smt_fallback]v:a)
: vprop
= MR.pts_to #a #p r f v | {
"file_name": "lib/steel/Steel.ST.MonotonicReference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 26,
"end_line": 34,
"start_col": 0,
"start_line": 28
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.ST.MonotonicReference
open FStar.Ghost
open Steel.ST.Util
open Steel.ST.Coercions
module Preorder = FStar.Preorder
module MR = Steel.MonotonicReference
let ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0
= MR.ref a p | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Coercions.fsti.checked",
"Steel.MonotonicReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.MonotonicReference.fst"
} | [
{
"abbrev": true,
"full_module": "Steel.MonotonicReference",
"short_module": "MR"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Coercions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.ST.MonotonicReference.ref a p -> f: Steel.FractionalPermission.perm -> v: a
-> Steel.Effect.Common.vprop | Prims.Tot | [
"total"
] | [] | [
"FStar.Preorder.preorder",
"Steel.ST.MonotonicReference.ref",
"Steel.FractionalPermission.perm",
"Steel.MonotonicReference.pts_to",
"Steel.Effect.Common.vprop"
] | [] | false | false | false | false | false | let pts_to
(#a: Type)
(#p: Preorder.preorder a)
(r: ref a p)
([@@@ smt_fallback]f: perm)
([@@@ smt_fallback]v: a)
: vprop =
| MR.pts_to #a #p r f v | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.ioffset | val ioffset : b:
LowStar.Monotonic.Buffer.mbuffer a
(LowStar.ImmutableBuffer.immutable_preorder a)
(LowStar.ImmutableBuffer.immutable_preorder a) ->
i: FStar.UInt32.t
-> FStar.HyperStack.ST.Stack
(LowStar.Monotonic.Buffer.mbuffer a
(LowStar.ImmutableBuffer.immutable_preorder a)
(LowStar.ImmutableBuffer.immutable_preorder a)) | let ioffset (#a:Type0) = moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 128,
"end_line": 46,
"start_col": 22,
"start_line": 46
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a)
unfold let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
unfold let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a)
inline_for_extraction
type ipointer (a:Type0) = b:ibuffer a{length b == 1}
inline_for_extraction
type ipointer_or_null (a:Type0) = b:ibuffer a{if g_is_null b then True else length b == 1}
inline_for_extraction let isub (#a:Type0) = msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b:
LowStar.Monotonic.Buffer.mbuffer a
(LowStar.ImmutableBuffer.immutable_preorder a)
(LowStar.ImmutableBuffer.immutable_preorder a) ->
i: FStar.UInt32.t
-> FStar.HyperStack.ST.Stack
(LowStar.Monotonic.Buffer.mbuffer a
(LowStar.ImmutableBuffer.immutable_preorder a)
(LowStar.ImmutableBuffer.immutable_preorder a)) | FStar.HyperStack.ST.Stack | [] | [] | [
"LowStar.Monotonic.Buffer.moffset",
"LowStar.ImmutableBuffer.immutable_preorder",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowStar.Monotonic.Buffer.length",
"Prims.l_Forall",
"FStar.Seq.Base.seq",
"Prims.l_imp",
"Prims.eq2",
"Prims.nat",
"FStar.Seq.Base.length",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"FStar.UInt32.sub",
"LowStar.Monotonic.Buffer.len",
"Prims.int",
"Prims.op_Subtraction",
"FStar.Seq.Properties.replace_subseq",
"LowStar.Monotonic.Buffer.live",
"LowStar.Monotonic.Buffer.mgsub"
] | [] | false | true | false | false | false | let ioffset (#a: Type0) =
| moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) | false |
|
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_check_exponent | val rsapss_check_exponent: #t:limb_t -> eBits:size_pos -> e:lbignum t (blocks eBits (bits t)) ->
res:limb t{v res == (if (0 < bn_v e && bn_v e < pow2 eBits) then v (ones t SEC) else v (zeros t SEC))} | val rsapss_check_exponent: #t:limb_t -> eBits:size_pos -> e:lbignum t (blocks eBits (bits t)) ->
res:limb t{v res == (if (0 < bn_v e && bn_v e < pow2 eBits) then v (ones t SEC) else v (zeros t SEC))} | let rsapss_check_exponent #t eBits e =
let m0 = bn_is_zero_mask e in
bn_is_zero_mask_lemma e;
let m1 = bn_check_num_bits eBits e in
let m = (lognot m0) &. m1 in
lognot_lemma m0;
logand_lemma (lognot m0) m1;
m | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 780,
"start_col": 0,
"start_line": 773
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)
val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
let rsapss_verify_pre a sLen msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a
val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post #t a modBits eBits pkey sLen sgnt msgLen msg verify =
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify_ a modBits pkeys sLen sgnt msgLen msg)
val rsapss_verify_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post1 #t a modBits eBits pkey sLen k sgnt msgLen msg verify =
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify a modBits pkeys sLen k sgnt msgLen msg)
val rsapss_sign_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_bn #t modBits eBits dBits skey m =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
let s = map (logand eq_m) s in
BB.unsafe_bool_of_limb eq_m, s
val rsapss_sign_msg_to_bn:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (lbignum t (blocks modBits (bits t)))
(requires rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> bn_v res < pow2 (modBits - 1))
let rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be #t emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
m
val rsapss_sign_compute_sgnt:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_compute_sgnt #t modBits eBits dBits skey m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
let eq_b, s = rsapss_sign_bn #t modBits eBits dBits skey m in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let sgnt = bn_to_bytes_be k s in
eq_b, sgnt
val rsapss_sign_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
rsapss_skey_pre modBits eBits dBits skey /\
rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> True)
let rsapss_sign_ #t a modBits eBits dBits skey sLen salt msgLen msg =
let m = rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg in
rsapss_sign_compute_sgnt #t modBits eBits dBits skey m
val rsapss_sign_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey)
(ensures
(let eq_m, s = rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg in
rsapss_sign_post a modBits eBits dBits skey sLen salt msgLen msg eq_m s))
let rsapss_sign_lemma #t a modBits eBits dBits skey sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
assert (bn_v m < bn_v n);
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
bn_eq_mask_lemma m m';
let s' = map (logand eq_m) s in
bn_mask_lemma s eq_m;
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
Math.Lemmas.pow2_le_compat (8 * k) modBits;
assert (bn_v s' < pow2 (8 * k));
let sgnt = bn_to_bytes_be k s' in
bn_to_bytes_be_lemma k s'
val rsapss_sign:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> sgnt:lseq uint8 (blocks modBits 8)
-> Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires rsapss_skey_pre modBits eBits dBits skey)
(ensures fun (b, sgnt) ->
rsapss_sign_post1 a modBits eBits dBits skey sLen salt msgLen msg b sgnt)
let rsapss_sign #t a modBits eBits dBits skey sLen salt msgLen msg sgnt =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
sLen + hLen + 2 <= blocks (modBits - 1) 8 in
if b then begin
rsapss_sign_lemma a modBits eBits dBits skey sLen salt msgLen msg;
rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg end
else
false, sgnt
val rsapss_verify_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> m_def:lbignum t (blocks modBits (bits t))
-> s:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_bn #t modBits eBits pkey m_def s =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
if bn_lt_pow2 modBits m then (true, m)
else false, m end
else false, m_def
val rsapss_verify_bn_to_msg:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> m:lbignum t (blocks modBits (bits t)) ->
Pure bool
(requires rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_bn_to_msg #t a modBits sLen msgLen msg m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let m1 = sub m 0 (blocks emLen numb) in
let em = bn_to_bytes_be emLen m1 in
S.pss_verify a sLen msgLen msg emBits em
val rsapss_verify_compute_msg:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sgnt:lseq uint8 (blocks modBits 8) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_compute_msg #t modBits eBits pkey sgnt =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
let m_def = create nLen (uint #t 0) in
rsapss_verify_bn #t modBits eBits pkey m_def s
val rsapss_verify_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires
rsapss_pkey_pre modBits eBits pkey /\
rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_ #t a modBits eBits pkey sLen sgnt msgLen msg =
let (b, m) = rsapss_verify_compute_msg #t modBits eBits pkey sgnt in
if b then
rsapss_verify_bn_to_msg a modBits sLen msgLen msg m
else
false
val rsapss_verify_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey)
(ensures
rsapss_verify_post a modBits eBits pkey sLen sgnt msgLen msg
(rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg))
let rsapss_verify_lemma #t a modBits eBits pkey sLen sgnt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
bn_from_bytes_be_lemma #t k sgnt;
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
let res =
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
bn_lt_pow2_lemma modBits m;
assert (bn_lt_pow2 modBits m == (bn_v m < pow2 (emLen * 8)));
let res =
if bn_lt_pow2 modBits m then begin
let m1 = sub m 0 (blocks emLen numb) in
bn_eval_sub modBits m;
assert (bn_v m1 == bn_v m);
let em = bn_to_bytes_be emLen m1 in
bn_to_bytes_be_lemma emLen m1;
S.pss_verify a sLen msgLen msg emBits em end
else false in
() end in
()
val rsapss_verify:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun r -> rsapss_verify_post1 a modBits eBits pkey sLen k sgnt msgLen msg r)
let rsapss_verify #t a modBits eBits pkey sLen k sgnt msgLen msg =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
//assert (max_size_t < Hash.max_input_length a);
assert (hLen + 8 < max_size_t);
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
k = blocks modBits 8 in
if b then begin
rsapss_verify_lemma a modBits eBits pkey sLen sgnt msgLen msg;
rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg end
else
false
val bn_check_num_bits: #t:limb_t -> bs:size_pos -> b:lbignum t (blocks bs (bits t)) ->
res:limb t{v res == (if bn_v b < pow2 bs then v (ones t SEC) else v (zeros t SEC))}
let bn_check_num_bits #t bs b =
let bLen = blocks bs (bits t) in
assert (bs <= bits t * bLen);
let m : limb t = if bs = bits t * bLen then ones t SEC else bn_lt_pow2_mask b bs in
(if bs = bits t * bLen then begin
bn_eval_bound b bLen;
Math.Lemmas.pow2_le_compat (bits t * bLen) bs end
else
bn_lt_pow2_mask_lemma b bs);
assert (v m == (if bn_v b < pow2 bs then v (ones t SEC) else v (zeros t SEC)));
m
val rsapss_check_modulus: #t:limb_t -> modBits:size_pos -> n:lbignum t (blocks modBits (bits t)) ->
res:limb t{v res == (if (bn_v n % 2 = 1 && pow2 (modBits - 1) < bn_v n && bn_v n < pow2 modBits) then v (ones t SEC) else v (zeros t SEC))}
let rsapss_check_modulus #t modBits n =
let bit0 = bn_is_odd n in
bn_is_odd_lemma n;
assert (v bit0 == bn_v n % 2);
let m0 = uint #t 0 -. bit0 in
let m1 = bn_gt_pow2_mask n (modBits - 1) in
bn_gt_pow2_mask_lemma n (modBits - 1);
let m2 = bn_check_num_bits modBits n in
let m = m0 &. (m1 &. m2) in
logand_lemma m0 (m1 &. m2);
logand_lemma m1 m2;
m
val rsapss_check_exponent: #t:limb_t -> eBits:size_pos -> e:lbignum t (blocks eBits (bits t)) ->
res:limb t{v res == (if (0 < bn_v e && bn_v e < pow2 eBits) then v (ones t SEC) else v (zeros t SEC))} | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
eBits: Lib.IntTypes.size_pos ->
e:
Hacl.Spec.Bignum.Definitions.lbignum t
(Hacl.Spec.Bignum.Definitions.blocks eBits (Lib.IntTypes.bits t))
-> res:
Hacl.Spec.Bignum.Definitions.limb t
{ Lib.IntTypes.v res ==
(match
0 < Hacl.Spec.Bignum.Definitions.bn_v e &&
Hacl.Spec.Bignum.Definitions.bn_v e < Prims.pow2 eBits
with
| true -> Lib.IntTypes.v (Lib.IntTypes.ones t Lib.IntTypes.SEC)
| _ -> Lib.IntTypes.v (Lib.IntTypes.zeros t Lib.IntTypes.SEC)) } | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.bits",
"Prims.unit",
"Lib.IntTypes.logand_lemma",
"Lib.IntTypes.SEC",
"Lib.IntTypes.lognot",
"Lib.IntTypes.lognot_lemma",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Amp_Dot",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.eq2",
"Prims.int",
"Lib.IntTypes.range",
"Lib.IntTypes.v",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.pow2",
"Lib.IntTypes.ones",
"Prims.bool",
"Lib.IntTypes.zeros",
"Hacl.Spec.RSAPSS.bn_check_num_bits",
"Hacl.Spec.Bignum.bn_is_zero_mask_lemma",
"Hacl.Spec.Bignum.bn_is_zero_mask",
"Lib.IntTypes.range_t",
"Prims.op_AmpAmp"
] | [] | false | false | false | false | false | let rsapss_check_exponent #t eBits e =
| let m0 = bn_is_zero_mask e in
bn_is_zero_mask_lemma e;
let m1 = bn_check_num_bits eBits e in
let m = (lognot m0) &. m1 in
lognot_lemma m0;
logand_lemma (lognot m0) m1;
m | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.seq_eq | val seq_eq (s: Ghost.erased (Seq.seq 'a)) : spred 'a | val seq_eq (s: Ghost.erased (Seq.seq 'a)) : spred 'a | let seq_eq (s:Ghost.erased (Seq.seq 'a)) : spred 'a =
fun s' -> s' `Seq.equal` Ghost.reveal s | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 41,
"end_line": 58,
"start_col": 0,
"start_line": 57
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a)
unfold let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
unfold let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a)
inline_for_extraction
type ipointer (a:Type0) = b:ibuffer a{length b == 1}
inline_for_extraction
type ipointer_or_null (a:Type0) = b:ibuffer a{if g_is_null b then True else length b == 1}
inline_for_extraction let isub (#a:Type0) = msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
inline_for_extraction let ioffset (#a:Type0) = moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
(*
* It's a bit sub-optimal that we have both cpred and seq_eq
* Ideally it should only be the erased version seq_eq
*
* However, Lib.Buffer in hacl is already using cpred, so keeping it for now
* But it should be cleaned up when that dependency is gone
*)
let cpred (#a:Type0) (s:Seq.seq a) :spred a = fun s1 -> Seq.equal s s1 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s: FStar.Ghost.erased (FStar.Seq.Base.seq 'a) -> LowStar.Monotonic.Buffer.spred 'a | Prims.Tot | [
"total"
] | [] | [
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.equal",
"FStar.Ghost.reveal",
"LowStar.Monotonic.Buffer.spred"
] | [] | false | false | false | true | false | let seq_eq (s: Ghost.erased (Seq.seq 'a)) : spred 'a =
| fun s' -> s' `Seq.equal` (Ghost.reveal s) | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_verify_compute_msg | val rsapss_verify_compute_msg:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sgnt:lseq uint8 (blocks modBits 8) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True) | val rsapss_verify_compute_msg:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sgnt:lseq uint8 (blocks modBits 8) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True) | let rsapss_verify_compute_msg #t modBits eBits pkey sgnt =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
let m_def = create nLen (uint #t 0) in
rsapss_verify_bn #t modBits eBits pkey m_def s | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 48,
"end_line": 606,
"start_col": 0,
"start_line": 593
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)
val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
let rsapss_verify_pre a sLen msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a
val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post #t a modBits eBits pkey sLen sgnt msgLen msg verify =
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify_ a modBits pkeys sLen sgnt msgLen msg)
val rsapss_verify_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post1 #t a modBits eBits pkey sLen k sgnt msgLen msg verify =
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify a modBits pkeys sLen k sgnt msgLen msg)
val rsapss_sign_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_bn #t modBits eBits dBits skey m =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
let s = map (logand eq_m) s in
BB.unsafe_bool_of_limb eq_m, s
val rsapss_sign_msg_to_bn:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (lbignum t (blocks modBits (bits t)))
(requires rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> bn_v res < pow2 (modBits - 1))
let rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be #t emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
m
val rsapss_sign_compute_sgnt:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_compute_sgnt #t modBits eBits dBits skey m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
let eq_b, s = rsapss_sign_bn #t modBits eBits dBits skey m in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let sgnt = bn_to_bytes_be k s in
eq_b, sgnt
val rsapss_sign_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
rsapss_skey_pre modBits eBits dBits skey /\
rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> True)
let rsapss_sign_ #t a modBits eBits dBits skey sLen salt msgLen msg =
let m = rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg in
rsapss_sign_compute_sgnt #t modBits eBits dBits skey m
val rsapss_sign_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey)
(ensures
(let eq_m, s = rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg in
rsapss_sign_post a modBits eBits dBits skey sLen salt msgLen msg eq_m s))
let rsapss_sign_lemma #t a modBits eBits dBits skey sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
assert (bn_v m < bn_v n);
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
bn_eq_mask_lemma m m';
let s' = map (logand eq_m) s in
bn_mask_lemma s eq_m;
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
Math.Lemmas.pow2_le_compat (8 * k) modBits;
assert (bn_v s' < pow2 (8 * k));
let sgnt = bn_to_bytes_be k s' in
bn_to_bytes_be_lemma k s'
val rsapss_sign:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> sgnt:lseq uint8 (blocks modBits 8)
-> Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires rsapss_skey_pre modBits eBits dBits skey)
(ensures fun (b, sgnt) ->
rsapss_sign_post1 a modBits eBits dBits skey sLen salt msgLen msg b sgnt)
let rsapss_sign #t a modBits eBits dBits skey sLen salt msgLen msg sgnt =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
sLen + hLen + 2 <= blocks (modBits - 1) 8 in
if b then begin
rsapss_sign_lemma a modBits eBits dBits skey sLen salt msgLen msg;
rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg end
else
false, sgnt
val rsapss_verify_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> m_def:lbignum t (blocks modBits (bits t))
-> s:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_bn #t modBits eBits pkey m_def s =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
if bn_lt_pow2 modBits m then (true, m)
else false, m end
else false, m_def
val rsapss_verify_bn_to_msg:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> m:lbignum t (blocks modBits (bits t)) ->
Pure bool
(requires rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_bn_to_msg #t a modBits sLen msgLen msg m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let m1 = sub m 0 (blocks emLen numb) in
let em = bn_to_bytes_be emLen m1 in
S.pss_verify a sLen msgLen msg emBits em
val rsapss_verify_compute_msg:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sgnt:lseq uint8 (blocks modBits 8) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True) | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat{Hacl.Spec.RSAPSS.pkey_len_pre t modBits eBits} ->
pkey:
Hacl.Spec.Bignum.Definitions.lbignum t
(2 * Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks eBits (Lib.IntTypes.bits t)) ->
sgnt: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks modBits 8)
-> Prims.Pure
(Prims.bool *
Hacl.Spec.Bignum.Definitions.lbignum t
(Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t))) | Prims.Pure | [] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.RSAPSS.pkey_len_pre",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.bits",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Hacl.Spec.RSAPSS.rsapss_verify_bn",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Lib.IntTypes.SEC",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.Sequence.index",
"Lib.Sequence.create",
"Lib.IntTypes.uint",
"Lib.IntTypes.numbytes",
"Hacl.Spec.Bignum.bn_from_bytes_be",
"Prims.unit",
"Prims._assert",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.max_size_t",
"Lib.IntTypes.size_pos",
"Prims.l_or",
"Hacl.Spec.RSAPSS.blocks_numb_lemma",
"Hacl.Spec.RSAPSS.blocks_bits_lemma",
"Prims.pos",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_Multiply",
"Prims.int",
"FStar.Pervasives.Native.tuple2",
"Prims.bool"
] | [] | false | false | false | false | false | let rsapss_verify_compute_msg #t modBits eBits pkey sgnt =
| let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
let m_def = create nLen (uint #t 0) in
rsapss_verify_bn #t modBits eBits pkey m_def s | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.bn_check_num_bits | val bn_check_num_bits: #t:limb_t -> bs:size_pos -> b:lbignum t (blocks bs (bits t)) ->
res:limb t{v res == (if bn_v b < pow2 bs then v (ones t SEC) else v (zeros t SEC))} | val bn_check_num_bits: #t:limb_t -> bs:size_pos -> b:lbignum t (blocks bs (bits t)) ->
res:limb t{v res == (if bn_v b < pow2 bs then v (ones t SEC) else v (zeros t SEC))} | let bn_check_num_bits #t bs b =
let bLen = blocks bs (bits t) in
assert (bs <= bits t * bLen);
let m : limb t = if bs = bits t * bLen then ones t SEC else bn_lt_pow2_mask b bs in
(if bs = bits t * bLen then begin
bn_eval_bound b bLen;
Math.Lemmas.pow2_le_compat (bits t * bLen) bs end
else
bn_lt_pow2_mask_lemma b bs);
assert (v m == (if bn_v b < pow2 bs then v (ones t SEC) else v (zeros t SEC)));
m | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 748,
"start_col": 0,
"start_line": 738
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)
val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
let rsapss_verify_pre a sLen msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a
val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post #t a modBits eBits pkey sLen sgnt msgLen msg verify =
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify_ a modBits pkeys sLen sgnt msgLen msg)
val rsapss_verify_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post1 #t a modBits eBits pkey sLen k sgnt msgLen msg verify =
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify a modBits pkeys sLen k sgnt msgLen msg)
val rsapss_sign_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_bn #t modBits eBits dBits skey m =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
let s = map (logand eq_m) s in
BB.unsafe_bool_of_limb eq_m, s
val rsapss_sign_msg_to_bn:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (lbignum t (blocks modBits (bits t)))
(requires rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> bn_v res < pow2 (modBits - 1))
let rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be #t emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
m
val rsapss_sign_compute_sgnt:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_compute_sgnt #t modBits eBits dBits skey m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
let eq_b, s = rsapss_sign_bn #t modBits eBits dBits skey m in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let sgnt = bn_to_bytes_be k s in
eq_b, sgnt
val rsapss_sign_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
rsapss_skey_pre modBits eBits dBits skey /\
rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> True)
let rsapss_sign_ #t a modBits eBits dBits skey sLen salt msgLen msg =
let m = rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg in
rsapss_sign_compute_sgnt #t modBits eBits dBits skey m
val rsapss_sign_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey)
(ensures
(let eq_m, s = rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg in
rsapss_sign_post a modBits eBits dBits skey sLen salt msgLen msg eq_m s))
let rsapss_sign_lemma #t a modBits eBits dBits skey sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
assert (bn_v m < bn_v n);
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
bn_eq_mask_lemma m m';
let s' = map (logand eq_m) s in
bn_mask_lemma s eq_m;
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
Math.Lemmas.pow2_le_compat (8 * k) modBits;
assert (bn_v s' < pow2 (8 * k));
let sgnt = bn_to_bytes_be k s' in
bn_to_bytes_be_lemma k s'
val rsapss_sign:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> sgnt:lseq uint8 (blocks modBits 8)
-> Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires rsapss_skey_pre modBits eBits dBits skey)
(ensures fun (b, sgnt) ->
rsapss_sign_post1 a modBits eBits dBits skey sLen salt msgLen msg b sgnt)
let rsapss_sign #t a modBits eBits dBits skey sLen salt msgLen msg sgnt =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
sLen + hLen + 2 <= blocks (modBits - 1) 8 in
if b then begin
rsapss_sign_lemma a modBits eBits dBits skey sLen salt msgLen msg;
rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg end
else
false, sgnt
val rsapss_verify_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> m_def:lbignum t (blocks modBits (bits t))
-> s:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_bn #t modBits eBits pkey m_def s =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
if bn_lt_pow2 modBits m then (true, m)
else false, m end
else false, m_def
val rsapss_verify_bn_to_msg:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> m:lbignum t (blocks modBits (bits t)) ->
Pure bool
(requires rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_bn_to_msg #t a modBits sLen msgLen msg m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let m1 = sub m 0 (blocks emLen numb) in
let em = bn_to_bytes_be emLen m1 in
S.pss_verify a sLen msgLen msg emBits em
val rsapss_verify_compute_msg:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sgnt:lseq uint8 (blocks modBits 8) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_compute_msg #t modBits eBits pkey sgnt =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
let m_def = create nLen (uint #t 0) in
rsapss_verify_bn #t modBits eBits pkey m_def s
val rsapss_verify_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires
rsapss_pkey_pre modBits eBits pkey /\
rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_ #t a modBits eBits pkey sLen sgnt msgLen msg =
let (b, m) = rsapss_verify_compute_msg #t modBits eBits pkey sgnt in
if b then
rsapss_verify_bn_to_msg a modBits sLen msgLen msg m
else
false
val rsapss_verify_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey)
(ensures
rsapss_verify_post a modBits eBits pkey sLen sgnt msgLen msg
(rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg))
let rsapss_verify_lemma #t a modBits eBits pkey sLen sgnt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
bn_from_bytes_be_lemma #t k sgnt;
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
let res =
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
bn_lt_pow2_lemma modBits m;
assert (bn_lt_pow2 modBits m == (bn_v m < pow2 (emLen * 8)));
let res =
if bn_lt_pow2 modBits m then begin
let m1 = sub m 0 (blocks emLen numb) in
bn_eval_sub modBits m;
assert (bn_v m1 == bn_v m);
let em = bn_to_bytes_be emLen m1 in
bn_to_bytes_be_lemma emLen m1;
S.pss_verify a sLen msgLen msg emBits em end
else false in
() end in
()
val rsapss_verify:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun r -> rsapss_verify_post1 a modBits eBits pkey sLen k sgnt msgLen msg r)
let rsapss_verify #t a modBits eBits pkey sLen k sgnt msgLen msg =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
//assert (max_size_t < Hash.max_input_length a);
assert (hLen + 8 < max_size_t);
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
k = blocks modBits 8 in
if b then begin
rsapss_verify_lemma a modBits eBits pkey sLen sgnt msgLen msg;
rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg end
else
false
val bn_check_num_bits: #t:limb_t -> bs:size_pos -> b:lbignum t (blocks bs (bits t)) ->
res:limb t{v res == (if bn_v b < pow2 bs then v (ones t SEC) else v (zeros t SEC))} | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
bs: Lib.IntTypes.size_pos ->
b:
Hacl.Spec.Bignum.Definitions.lbignum t
(Hacl.Spec.Bignum.Definitions.blocks bs (Lib.IntTypes.bits t))
-> res:
Hacl.Spec.Bignum.Definitions.limb t
{ Lib.IntTypes.v res ==
(match Hacl.Spec.Bignum.Definitions.bn_v b < Prims.pow2 bs with
| true -> Lib.IntTypes.v (Lib.IntTypes.ones t Lib.IntTypes.SEC)
| _ -> Lib.IntTypes.v (Lib.IntTypes.zeros t Lib.IntTypes.SEC)) } | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.bits",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Lib.IntTypes.range_t",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.pow2",
"Lib.IntTypes.ones",
"Prims.bool",
"Lib.IntTypes.zeros",
"Prims.op_Equality",
"Prims.int",
"FStar.Mul.op_Star",
"FStar.Math.Lemmas.pow2_le_compat",
"Hacl.Spec.Bignum.Definitions.bn_eval_bound",
"Hacl.Spec.Bignum.bn_lt_pow2_mask_lemma",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.bn_lt_pow2_mask",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.pos",
"Prims.op_Subtraction",
"Prims.op_Multiply"
] | [] | false | false | false | false | false | let bn_check_num_bits #t bs b =
| let bLen = blocks bs (bits t) in
assert (bs <= bits t * bLen);
let m:limb t = if bs = bits t * bLen then ones t SEC else bn_lt_pow2_mask b bs in
(if bs = bits t * bLen
then
(bn_eval_bound b bLen;
Math.Lemmas.pow2_le_compat (bits t * bLen) bs)
else bn_lt_pow2_mask_lemma b bs);
assert (v m == (if bn_v b < pow2 bs then v (ones t SEC) else v (zeros t SEC)));
m | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.cpred | val cpred (#a: Type0) (s: Seq.seq a) : spred a | val cpred (#a: Type0) (s: Seq.seq a) : spred a | let cpred (#a:Type0) (s:Seq.seq a) :spred a = fun s1 -> Seq.equal s s1 | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 70,
"end_line": 55,
"start_col": 0,
"start_line": 55
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a)
unfold let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
unfold let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a)
inline_for_extraction
type ipointer (a:Type0) = b:ibuffer a{length b == 1}
inline_for_extraction
type ipointer_or_null (a:Type0) = b:ibuffer a{if g_is_null b then True else length b == 1}
inline_for_extraction let isub (#a:Type0) = msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
inline_for_extraction let ioffset (#a:Type0) = moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
(*
* It's a bit sub-optimal that we have both cpred and seq_eq
* Ideally it should only be the erased version seq_eq
*
* However, Lib.Buffer in hacl is already using cpred, so keeping it for now
* But it should be cleaned up when that dependency is gone | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s: FStar.Seq.Base.seq a -> LowStar.Monotonic.Buffer.spred a | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"FStar.Seq.Base.equal",
"LowStar.Monotonic.Buffer.spred"
] | [] | false | false | false | true | false | let cpred (#a: Type0) (s: Seq.seq a) : spred a =
| fun s1 -> Seq.equal s s1 | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_skey_pre | val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0 | val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0 | let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 35,
"end_line": 147,
"start_col": 0,
"start_line": 137
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0 | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat ->
dBits: Lib.IntTypes.size_nat{Hacl.Spec.RSAPSS.skey_len_pre t modBits eBits dBits} ->
skey:
Hacl.Spec.Bignum.Definitions.lbignum t
(2 * Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks eBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks dBits (Lib.IntTypes.bits t))
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.RSAPSS.skey_len_pre",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.bits",
"Prims.l_and",
"Hacl.Spec.RSAPSS.rsapss_pkey_pre",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.pow2",
"Lib.Sequence.lseq",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.op_Multiply",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.Sequence.sub",
"Prims.int",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction"
] | [] | false | false | false | false | true | let rsapss_skey_pre #t modBits eBits dBits skey =
| let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\ 0 < bn_v d /\ bn_v d < pow2 dBits | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.value_is | val value_is : b: LowStar.ImmutableBuffer.ibuffer a -> s: FStar.Ghost.erased (FStar.Seq.Base.seq a) -> Type0 | let value_is #a (b:ibuffer a) (s:Ghost.erased (Seq.seq a)) =
witnessed b (seq_eq s) | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 24,
"end_line": 61,
"start_col": 0,
"start_line": 60
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a)
unfold let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
unfold let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a)
inline_for_extraction
type ipointer (a:Type0) = b:ibuffer a{length b == 1}
inline_for_extraction
type ipointer_or_null (a:Type0) = b:ibuffer a{if g_is_null b then True else length b == 1}
inline_for_extraction let isub (#a:Type0) = msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
inline_for_extraction let ioffset (#a:Type0) = moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
(*
* It's a bit sub-optimal that we have both cpred and seq_eq
* Ideally it should only be the erased version seq_eq
*
* However, Lib.Buffer in hacl is already using cpred, so keeping it for now
* But it should be cleaned up when that dependency is gone
*)
let cpred (#a:Type0) (s:Seq.seq a) :spred a = fun s1 -> Seq.equal s s1
let seq_eq (s:Ghost.erased (Seq.seq 'a)) : spred 'a =
fun s' -> s' `Seq.equal` Ghost.reveal s | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b: LowStar.ImmutableBuffer.ibuffer a -> s: FStar.Ghost.erased (FStar.Seq.Base.seq a) -> Type0 | Prims.Tot | [
"total"
] | [] | [
"LowStar.ImmutableBuffer.ibuffer",
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"LowStar.Monotonic.Buffer.witnessed",
"LowStar.ImmutableBuffer.immutable_preorder",
"LowStar.ImmutableBuffer.seq_eq"
] | [] | false | false | false | true | true | let value_is #a (b: ibuffer a) (s: Ghost.erased (Seq.seq a)) =
| witnessed b (seq_eq s) | false |
|
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_verify_ | val rsapss_verify_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires
rsapss_pkey_pre modBits eBits pkey /\
rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True) | val rsapss_verify_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires
rsapss_pkey_pre modBits eBits pkey /\
rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True) | let rsapss_verify_ #t a modBits eBits pkey sLen sgnt msgLen msg =
let (b, m) = rsapss_verify_compute_msg #t modBits eBits pkey sgnt in
if b then
rsapss_verify_bn_to_msg a modBits sLen msgLen msg m
else
false | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 9,
"end_line": 630,
"start_col": 0,
"start_line": 625
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)
val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
let rsapss_verify_pre a sLen msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a
val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post #t a modBits eBits pkey sLen sgnt msgLen msg verify =
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify_ a modBits pkeys sLen sgnt msgLen msg)
val rsapss_verify_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post1 #t a modBits eBits pkey sLen k sgnt msgLen msg verify =
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify a modBits pkeys sLen k sgnt msgLen msg)
val rsapss_sign_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_bn #t modBits eBits dBits skey m =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
let s = map (logand eq_m) s in
BB.unsafe_bool_of_limb eq_m, s
val rsapss_sign_msg_to_bn:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (lbignum t (blocks modBits (bits t)))
(requires rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> bn_v res < pow2 (modBits - 1))
let rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be #t emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
m
val rsapss_sign_compute_sgnt:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_compute_sgnt #t modBits eBits dBits skey m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
let eq_b, s = rsapss_sign_bn #t modBits eBits dBits skey m in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let sgnt = bn_to_bytes_be k s in
eq_b, sgnt
val rsapss_sign_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
rsapss_skey_pre modBits eBits dBits skey /\
rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> True)
let rsapss_sign_ #t a modBits eBits dBits skey sLen salt msgLen msg =
let m = rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg in
rsapss_sign_compute_sgnt #t modBits eBits dBits skey m
val rsapss_sign_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey)
(ensures
(let eq_m, s = rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg in
rsapss_sign_post a modBits eBits dBits skey sLen salt msgLen msg eq_m s))
let rsapss_sign_lemma #t a modBits eBits dBits skey sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
assert (bn_v m < bn_v n);
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
bn_eq_mask_lemma m m';
let s' = map (logand eq_m) s in
bn_mask_lemma s eq_m;
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
Math.Lemmas.pow2_le_compat (8 * k) modBits;
assert (bn_v s' < pow2 (8 * k));
let sgnt = bn_to_bytes_be k s' in
bn_to_bytes_be_lemma k s'
val rsapss_sign:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> sgnt:lseq uint8 (blocks modBits 8)
-> Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires rsapss_skey_pre modBits eBits dBits skey)
(ensures fun (b, sgnt) ->
rsapss_sign_post1 a modBits eBits dBits skey sLen salt msgLen msg b sgnt)
let rsapss_sign #t a modBits eBits dBits skey sLen salt msgLen msg sgnt =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
sLen + hLen + 2 <= blocks (modBits - 1) 8 in
if b then begin
rsapss_sign_lemma a modBits eBits dBits skey sLen salt msgLen msg;
rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg end
else
false, sgnt
val rsapss_verify_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> m_def:lbignum t (blocks modBits (bits t))
-> s:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_bn #t modBits eBits pkey m_def s =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
if bn_lt_pow2 modBits m then (true, m)
else false, m end
else false, m_def
val rsapss_verify_bn_to_msg:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> m:lbignum t (blocks modBits (bits t)) ->
Pure bool
(requires rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_bn_to_msg #t a modBits sLen msgLen msg m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let m1 = sub m 0 (blocks emLen numb) in
let em = bn_to_bytes_be emLen m1 in
S.pss_verify a sLen msgLen msg emBits em
val rsapss_verify_compute_msg:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sgnt:lseq uint8 (blocks modBits 8) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_compute_msg #t modBits eBits pkey sgnt =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
let m_def = create nLen (uint #t 0) in
rsapss_verify_bn #t modBits eBits pkey m_def s
val rsapss_verify_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires
rsapss_pkey_pre modBits eBits pkey /\
rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True) | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat{Hacl.Spec.RSAPSS.pkey_len_pre t modBits eBits} ->
pkey:
Hacl.Spec.Bignum.Definitions.lbignum t
(2 * Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks eBits (Lib.IntTypes.bits t)) ->
sLen: Lib.IntTypes.size_nat ->
sgnt: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks modBits 8) ->
msgLen: Prims.nat ->
msg: Lib.Sequence.seq Lib.IntTypes.uint8 {Lib.Sequence.length msg == msgLen}
-> Prims.Pure Prims.bool | Prims.Pure | [] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Lib.IntTypes.size_nat",
"Hacl.Spec.RSAPSS.pkey_len_pre",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.bits",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Prims.nat",
"Lib.Sequence.seq",
"Prims.eq2",
"Lib.Sequence.length",
"Prims.bool",
"Hacl.Spec.RSAPSS.rsapss_verify_bn_to_msg",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.RSAPSS.rsapss_verify_compute_msg"
] | [] | false | false | false | false | false | let rsapss_verify_ #t a modBits eBits pkey sLen sgnt msgLen msg =
| let b, m = rsapss_verify_compute_msg #t modBits eBits pkey sgnt in
if b then rsapss_verify_bn_to_msg a modBits sLen msgLen msg m else false | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.libuffer | val libuffer : a: Type0 -> len: Prims.nat -> s: FStar.Seq.Base.seq a -> Type0 | let libuffer (a:Type0) (len:nat) (s:Seq.seq a) =
b:lmbuffer a (immutable_preorder a) (immutable_preorder a) len{witnessed b (cpred s)} | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 87,
"end_line": 76,
"start_col": 7,
"start_line": 75
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a)
unfold let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
unfold let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a)
inline_for_extraction
type ipointer (a:Type0) = b:ibuffer a{length b == 1}
inline_for_extraction
type ipointer_or_null (a:Type0) = b:ibuffer a{if g_is_null b then True else length b == 1}
inline_for_extraction let isub (#a:Type0) = msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
inline_for_extraction let ioffset (#a:Type0) = moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
(*
* It's a bit sub-optimal that we have both cpred and seq_eq
* Ideally it should only be the erased version seq_eq
*
* However, Lib.Buffer in hacl is already using cpred, so keeping it for now
* But it should be cleaned up when that dependency is gone
*)
let cpred (#a:Type0) (s:Seq.seq a) :spred a = fun s1 -> Seq.equal s s1
let seq_eq (s:Ghost.erased (Seq.seq 'a)) : spred 'a =
fun s' -> s' `Seq.equal` Ghost.reveal s
let value_is #a (b:ibuffer a) (s:Ghost.erased (Seq.seq a)) =
witnessed b (seq_eq s)
let sub_ptr_value_is (#a:_) (b0 b1:ibuffer a) (h:HS.mem) (i len:U32.t) (v:Seq.seq a)
: Lemma
(requires
U32.v i + U32.v len <= length b1 /\
b0 == mgsub (immutable_preorder a) b1 i len /\
value_is b1 v /\
Seq.length v == length b1)
(ensures
value_is b0 (Seq.slice v (U32.v i) (U32.v i + U32.v len)))
= let sub_v = Seq.slice v (U32.v i) (U32.v i + U32.v len) in
witnessed_functorial b1 b0 i len (seq_eq (Ghost.hide v)) (seq_eq (Ghost.hide sub_v)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Type0 -> len: Prims.nat -> s: FStar.Seq.Base.seq a -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"FStar.Seq.Base.seq",
"LowStar.Monotonic.Buffer.lmbuffer",
"LowStar.ImmutableBuffer.immutable_preorder",
"LowStar.Monotonic.Buffer.witnessed",
"LowStar.ImmutableBuffer.cpred"
] | [] | false | false | false | true | true | let libuffer (a: Type0) (len: nat) (s: Seq.seq a) =
| b: lmbuffer a (immutable_preorder a) (immutable_preorder a) len {witnessed b (cpred s)} | false |
|
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.libuffer_or_null | val libuffer_or_null : a: Type0 -> len: Prims.nat -> r: FStar.Monotonic.HyperHeap.rid -> s: FStar.Seq.Base.seq a -> Type0 | let libuffer_or_null (a:Type0) (len:nat) (r:HS.rid) (s:Seq.seq a) =
b:lmbuffer_or_null a (immutable_preorder a) (immutable_preorder a) len r{(not (g_is_null b)) ==>
witnessed b (cpred s)} | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 97,
"end_line": 80,
"start_col": 7,
"start_line": 78
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a)
unfold let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
unfold let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a)
inline_for_extraction
type ipointer (a:Type0) = b:ibuffer a{length b == 1}
inline_for_extraction
type ipointer_or_null (a:Type0) = b:ibuffer a{if g_is_null b then True else length b == 1}
inline_for_extraction let isub (#a:Type0) = msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
inline_for_extraction let ioffset (#a:Type0) = moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
(*
* It's a bit sub-optimal that we have both cpred and seq_eq
* Ideally it should only be the erased version seq_eq
*
* However, Lib.Buffer in hacl is already using cpred, so keeping it for now
* But it should be cleaned up when that dependency is gone
*)
let cpred (#a:Type0) (s:Seq.seq a) :spred a = fun s1 -> Seq.equal s s1
let seq_eq (s:Ghost.erased (Seq.seq 'a)) : spred 'a =
fun s' -> s' `Seq.equal` Ghost.reveal s
let value_is #a (b:ibuffer a) (s:Ghost.erased (Seq.seq a)) =
witnessed b (seq_eq s)
let sub_ptr_value_is (#a:_) (b0 b1:ibuffer a) (h:HS.mem) (i len:U32.t) (v:Seq.seq a)
: Lemma
(requires
U32.v i + U32.v len <= length b1 /\
b0 == mgsub (immutable_preorder a) b1 i len /\
value_is b1 v /\
Seq.length v == length b1)
(ensures
value_is b0 (Seq.slice v (U32.v i) (U32.v i + U32.v len)))
= let sub_v = Seq.slice v (U32.v i) (U32.v i + U32.v len) in
witnessed_functorial b1 b0 i len (seq_eq (Ghost.hide v)) (seq_eq (Ghost.hide sub_v))
unfold let libuffer (a:Type0) (len:nat) (s:Seq.seq a) =
b:lmbuffer a (immutable_preorder a) (immutable_preorder a) len{witnessed b (cpred s)} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Type0 -> len: Prims.nat -> r: FStar.Monotonic.HyperHeap.rid -> s: FStar.Seq.Base.seq a -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"FStar.Monotonic.HyperHeap.rid",
"FStar.Seq.Base.seq",
"LowStar.Monotonic.Buffer.lmbuffer_or_null",
"LowStar.ImmutableBuffer.immutable_preorder",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"LowStar.Monotonic.Buffer.witnessed",
"LowStar.ImmutableBuffer.cpred"
] | [] | false | false | false | true | true | let libuffer_or_null (a: Type0) (len: nat) (r: HS.rid) (s: Seq.seq a) =
| b:
lmbuffer_or_null a (immutable_preorder a) (immutable_preorder a) len r
{(not (g_is_null b)) ==> witnessed b (cpred s)} | false |
|
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_verify_bn_to_msg | val rsapss_verify_bn_to_msg:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> m:lbignum t (blocks modBits (bits t)) ->
Pure bool
(requires rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True) | val rsapss_verify_bn_to_msg:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> m:lbignum t (blocks modBits (bits t)) ->
Pure bool
(requires rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True) | let rsapss_verify_bn_to_msg #t a modBits sLen msgLen msg m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let m1 = sub m 0 (blocks emLen numb) in
let em = bn_to_bytes_be emLen m1 in
S.pss_verify a sLen msgLen msg emBits em | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 42,
"end_line": 580,
"start_col": 0,
"start_line": 565
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)
val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
let rsapss_verify_pre a sLen msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a
val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post #t a modBits eBits pkey sLen sgnt msgLen msg verify =
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify_ a modBits pkeys sLen sgnt msgLen msg)
val rsapss_verify_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post1 #t a modBits eBits pkey sLen k sgnt msgLen msg verify =
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify a modBits pkeys sLen k sgnt msgLen msg)
val rsapss_sign_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_bn #t modBits eBits dBits skey m =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
let s = map (logand eq_m) s in
BB.unsafe_bool_of_limb eq_m, s
val rsapss_sign_msg_to_bn:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (lbignum t (blocks modBits (bits t)))
(requires rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> bn_v res < pow2 (modBits - 1))
let rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be #t emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
m
val rsapss_sign_compute_sgnt:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_compute_sgnt #t modBits eBits dBits skey m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
let eq_b, s = rsapss_sign_bn #t modBits eBits dBits skey m in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let sgnt = bn_to_bytes_be k s in
eq_b, sgnt
val rsapss_sign_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
rsapss_skey_pre modBits eBits dBits skey /\
rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> True)
let rsapss_sign_ #t a modBits eBits dBits skey sLen salt msgLen msg =
let m = rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg in
rsapss_sign_compute_sgnt #t modBits eBits dBits skey m
val rsapss_sign_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey)
(ensures
(let eq_m, s = rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg in
rsapss_sign_post a modBits eBits dBits skey sLen salt msgLen msg eq_m s))
let rsapss_sign_lemma #t a modBits eBits dBits skey sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
assert (bn_v m < bn_v n);
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
bn_eq_mask_lemma m m';
let s' = map (logand eq_m) s in
bn_mask_lemma s eq_m;
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
Math.Lemmas.pow2_le_compat (8 * k) modBits;
assert (bn_v s' < pow2 (8 * k));
let sgnt = bn_to_bytes_be k s' in
bn_to_bytes_be_lemma k s'
val rsapss_sign:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> sgnt:lseq uint8 (blocks modBits 8)
-> Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires rsapss_skey_pre modBits eBits dBits skey)
(ensures fun (b, sgnt) ->
rsapss_sign_post1 a modBits eBits dBits skey sLen salt msgLen msg b sgnt)
let rsapss_sign #t a modBits eBits dBits skey sLen salt msgLen msg sgnt =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
sLen + hLen + 2 <= blocks (modBits - 1) 8 in
if b then begin
rsapss_sign_lemma a modBits eBits dBits skey sLen salt msgLen msg;
rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg end
else
false, sgnt
val rsapss_verify_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> m_def:lbignum t (blocks modBits (bits t))
-> s:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_bn #t modBits eBits pkey m_def s =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
if bn_lt_pow2 modBits m then (true, m)
else false, m end
else false, m_def
val rsapss_verify_bn_to_msg:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> m:lbignum t (blocks modBits (bits t)) ->
Pure bool
(requires rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True) | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
modBits: Lib.IntTypes.size_nat{1 < modBits} ->
sLen: Lib.IntTypes.size_nat ->
msgLen: Prims.nat ->
msg: Lib.Sequence.seq Lib.IntTypes.uint8 {Lib.Sequence.length msg == msgLen} ->
m:
Hacl.Spec.Bignum.Definitions.lbignum t
(Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t))
-> Prims.Pure Prims.bool | Prims.Pure | [] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Lib.IntTypes.size_nat",
"Prims.op_LessThan",
"Prims.nat",
"Lib.Sequence.seq",
"Lib.IntTypes.uint8",
"Prims.eq2",
"Lib.Sequence.length",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.bits",
"Spec.RSAPSS.pss_verify",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Hacl.Spec.Bignum.bn_to_bytes_be",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.l_and",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"Prims.l_Forall",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.Sequence.sub",
"Prims.unit",
"Prims._assert",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Lib.IntTypes.size_pos",
"Hacl.Spec.RSAPSS.blocks_numb_lemma",
"Hacl.Spec.RSAPSS.blocks_bits_lemma",
"Prims.pos",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_Multiply",
"Prims.int",
"Lib.IntTypes.numbytes",
"Prims.bool"
] | [] | false | false | false | false | false | let rsapss_verify_bn_to_msg #t a modBits sLen msgLen msg m =
| let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let m1 = sub m 0 (blocks emLen numb) in
let em = bn_to_bytes_be emLen m1 in
S.pss_verify a sLen msgLen msg emBits em | false |
Steel.ST.GenElim1.fst | Steel.ST.GenElim1.compute_gen_elim_nondep_correct5 | val compute_gen_elim_nondep_correct5 (i0: gen_elim_i) (t1 t2 t3 t4 t5: Type)
: Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4; t5]) | val compute_gen_elim_nondep_correct5 (i0: gen_elim_i) (t1 t2 t3 t4 t5: Type)
: Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4; t5]) | let compute_gen_elim_nondep_correct5
(i0: gen_elim_i)
(t1 t2 t3 t4 t5: Type)
: Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4; t5])
= fun q post intro _ ->
intro _;
rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> q x1 x2 x3 x4 x5 (U.raise_val ()) `star` pure (post x1 x2 x3 x4 x5 (U.raise_val ()))))))));
let x1 = elim_exists' () in
let x2 = elim_exists' () in
let x3 = elim_exists' () in
let x4 = elim_exists' () in
let x5 = elim_exists' () in
let res = Mktuple5 x1 x2 x3 x4 x5 in
elim_pure _;
rewrite_with_trefl (q _ _ _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
res | {
"file_name": "lib/steel/Steel.ST.GenElim1.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 7,
"end_line": 559,
"start_col": 0,
"start_line": 544
} | module Steel.ST.GenElim1
let gen_elim_f
(p: vprop)
(a: Type)
(q: (a -> vprop))
(post: (a -> prop))
: Tot Type
= ((opened: inames) -> STGhost a opened p q True post)
module U = FStar.Universe
let gen_unit_elim_t (i: gen_unit_elim_i) : Tot Type =
gen_elim_f (compute_gen_unit_elim_p i) (U.raise_t u#_ u#1 unit) (fun _ -> compute_gen_unit_elim_q i) (fun _ -> compute_gen_unit_elim_post i)
let compute_gen_unit_elim_f_id
(v: vprop)
: Tot (gen_unit_elim_t (GUEId v))
= fun _ -> noop (); U.raise_val ()
let compute_gen_unit_elim_f_pure
(p: prop)
: Tot (gen_unit_elim_t (GUEPure p))
= fun _ ->
rewrite (compute_gen_unit_elim_p (GUEPure p)) (pure p);
elim_pure p;
U.raise_val ()
let compute_gen_unit_elim_f_star
(i1 i2: gen_unit_elim_i)
(f1: gen_unit_elim_t i1)
(f2: gen_unit_elim_t i2)
: Tot (gen_unit_elim_t (GUEStar i1 i2))
= fun _ ->
rewrite (compute_gen_unit_elim_p (GUEStar i1 i2)) (compute_gen_unit_elim_p i1 `star` compute_gen_unit_elim_p i2);
let _ = f1 _ in
let _ = f2 _ in
rewrite (compute_gen_unit_elim_q i1 `star` compute_gen_unit_elim_q i2) (compute_gen_unit_elim_q (GUEStar i1 i2));
U.raise_val ()
let rec compute_gen_unit_elim_f
(i: gen_unit_elim_i)
: GTot (gen_unit_elim_t i)
= match i returns (gen_unit_elim_t i) with
| GUEId v -> compute_gen_unit_elim_f_id v
| GUEPure p -> compute_gen_unit_elim_f_pure p
| GUEStar i1 i2 -> compute_gen_unit_elim_f_star i1 i2 (compute_gen_unit_elim_f i1) (compute_gen_unit_elim_f i2)
let gen_elim_t (i: gen_elim_i) : Tot Type =
gen_elim_f (compute_gen_elim_p i) (compute_gen_elim_a i) (compute_gen_elim_q i) (compute_gen_elim_post i)
let compute_gen_elim_f_unit
(i: gen_unit_elim_i)
: GTot (gen_elim_t (GEUnit i))
= compute_gen_unit_elim_f i
let compute_gen_elim_f_star_l
(i1: gen_elim_i)
(f1: gen_elim_t i1)
(i2: gen_unit_elim_i)
: GTot (gen_elim_t (GEStarL i1 i2))
= let f2 = compute_gen_unit_elim_f i2 in
fun _ ->
rewrite (compute_gen_elim_p (GEStarL i1 i2)) (compute_gen_elim_p i1 `star` compute_gen_unit_elim_p i2);
let res = f1 _ in
let _ = f2 _ in
let res' : compute_gen_elim_a (GEStarL i1 i2) = coerce_with_trefl res in
rewrite (compute_gen_elim_q i1 res `star` compute_gen_unit_elim_q i2) (compute_gen_elim_q (GEStarL i1 i2) res');
res'
let compute_gen_elim_f_star_r
(i1: gen_unit_elim_i)
(i2: gen_elim_i)
(f2: gen_elim_t i2)
: GTot (gen_elim_t (GEStarR i1 i2))
= let f1 = compute_gen_unit_elim_f i1 in
fun _ ->
rewrite (compute_gen_elim_p (GEStarR i1 i2)) (compute_gen_unit_elim_p i1 `star` compute_gen_elim_p i2);
let _ = f1 _ in
let res = f2 _ in
let res' : compute_gen_elim_a (GEStarR i1 i2) = coerce_with_trefl res in
rewrite (compute_gen_unit_elim_q i1 `star` compute_gen_elim_q i2 res) (compute_gen_elim_q (GEStarR i1 i2) res');
res'
let compute_gen_elim_f_star
(i1: gen_elim_i)
(f1: gen_elim_t i1)
(i2: gen_elim_i)
(f2: gen_elim_t i2)
: GTot (gen_elim_t (GEStar i1 i2))
= fun _ ->
rewrite (compute_gen_elim_p (GEStar i1 i2)) (compute_gen_elim_p i1 `star` compute_gen_elim_p i2);
let res1 = f1 _ in
let res2 = f2 _ in
let res : compute_gen_elim_a (GEStar i1 i2) = coerce_with_trefl (res1, res2) in
rewrite (compute_gen_elim_q i1 res1 `star` compute_gen_elim_q i2 res2) (compute_gen_elim_q (GEStar i1 i2) res);
res
let compute_gen_elim_f_exists_no_abs0
(a: Type0)
(body: (a -> vprop))
: GTot (gen_elim_t (GEExistsNoAbs0 body))
= fun _ ->
rewrite (compute_gen_elim_p (GEExistsNoAbs0 body)) (exists_ body);
let gres = elim_exists () in
let res : compute_gen_elim_a (GEExistsNoAbs0 body) = U.raise_val (Ghost.reveal gres) in // coerce_with_trefl (Ghost.reveal gres) in
rewrite (body gres) (compute_gen_elim_q (GEExistsNoAbs0 body) res);
res
let rewrite_with_trefl (#opened:_) (p q:vprop)
: STGhost unit opened
p
(fun _ -> q)
(requires T.with_tactic T.trefl (p == q))
(ensures fun _ -> True)
= rewrite p q
let compute_gen_elim_f_exists_unit0
(a: Type0)
(body: a -> gen_unit_elim_i)
: Tot (gen_elim_t (GEExistsUnit0 body))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p (GEExistsUnit0 body)) (exists_ (fun x -> compute_gen_unit_elim_p (body x)));
let gres = elim_exists () in
let _ = compute_gen_unit_elim_f (body gres) _ in
let res : compute_gen_elim_a (GEExistsUnit0 body) = U.raise_val (Ghost.reveal gres) in // coerce_with_trefl (Ghost.reveal gres) in
rewrite (compute_gen_unit_elim_q (body gres)) (compute_gen_elim_q (GEExistsUnit0 body) res);
res
let compute_gen_elim_f_exists0
(a: Type0)
(body: a -> gen_elim_i)
(f: (x: a) -> GTot (gen_elim_t (body x)))
: Tot (gen_elim_t (GEExists0 body))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p (GEExists0 body)) (exists_ (fun x -> compute_gen_elim_p (body x)));
let gres1 = elim_exists () in
let gres2 = f gres1 _ in
let res : compute_gen_elim_a (GEExists0 body) = coerce_with_trefl (Mkdtuple2 #a #(fun x -> compute_gen_elim_a (body x)) (Ghost.reveal gres1) (Ghost.reveal gres2)) in
rewrite (compute_gen_elim_q (body gres1) gres2) (compute_gen_elim_q (GEExists0 body) res);
res
let compute_gen_elim_f_exists_no_abs1
(a: Type)
(body: (a -> vprop))
: GTot (gen_elim_t (GEExistsNoAbs1 body))
= fun _ ->
rewrite (compute_gen_elim_p (GEExistsNoAbs1 body)) (exists_ body);
let gres = elim_exists () in
let res : compute_gen_elim_a (GEExistsNoAbs1 body) = coerce_with_trefl (Ghost.reveal gres) in
rewrite (body gres) (compute_gen_elim_q (GEExistsNoAbs1 body) res);
res
let compute_gen_elim_f_exists_unit1
(a: Type)
(body: a -> gen_unit_elim_i)
: Tot (gen_elim_t (GEExistsUnit1 body))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p (GEExistsUnit1 body)) (exists_ (fun x -> compute_gen_unit_elim_p (body x)));
let gres = elim_exists () in
let _ = compute_gen_unit_elim_f (body gres) _ in
let res : compute_gen_elim_a (GEExistsUnit1 body) = coerce_with_trefl (Ghost.reveal gres) in
rewrite (compute_gen_unit_elim_q (body gres)) (compute_gen_elim_q (GEExistsUnit1 body) res);
res
let compute_gen_elim_f_exists1
(a: Type)
(body: a -> gen_elim_i)
(f: (x: a) -> GTot (gen_elim_t (body x)))
: Tot (gen_elim_t (GEExists1 body))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p (GEExists1 body)) (exists_ (fun x -> compute_gen_elim_p (body x)));
let gres1 = elim_exists () in
let gres2 = f gres1 _ in
let res : compute_gen_elim_a (GEExists1 body) = coerce_with_trefl (Mkdtuple2 #a #(fun x -> compute_gen_elim_a (body x)) (Ghost.reveal gres1) (Ghost.reveal gres2)) in
rewrite (compute_gen_elim_q (body gres1) gres2) (compute_gen_elim_q (GEExists1 body) res);
res
let rec compute_gen_elim_f
(i: gen_elim_i)
: GTot (gen_elim_t i)
= match i returns (gen_elim_t i) with
| GEUnit i -> compute_gen_elim_f_unit i
| GEStarL i1 i2 -> compute_gen_elim_f_star_l i1 (compute_gen_elim_f i1) i2
| GEStarR i1 i2 -> compute_gen_elim_f_star_r i1 i2 (compute_gen_elim_f i2)
| GEStar i1 i2 -> compute_gen_elim_f_star i1 (compute_gen_elim_f i1) i2 (compute_gen_elim_f i2)
| GEExistsNoAbs0 body -> compute_gen_elim_f_exists_no_abs0 _ body
| GEExistsUnit0 body -> compute_gen_elim_f_exists_unit0 _ body
| GEExists0 body -> compute_gen_elim_f_exists0 _ body (fun x -> compute_gen_elim_f (body x))
| GEExistsNoAbs1 body -> compute_gen_elim_f_exists_no_abs1 _ body
| GEExistsUnit1 body -> compute_gen_elim_f_exists_unit1 _ body
| GEExists1 body -> compute_gen_elim_f_exists1 _ body (fun x -> compute_gen_elim_f (body x))
let rec tele_p (x: gen_elim_tele) : Tot vprop =
match x with
| TRet v p -> v `star` pure p
| TExists ty body -> exists_ (fun x -> tele_p (body x))
let elim_exists' (#a:Type)
(#opened_invariants:_)
(#p:a -> vprop)
(_:unit)
: STGhostT (a) opened_invariants
(exists_ p)
(fun x -> p x)
= let gx = elim_exists () in
let x = Ghost.reveal gx in
rewrite (p gx) (p x);
x
let vprop_rewrite (from to: vprop) : Tot Type =
gen_elim_f from unit (fun _ -> to) (fun _ -> True)
let tele_star_vprop_correct_ret
(v': vprop) (p': prop) (v: vprop) (p: prop)
: Tot (vprop_rewrite (tele_p (TRet v' p') `star` v `star` pure p) (tele_p (tele_star_vprop (TRet v' p') v p)))
= fun _ ->
elim_pure p;
rewrite (tele_p _) (v' `star` pure p');
elim_pure p';
intro_pure (p /\ p');
rewrite ((v `star` v') `star` pure (p /\ p')) (tele_p _)
let tele_star_vprop_correct_exists
(v: vprop) (p: prop)
(ty: _) (body: ty -> gen_elim_tele) (ih: (x: ty) -> GTot (vprop_rewrite (tele_p (body x) `star` v `star` pure p) (tele_p (tele_star_vprop (body x) v p))))
: Tot (vprop_rewrite (tele_p (TExists ty body) `star` v `star` pure p) (tele_p (tele_star_vprop (TExists ty body) v p)))
= fun _ ->
rewrite_with_trefl (tele_p _) (exists_ (fun x -> tele_p (body x)));
let x = elim_exists' () in
ih x _;
intro_exists x (fun x -> tele_p (tele_star_vprop (body x) v p));
rewrite_with_trefl (exists_ (fun x -> tele_p (tele_star_vprop (body x) v p))) (tele_p _)
let rec tele_star_vprop_correct
(i: gen_elim_tele) (v: vprop) (p: prop)
: GTot (vprop_rewrite
(tele_p i `star` v `star` pure p)
(tele_p (tele_star_vprop i v p))
)
= match i returns vprop_rewrite
(tele_p i `star` v `star` pure p)
(tele_p (tele_star_vprop i v p)) with
| TRet v' p' -> tele_star_vprop_correct_ret v' p' v p
| TExists ty body -> tele_star_vprop_correct_exists v p ty body (fun x -> tele_star_vprop_correct (body x) v p)
let tele_star_correct_ret_l
(v1: vprop) (p1: prop) (i2: gen_elim_tele)
: Tot (vprop_rewrite (tele_p (TRet v1 p1) `star` tele_p i2) (tele_p (TRet v1 p1 `tele_star` i2)))
= fun _ ->
rewrite (tele_p (TRet v1 p1)) (v1 `star` pure p1);
tele_star_vprop_correct i2 v1 p1 _;
rewrite (tele_p _) (tele_p _)
let tele_star_correct_ret_r
(i1: gen_elim_tele { ~ (TRet? i1) }) (v2: vprop) (p2: prop)
: Tot (vprop_rewrite (tele_p i1 `star` tele_p (TRet v2 p2)) (tele_p (i1 `tele_star` TRet v2 p2)))
= fun _ ->
rewrite (tele_p (TRet v2 p2)) (v2 `star` pure p2);
tele_star_vprop_correct i1 v2 p2 _;
rewrite (tele_p _) (tele_p (i1 `tele_star` TRet v2 p2))
let tele_star_correct_exists
(ty1: _) (f1: ty1 -> gen_elim_tele) (ty2: _) (f2: ty2 -> gen_elim_tele)
(ih: (x1: ty1) -> (x2: ty2) -> GTot (vprop_rewrite (tele_p (f1 x1) `star` tele_p (f2 x2)) (tele_p (f1 x1 `tele_star` f2 x2))))
: Tot (vprop_rewrite (tele_p (TExists ty1 f1) `star` tele_p (TExists ty2 f2)) (tele_p (tele_star (TExists ty1 f1) (TExists ty2 f2))))
= fun _ ->
rewrite_with_trefl (tele_p (TExists ty1 f1)) (exists_ (fun x1 -> tele_p (f1 x1)));
let x1 = elim_exists' () in
rewrite_with_trefl (tele_p (TExists ty2 f2)) (exists_ (fun x2 -> tele_p (f2 x2)));
let x2 = elim_exists' () in
ih x1 x2 _;
intro_exists x2 (fun x2 -> tele_p (tele_star (f1 x1) (f2 x2)));
intro_exists x1 (fun x1 -> exists_ (fun x2 -> tele_p (tele_star (f1 x1) (f2 x2))));
rewrite_with_trefl (exists_ _) (tele_p _)
let rec tele_star_correct
(i1 i2: gen_elim_tele)
: GTot (vprop_rewrite (tele_p i1 `star` tele_p i2) (tele_p (i1 `tele_star` i2)))
= match i1 returns vprop_rewrite (tele_p i1 `star` tele_p i2) (tele_p (i1 `tele_star` i2)) with
| TRet v1 p1 -> tele_star_correct_ret_l v1 p1 i2
| TExists ty1 f1 ->
begin match i2 returns vprop_rewrite (tele_p (TExists ty1 f1) `star` tele_p i2) (tele_p (TExists ty1 f1 `tele_star` i2)) with
| TRet v2 p2 -> tele_star_correct_ret_r (TExists ty1 f1) v2 p2
| TExists ty2 f2 -> tele_star_correct_exists ty1 f1 ty2 f2 (fun x1 x2 -> tele_star_correct (f1 x1) (f2 x2))
end
[@@noextract_to "Plugin" ]
let ge_to_tele_t
(i: gen_elim_i)
: Tot Type
= vprop_rewrite (compute_gen_elim_p i) (tele_p (compute_gen_elim_tele i))
let compute_gen_elim_tele_correct_unit
(v: gen_unit_elim_i)
: Tot (ge_to_tele_t (GEUnit v))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p _) (compute_gen_unit_elim_p v);
let _ = compute_gen_unit_elim_f v _ in
intro_pure (compute_gen_unit_elim_post v);
rewrite_with_trefl (compute_gen_unit_elim_q v `star` pure _) (tele_p _)
let compute_gen_elim_tele_correct_star_l
(l: gen_elim_i)
(ihl: ge_to_tele_t l)
(ru: gen_unit_elim_i)
: Tot (ge_to_tele_t (GEStarL l ru))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p _) (compute_gen_elim_p l `star` compute_gen_unit_elim_p ru);
ihl _;
let _ = compute_gen_unit_elim_f ru _ in
intro_pure (compute_gen_unit_elim_post ru);
tele_star_vprop_correct _ _ _ _;
rewrite_with_trefl (tele_p _) (tele_p _)
let compute_gen_elim_tele_correct_star_r
(lu: gen_unit_elim_i)
(r: gen_elim_i)
(ihr: ge_to_tele_t r)
: Tot (ge_to_tele_t (GEStarR lu r))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p _) (compute_gen_unit_elim_p lu `star` compute_gen_elim_p r);
ihr _;
let _ = compute_gen_unit_elim_f lu _ in
intro_pure (compute_gen_unit_elim_post lu);
tele_star_vprop_correct _ _ _ _;
rewrite_with_trefl (tele_p _) (tele_p _)
let compute_gen_elim_tele_correct_star
(l: gen_elim_i)
(ihl: ge_to_tele_t l)
(r: gen_elim_i)
(ihr: ge_to_tele_t r)
: Tot (ge_to_tele_t (GEStar l r))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p _) (compute_gen_elim_p l `star` compute_gen_elim_p r);
ihl _;
ihr _;
tele_star_correct (compute_gen_elim_tele l) (compute_gen_elim_tele r) _;
rewrite_with_trefl (tele_p _) (tele_p _)
let compute_gen_elim_tele_correct_exists_no_abs0
(ty: _)
(body: ty -> vprop)
: Tot (ge_to_tele_t (GEExistsNoAbs0 #ty body))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p _) (exists_ body);
let x = elim_exists' () in
intro_pure True;
rewrite (body x) (body (U.downgrade_val (U.raise_val x)));
intro_exists (U.raise_val u#0 u#1 x) (fun x -> body (U.downgrade_val x) `star` pure True);
rewrite_with_trefl (exists_ _) (tele_p _)
let compute_gen_elim_tele_correct_exists_unit0
(ty: _)
(body: ty -> gen_unit_elim_i)
: Tot (ge_to_tele_t (GEExistsUnit0 #ty body))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p _) (exists_ (fun x -> compute_gen_unit_elim_p (body x)));
let x = elim_exists' () in
let _ = compute_gen_unit_elim_f (body x) _ in
intro_pure (compute_gen_unit_elim_post (body (U.downgrade_val (U.raise_val u#0 u#1 x))));
rewrite (compute_gen_unit_elim_q (body x)) (compute_gen_unit_elim_q (body (U.downgrade_val (U.raise_val x))));
intro_exists (U.raise_val u#0 u#1 x) (fun x -> compute_gen_unit_elim_q (body (U.downgrade_val x)) `star` pure (compute_gen_unit_elim_post (body (U.downgrade_val x))));
rewrite_with_trefl (exists_ _) (tele_p _)
let compute_gen_elim_tele_correct_exists0
(ty: _)
(body: ty -> gen_elim_i)
(ih: (x: ty) -> GTot (ge_to_tele_t (body x)))
: Tot (ge_to_tele_t (GEExists0 #ty body))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p _) (exists_ (fun x -> compute_gen_elim_p (body x)));
let x = elim_exists' () in
ih x _;
rewrite (tele_p (compute_gen_elim_tele (body x))) (tele_p (compute_gen_elim_tele (body (U.downgrade_val (U.raise_val u#0 u#1 x)))));
intro_exists (U.raise_val u#0 u#1 x) (fun x -> tele_p (compute_gen_elim_tele (body (U.downgrade_val u#0 u#1 x))));
rewrite_with_trefl (exists_ _) (tele_p _)
let compute_gen_elim_tele_correct_exists_no_abs1
(ty: _)
(body: ty -> vprop)
: Tot (ge_to_tele_t (GEExistsNoAbs1 #ty body))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p _) (exists_ body);
let x = elim_exists' () in
intro_pure True;
intro_exists x (fun x -> body x `star` pure True);
rewrite_with_trefl (exists_ _) (tele_p _)
let compute_gen_elim_tele_correct_exists_unit1
(ty: _)
(body: ty -> gen_unit_elim_i)
: Tot (ge_to_tele_t (GEExistsUnit1 #ty body))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p _) (exists_ (fun x -> compute_gen_unit_elim_p (body x)));
let x = elim_exists' () in
let _ = compute_gen_unit_elim_f (body x) _ in
intro_pure (compute_gen_unit_elim_post (body x));
intro_exists x (fun x -> compute_gen_unit_elim_q (body x) `star` pure (compute_gen_unit_elim_post (body x)));
rewrite_with_trefl (exists_ _) (tele_p _)
let compute_gen_elim_tele_correct_exists1
(ty: _)
(body: ty -> gen_elim_i)
(ih: (x: ty) -> GTot (ge_to_tele_t (body x)))
: Tot (ge_to_tele_t (GEExists1 #ty body))
= fun _ ->
rewrite_with_trefl (compute_gen_elim_p _) (exists_ (fun x -> compute_gen_elim_p (body x)));
let x = elim_exists' () in
ih x _;
intro_exists x (fun x -> tele_p (compute_gen_elim_tele (body x)));
rewrite_with_trefl (exists_ _) (tele_p _)
let rec compute_gen_elim_tele_correct
(x: gen_elim_i)
: GTot (ge_to_tele_t x)
= match x returns ge_to_tele_t x with
| GEUnit v -> compute_gen_elim_tele_correct_unit v
| GEStarL l ru -> compute_gen_elim_tele_correct_star_l l (compute_gen_elim_tele_correct l) ru
| GEStarR lu r -> compute_gen_elim_tele_correct_star_r lu r (compute_gen_elim_tele_correct r)
| GEStar l r -> compute_gen_elim_tele_correct_star l (compute_gen_elim_tele_correct l) r (compute_gen_elim_tele_correct r)
| GEExistsNoAbs0 #ty body -> compute_gen_elim_tele_correct_exists_no_abs0 ty body
| GEExistsUnit0 #ty body -> compute_gen_elim_tele_correct_exists_unit0 ty body
| GEExists0 #ty body -> compute_gen_elim_tele_correct_exists0 ty body (fun x -> compute_gen_elim_tele_correct (body x))
| GEExistsNoAbs1 #ty body -> compute_gen_elim_tele_correct_exists_no_abs1 ty body
| GEExistsUnit1 #ty body -> compute_gen_elim_tele_correct_exists_unit1 ty body
| GEExists1 #ty body -> compute_gen_elim_tele_correct_exists1 ty body (fun x -> compute_gen_elim_tele_correct (body x))
let rec gen_elim_nondep_p (ty: list (Type u#a)) : Tot (curried_function_type ty (U.raise_t u#_ u#(max 2 a) unit -> vprop) -> curried_function_type ty (U.raise_t u#_ u#(max 2 a) unit -> prop) -> Tot vprop) =
match ty as ty' returns curried_function_type ty' (U.raise_t u#_ u#(max 2 a) unit -> vprop) -> curried_function_type ty' (U.raise_t u#_ u#(max 2 a) unit -> prop) -> Tot vprop with
| [] -> fun q post -> q (U.raise_val ()) `star` pure (post (U.raise_val ()))
| t :: tq -> fun q post -> exists_ (fun x -> gen_elim_nondep_p tq (q x) (post x))
let rec gen_elim_nondep_sem_correct
(ty: list (Type u#a))
: Tot ((q: curried_function_type ty _) -> (post: curried_function_type ty _) -> Lemma
(tele_p (gen_elim_nondep_sem ty q post) `equiv` gen_elim_nondep_p ty q post)
)
= match ty returns ((q: curried_function_type ty _) -> (post: curried_function_type ty _) -> Lemma
(tele_p (gen_elim_nondep_sem ty q post) `equiv` gen_elim_nondep_p ty q post)
)
with
| [] -> fun q post -> equiv_refl (q (U.raise_val ()) `star` pure (post (U.raise_val ())))
| ta :: tq -> fun q post ->
let phi
(x: ta)
: Lemma
(tele_p (gen_elim_nondep_sem tq (q x) (post x)) `equiv` gen_elim_nondep_p tq (q x) (post x))
= gen_elim_nondep_sem_correct tq (q x) (post x)
in
Classical.forall_intro phi;
let prf () : Lemma
(exists_ (fun x -> tele_p (gen_elim_nondep_sem tq (q x) (post x))) `equiv` exists_ (fun x -> gen_elim_nondep_p tq (q x) (post x)))
=
exists_equiv (fun x -> tele_p (gen_elim_nondep_sem tq (q x) (post x))) (fun x -> gen_elim_nondep_p tq (q x) (post x))
in
assert_norm (tele_p (gen_elim_nondep_sem (ta :: tq) q post) == exists_ (fun x -> tele_p (gen_elim_nondep_sem tq (q x) (post x))));
assert_norm (gen_elim_nondep_p (ta :: tq) q post == exists_ (fun x -> gen_elim_nondep_p tq (q x) (post x)));
prf ()
let compute_gen_elim_nondep_correct_t
(i0: gen_elim_i)
(ty: list (Type u#1))
: Tot Type
= (q: _) ->
(post: _) ->
(intro: vprop_rewrite (compute_gen_elim_p i0) (gen_elim_nondep_p ty q post)) ->
GTot (gen_elim_f
(compute_gen_elim_p i0)
(compute_gen_elim_nondep_a' ty)
(fun x -> compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) ty q x (U.raise_val ()))
(fun x -> compute_uncurry _ (fun _ -> True) ty post x (U.raise_val ()))
)
let compute_gen_elim_nondep_correct0
(i0: gen_elim_i)
: Tot (compute_gen_elim_nondep_correct_t i0 [])
= fun q post intro _ ->
intro _;
rewrite_with_trefl (gen_elim_nondep_p _ _ _) (q (U.raise_val ()) `star` pure (post (U.raise_val ())));
let res = U.raise_val () in
elim_pure _;
rewrite_with_trefl (q (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
res
let compute_gen_elim_nondep_correct1
(i0: gen_elim_i)
(t1: Type)
: Tot (compute_gen_elim_nondep_correct_t i0 [t1])
= fun q post intro _ ->
intro _;
rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> q x1 (U.raise_val ()) `star` pure (post x1 (U.raise_val ()))));
let res = elim_exists' () in
elim_pure _;
rewrite_with_trefl (q _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
res
let compute_gen_elim_nondep_correct2
(i0: gen_elim_i)
(t1 t2: Type)
: Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2])
= fun q post intro _ ->
intro _;
rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> q x1 x2 (U.raise_val ()) `star` pure (post x1 x2 (U.raise_val ())))));
let x1 = elim_exists' () in
let x2 = elim_exists' () in
let res = Mktuple2 x1 x2 in
elim_pure _;
rewrite_with_trefl (q _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
res
let compute_gen_elim_nondep_correct3
(i0: gen_elim_i)
(t1 t2 t3: Type)
: Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3])
= fun q post intro _ ->
intro _;
rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> q x1 x2 x3 (U.raise_val ()) `star` pure (post x1 x2 x3 (U.raise_val ()))))));
let x1 = elim_exists' () in
let x2 = elim_exists' () in
let x3 = elim_exists' () in
let res = Mktuple3 x1 x2 x3 in
elim_pure _;
rewrite_with_trefl (q _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
res
let compute_gen_elim_nondep_correct4
(i0: gen_elim_i)
(t1 t2 t3 t4: Type)
: Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4])
= fun q post intro _ ->
intro _;
rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> q x1 x2 x3 x4 (U.raise_val ()) `star` pure (post x1 x2 x3 x4 (U.raise_val ())))))));
let x1 = elim_exists' () in
let x2 = elim_exists' () in
let x3 = elim_exists' () in
let x4 = elim_exists' () in
let res = Mktuple4 x1 x2 x3 x4 in
elim_pure _;
rewrite_with_trefl (q _ _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
res | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.GenElim1.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Steel.ST.GenElim1.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | i0: Steel.ST.GenElim1.Base.gen_elim_i -> t1: Type -> t2: Type -> t3: Type -> t4: Type -> t5: Type
-> Steel.ST.GenElim1.compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4; t5] | Prims.Tot | [
"total"
] | [] | [
"Steel.ST.GenElim1.Base.gen_elim_i",
"Steel.ST.GenElim1.Base.curried_function_type",
"Prims.Cons",
"Prims.Nil",
"FStar.Universe.raise_t",
"Prims.unit",
"Steel.Effect.Common.vprop",
"Prims.prop",
"Steel.ST.GenElim1.vprop_rewrite",
"Steel.ST.GenElim1.Base.compute_gen_elim_p",
"Steel.ST.GenElim1.gen_elim_nondep_p",
"Steel.Memory.inames",
"Steel.ST.GenElim1.Base.compute_gen_elim_nondep_a'",
"Steel.ST.GenElim1.rewrite_with_trefl",
"FStar.Universe.raise_val",
"Steel.ST.GenElim1.Base.compute_uncurry",
"Steel.ST.GenElim1.Base.compute_gen_elim_p'",
"Steel.ST.Util.elim_pure",
"FStar.Pervasives.Native.tuple5",
"FStar.Pervasives.Native.Mktuple5",
"Steel.ST.GenElim1.elim_exists'",
"Steel.Effect.Common.VStar",
"Steel.ST.Util.pure",
"Steel.ST.Util.exists_",
"Steel.Effect.Common.star",
"Steel.ST.GenElim1.compute_gen_elim_nondep_correct_t"
] | [] | false | false | false | false | false | let compute_gen_elim_nondep_correct5 (i0: gen_elim_i) (t1 t2 t3 t4 t5: Type)
: Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4; t5]) =
| fun q post intro _ ->
intro _;
rewrite_with_trefl (gen_elim_nondep_p _ _ _)
(exists_ (fun x1 ->
exists_ (fun x2 ->
exists_ (fun x3 ->
exists_ (fun x4 ->
exists_ (fun x5 ->
(q x1 x2 x3 x4 x5 (U.raise_val ()))
`star`
(pure (post x1 x2 x3 x4 x5 (U.raise_val ())))))))));
let x1 = elim_exists' () in
let x2 = elim_exists' () in
let x3 = elim_exists' () in
let x4 = elim_exists' () in
let x5 = elim_exists' () in
let res = Mktuple5 x1 x2 x3 x4 x5 in
elim_pure _;
rewrite_with_trefl (q _ _ _ _ _ (U.raise_val ()))
(compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
res | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_verify | val rsapss_verify:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun r -> rsapss_verify_post1 a modBits eBits pkey sLen k sgnt msgLen msg r) | val rsapss_verify:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun r -> rsapss_verify_post1 a modBits eBits pkey sLen k sgnt msgLen msg r) | let rsapss_verify #t a modBits eBits pkey sLen k sgnt msgLen msg =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
//assert (max_size_t < Hash.max_input_length a);
assert (hLen + 8 < max_size_t);
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
k = blocks modBits 8 in
if b then begin
rsapss_verify_lemma a modBits eBits pkey sLen sgnt msgLen msg;
rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg end
else
false | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 9,
"end_line": 731,
"start_col": 0,
"start_line": 715
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)
val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
let rsapss_verify_pre a sLen msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a
val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post #t a modBits eBits pkey sLen sgnt msgLen msg verify =
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify_ a modBits pkeys sLen sgnt msgLen msg)
val rsapss_verify_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post1 #t a modBits eBits pkey sLen k sgnt msgLen msg verify =
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify a modBits pkeys sLen k sgnt msgLen msg)
val rsapss_sign_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_bn #t modBits eBits dBits skey m =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
let s = map (logand eq_m) s in
BB.unsafe_bool_of_limb eq_m, s
val rsapss_sign_msg_to_bn:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (lbignum t (blocks modBits (bits t)))
(requires rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> bn_v res < pow2 (modBits - 1))
let rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be #t emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
m
val rsapss_sign_compute_sgnt:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_compute_sgnt #t modBits eBits dBits skey m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
let eq_b, s = rsapss_sign_bn #t modBits eBits dBits skey m in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let sgnt = bn_to_bytes_be k s in
eq_b, sgnt
val rsapss_sign_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
rsapss_skey_pre modBits eBits dBits skey /\
rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> True)
let rsapss_sign_ #t a modBits eBits dBits skey sLen salt msgLen msg =
let m = rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg in
rsapss_sign_compute_sgnt #t modBits eBits dBits skey m
val rsapss_sign_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey)
(ensures
(let eq_m, s = rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg in
rsapss_sign_post a modBits eBits dBits skey sLen salt msgLen msg eq_m s))
let rsapss_sign_lemma #t a modBits eBits dBits skey sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
assert (bn_v m < bn_v n);
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
bn_eq_mask_lemma m m';
let s' = map (logand eq_m) s in
bn_mask_lemma s eq_m;
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
Math.Lemmas.pow2_le_compat (8 * k) modBits;
assert (bn_v s' < pow2 (8 * k));
let sgnt = bn_to_bytes_be k s' in
bn_to_bytes_be_lemma k s'
val rsapss_sign:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> sgnt:lseq uint8 (blocks modBits 8)
-> Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires rsapss_skey_pre modBits eBits dBits skey)
(ensures fun (b, sgnt) ->
rsapss_sign_post1 a modBits eBits dBits skey sLen salt msgLen msg b sgnt)
let rsapss_sign #t a modBits eBits dBits skey sLen salt msgLen msg sgnt =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
sLen + hLen + 2 <= blocks (modBits - 1) 8 in
if b then begin
rsapss_sign_lemma a modBits eBits dBits skey sLen salt msgLen msg;
rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg end
else
false, sgnt
val rsapss_verify_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> m_def:lbignum t (blocks modBits (bits t))
-> s:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_bn #t modBits eBits pkey m_def s =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
if bn_lt_pow2 modBits m then (true, m)
else false, m end
else false, m_def
val rsapss_verify_bn_to_msg:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> m:lbignum t (blocks modBits (bits t)) ->
Pure bool
(requires rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_bn_to_msg #t a modBits sLen msgLen msg m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let m1 = sub m 0 (blocks emLen numb) in
let em = bn_to_bytes_be emLen m1 in
S.pss_verify a sLen msgLen msg emBits em
val rsapss_verify_compute_msg:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sgnt:lseq uint8 (blocks modBits 8) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_compute_msg #t modBits eBits pkey sgnt =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
let m_def = create nLen (uint #t 0) in
rsapss_verify_bn #t modBits eBits pkey m_def s
val rsapss_verify_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires
rsapss_pkey_pre modBits eBits pkey /\
rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_ #t a modBits eBits pkey sLen sgnt msgLen msg =
let (b, m) = rsapss_verify_compute_msg #t modBits eBits pkey sgnt in
if b then
rsapss_verify_bn_to_msg a modBits sLen msgLen msg m
else
false
val rsapss_verify_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey)
(ensures
rsapss_verify_post a modBits eBits pkey sLen sgnt msgLen msg
(rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg))
let rsapss_verify_lemma #t a modBits eBits pkey sLen sgnt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
bn_from_bytes_be_lemma #t k sgnt;
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
let res =
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
bn_lt_pow2_lemma modBits m;
assert (bn_lt_pow2 modBits m == (bn_v m < pow2 (emLen * 8)));
let res =
if bn_lt_pow2 modBits m then begin
let m1 = sub m 0 (blocks emLen numb) in
bn_eval_sub modBits m;
assert (bn_v m1 == bn_v m);
let em = bn_to_bytes_be emLen m1 in
bn_to_bytes_be_lemma emLen m1;
S.pss_verify a sLen msgLen msg emBits em end
else false in
() end in
()
val rsapss_verify:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun r -> rsapss_verify_post1 a modBits eBits pkey sLen k sgnt msgLen msg r) | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat{Hacl.Spec.RSAPSS.pkey_len_pre t modBits eBits} ->
pkey:
Hacl.Spec.Bignum.Definitions.lbignum t
(2 * Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks eBits (Lib.IntTypes.bits t)) ->
sLen: Lib.IntTypes.size_nat ->
k: Lib.IntTypes.size_nat ->
sgnt: Lib.Sequence.lseq Lib.IntTypes.uint8 k ->
msgLen: Prims.nat ->
msg: Lib.Sequence.seq Lib.IntTypes.uint8 {Lib.Sequence.length msg == msgLen}
-> Prims.Pure Prims.bool | Prims.Pure | [] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Lib.IntTypes.size_nat",
"Hacl.Spec.RSAPSS.pkey_len_pre",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.bits",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Prims.nat",
"Lib.Sequence.seq",
"Prims.eq2",
"Lib.Sequence.length",
"Hacl.Spec.RSAPSS.rsapss_verify_",
"Prims.unit",
"Hacl.Spec.RSAPSS.rsapss_verify_lemma",
"Prims.bool",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"FStar.UInt32.__uint_to_t",
"Hacl.Spec.RSAPSS.less_than_max_input_length",
"Prims.op_Equality",
"Prims.int",
"Prims.l_or",
"Prims.l_and",
"Prims.op_GreaterThanOrEqual",
"Lib.IntTypes.max_size_t",
"Prims.op_GreaterThan",
"Prims._assert",
"Prims.op_LessThan",
"FStar.Math.Lemmas.pow2_lt_compat",
"Prims.pow2",
"Spec.Hash.Definitions.hash_length"
] | [] | false | false | false | false | false | let rsapss_verify #t a modBits eBits pkey sLen k sgnt msgLen msg =
| let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
assert (hLen + 8 < max_size_t);
let b =
sLen <= v (0xfffffffful) - hLen - 8 && msgLen `less_than_max_input_length` a &&
k = blocks modBits 8
in
if b
then
(rsapss_verify_lemma a modBits eBits pkey sLen sgnt msgLen msg;
rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg)
else false | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_sign | val rsapss_sign:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> sgnt:lseq uint8 (blocks modBits 8)
-> Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires rsapss_skey_pre modBits eBits dBits skey)
(ensures fun (b, sgnt) ->
rsapss_sign_post1 a modBits eBits dBits skey sLen salt msgLen msg b sgnt) | val rsapss_sign:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> sgnt:lseq uint8 (blocks modBits 8)
-> Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires rsapss_skey_pre modBits eBits dBits skey)
(ensures fun (b, sgnt) ->
rsapss_sign_post1 a modBits eBits dBits skey sLen salt msgLen msg b sgnt) | let rsapss_sign #t a modBits eBits dBits skey sLen salt msgLen msg sgnt =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
sLen + hLen + 2 <= blocks (modBits - 1) 8 in
if b then begin
rsapss_sign_lemma a modBits eBits dBits skey sLen salt msgLen msg;
rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg end
else
false, sgnt | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 516,
"start_col": 0,
"start_line": 502
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)
val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
let rsapss_verify_pre a sLen msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a
val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post #t a modBits eBits pkey sLen sgnt msgLen msg verify =
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify_ a modBits pkeys sLen sgnt msgLen msg)
val rsapss_verify_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post1 #t a modBits eBits pkey sLen k sgnt msgLen msg verify =
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify a modBits pkeys sLen k sgnt msgLen msg)
val rsapss_sign_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_bn #t modBits eBits dBits skey m =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
let s = map (logand eq_m) s in
BB.unsafe_bool_of_limb eq_m, s
val rsapss_sign_msg_to_bn:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (lbignum t (blocks modBits (bits t)))
(requires rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> bn_v res < pow2 (modBits - 1))
let rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be #t emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
m
val rsapss_sign_compute_sgnt:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_compute_sgnt #t modBits eBits dBits skey m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
let eq_b, s = rsapss_sign_bn #t modBits eBits dBits skey m in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let sgnt = bn_to_bytes_be k s in
eq_b, sgnt
val rsapss_sign_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
rsapss_skey_pre modBits eBits dBits skey /\
rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> True)
let rsapss_sign_ #t a modBits eBits dBits skey sLen salt msgLen msg =
let m = rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg in
rsapss_sign_compute_sgnt #t modBits eBits dBits skey m
val rsapss_sign_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey)
(ensures
(let eq_m, s = rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg in
rsapss_sign_post a modBits eBits dBits skey sLen salt msgLen msg eq_m s))
let rsapss_sign_lemma #t a modBits eBits dBits skey sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
assert (bn_v m < bn_v n);
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
bn_eq_mask_lemma m m';
let s' = map (logand eq_m) s in
bn_mask_lemma s eq_m;
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
Math.Lemmas.pow2_le_compat (8 * k) modBits;
assert (bn_v s' < pow2 (8 * k));
let sgnt = bn_to_bytes_be k s' in
bn_to_bytes_be_lemma k s'
val rsapss_sign:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> sgnt:lseq uint8 (blocks modBits 8)
-> Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires rsapss_skey_pre modBits eBits dBits skey)
(ensures fun (b, sgnt) ->
rsapss_sign_post1 a modBits eBits dBits skey sLen salt msgLen msg b sgnt) | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat ->
dBits: Lib.IntTypes.size_nat{Hacl.Spec.RSAPSS.skey_len_pre t modBits eBits dBits} ->
skey:
Hacl.Spec.Bignum.Definitions.lbignum t
(2 * Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks eBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks dBits (Lib.IntTypes.bits t)) ->
sLen: Lib.IntTypes.size_nat ->
salt: Lib.Sequence.lseq Lib.IntTypes.uint8 sLen ->
msgLen: Prims.nat ->
msg: Lib.Sequence.seq Lib.IntTypes.uint8 {Lib.Sequence.length msg == msgLen} ->
sgnt: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks modBits 8)
-> Prims.Pure
(Prims.bool *
Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks modBits 8)) | Prims.Pure | [] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Lib.IntTypes.size_nat",
"Hacl.Spec.RSAPSS.skey_len_pre",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.bits",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Prims.nat",
"Lib.Sequence.seq",
"Prims.eq2",
"Lib.Sequence.length",
"Hacl.Spec.RSAPSS.rsapss_sign_",
"Prims.unit",
"Hacl.Spec.RSAPSS.rsapss_sign_lemma",
"Prims.bool",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.tuple2",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"FStar.UInt32.__uint_to_t",
"Hacl.Spec.RSAPSS.less_than_max_input_length",
"FStar.Math.Lemmas.pow2_lt_compat",
"Prims.pow2",
"Prims.op_GreaterThan",
"Spec.Hash.Definitions.hash_length"
] | [] | false | false | false | false | false | let rsapss_sign #t a modBits eBits dBits skey sLen salt msgLen msg sgnt =
| let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
let b =
sLen <= v (0xfffffffful) - hLen - 8 && msgLen `less_than_max_input_length` a &&
sLen + hLen + 2 <= blocks (modBits - 1) 8
in
if b
then
(rsapss_sign_lemma a modBits eBits dBits skey sLen salt msgLen msg;
rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg)
else false, sgnt | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.immutable_preorder | val immutable_preorder (a: Type0) : srel a | val immutable_preorder (a: Type0) : srel a | let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2 | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 71,
"end_line": 28,
"start_col": 0,
"start_line": 28
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Type0 -> LowStar.Monotonic.Buffer.srel a | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"FStar.Seq.Base.equal",
"Prims.prop",
"LowStar.Monotonic.Buffer.srel"
] | [] | false | false | false | true | false | let immutable_preorder (a: Type0) : srel a =
| fun s1 s2 -> Seq.equal s1 s2 | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_load_pkey_post | val rsapss_load_pkey_post:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0 | val rsapss_load_pkey_post:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0 | let rsapss_load_pkey_post #t modBits eBits nb eb pkey =
let bits = bits t in
let pkey_s = S.rsapss_load_pkey modBits eBits nb eb in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let e = sub pkey (nLen + nLen) eLen in
rsapss_pkey_pre modBits eBits pkey /\
Some? pkey_s /\
bn_v n == S.Mk_rsapss_pkey?.n (Some?.v pkey_s) /\
bn_v e == S.Mk_rsapss_pkey?.e (Some?.v pkey_s) | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 48,
"end_line": 804,
"start_col": 0,
"start_line": 791
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)
val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
let rsapss_verify_pre a sLen msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a
val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post #t a modBits eBits pkey sLen sgnt msgLen msg verify =
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify_ a modBits pkeys sLen sgnt msgLen msg)
val rsapss_verify_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post1 #t a modBits eBits pkey sLen k sgnt msgLen msg verify =
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify a modBits pkeys sLen k sgnt msgLen msg)
val rsapss_sign_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_bn #t modBits eBits dBits skey m =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
let s = map (logand eq_m) s in
BB.unsafe_bool_of_limb eq_m, s
val rsapss_sign_msg_to_bn:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (lbignum t (blocks modBits (bits t)))
(requires rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> bn_v res < pow2 (modBits - 1))
let rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be #t emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
m
val rsapss_sign_compute_sgnt:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_compute_sgnt #t modBits eBits dBits skey m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
let eq_b, s = rsapss_sign_bn #t modBits eBits dBits skey m in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let sgnt = bn_to_bytes_be k s in
eq_b, sgnt
val rsapss_sign_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
rsapss_skey_pre modBits eBits dBits skey /\
rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> True)
let rsapss_sign_ #t a modBits eBits dBits skey sLen salt msgLen msg =
let m = rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg in
rsapss_sign_compute_sgnt #t modBits eBits dBits skey m
val rsapss_sign_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey)
(ensures
(let eq_m, s = rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg in
rsapss_sign_post a modBits eBits dBits skey sLen salt msgLen msg eq_m s))
let rsapss_sign_lemma #t a modBits eBits dBits skey sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
assert (bn_v m < bn_v n);
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
bn_eq_mask_lemma m m';
let s' = map (logand eq_m) s in
bn_mask_lemma s eq_m;
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
Math.Lemmas.pow2_le_compat (8 * k) modBits;
assert (bn_v s' < pow2 (8 * k));
let sgnt = bn_to_bytes_be k s' in
bn_to_bytes_be_lemma k s'
val rsapss_sign:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> sgnt:lseq uint8 (blocks modBits 8)
-> Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires rsapss_skey_pre modBits eBits dBits skey)
(ensures fun (b, sgnt) ->
rsapss_sign_post1 a modBits eBits dBits skey sLen salt msgLen msg b sgnt)
let rsapss_sign #t a modBits eBits dBits skey sLen salt msgLen msg sgnt =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
sLen + hLen + 2 <= blocks (modBits - 1) 8 in
if b then begin
rsapss_sign_lemma a modBits eBits dBits skey sLen salt msgLen msg;
rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg end
else
false, sgnt
val rsapss_verify_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> m_def:lbignum t (blocks modBits (bits t))
-> s:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_bn #t modBits eBits pkey m_def s =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
if bn_lt_pow2 modBits m then (true, m)
else false, m end
else false, m_def
val rsapss_verify_bn_to_msg:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> m:lbignum t (blocks modBits (bits t)) ->
Pure bool
(requires rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_bn_to_msg #t a modBits sLen msgLen msg m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let m1 = sub m 0 (blocks emLen numb) in
let em = bn_to_bytes_be emLen m1 in
S.pss_verify a sLen msgLen msg emBits em
val rsapss_verify_compute_msg:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sgnt:lseq uint8 (blocks modBits 8) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_compute_msg #t modBits eBits pkey sgnt =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
let m_def = create nLen (uint #t 0) in
rsapss_verify_bn #t modBits eBits pkey m_def s
val rsapss_verify_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires
rsapss_pkey_pre modBits eBits pkey /\
rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_ #t a modBits eBits pkey sLen sgnt msgLen msg =
let (b, m) = rsapss_verify_compute_msg #t modBits eBits pkey sgnt in
if b then
rsapss_verify_bn_to_msg a modBits sLen msgLen msg m
else
false
val rsapss_verify_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey)
(ensures
rsapss_verify_post a modBits eBits pkey sLen sgnt msgLen msg
(rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg))
let rsapss_verify_lemma #t a modBits eBits pkey sLen sgnt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
bn_from_bytes_be_lemma #t k sgnt;
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
let res =
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
bn_lt_pow2_lemma modBits m;
assert (bn_lt_pow2 modBits m == (bn_v m < pow2 (emLen * 8)));
let res =
if bn_lt_pow2 modBits m then begin
let m1 = sub m 0 (blocks emLen numb) in
bn_eval_sub modBits m;
assert (bn_v m1 == bn_v m);
let em = bn_to_bytes_be emLen m1 in
bn_to_bytes_be_lemma emLen m1;
S.pss_verify a sLen msgLen msg emBits em end
else false in
() end in
()
val rsapss_verify:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun r -> rsapss_verify_post1 a modBits eBits pkey sLen k sgnt msgLen msg r)
let rsapss_verify #t a modBits eBits pkey sLen k sgnt msgLen msg =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
//assert (max_size_t < Hash.max_input_length a);
assert (hLen + 8 < max_size_t);
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
k = blocks modBits 8 in
if b then begin
rsapss_verify_lemma a modBits eBits pkey sLen sgnt msgLen msg;
rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg end
else
false
val bn_check_num_bits: #t:limb_t -> bs:size_pos -> b:lbignum t (blocks bs (bits t)) ->
res:limb t{v res == (if bn_v b < pow2 bs then v (ones t SEC) else v (zeros t SEC))}
let bn_check_num_bits #t bs b =
let bLen = blocks bs (bits t) in
assert (bs <= bits t * bLen);
let m : limb t = if bs = bits t * bLen then ones t SEC else bn_lt_pow2_mask b bs in
(if bs = bits t * bLen then begin
bn_eval_bound b bLen;
Math.Lemmas.pow2_le_compat (bits t * bLen) bs end
else
bn_lt_pow2_mask_lemma b bs);
assert (v m == (if bn_v b < pow2 bs then v (ones t SEC) else v (zeros t SEC)));
m
val rsapss_check_modulus: #t:limb_t -> modBits:size_pos -> n:lbignum t (blocks modBits (bits t)) ->
res:limb t{v res == (if (bn_v n % 2 = 1 && pow2 (modBits - 1) < bn_v n && bn_v n < pow2 modBits) then v (ones t SEC) else v (zeros t SEC))}
let rsapss_check_modulus #t modBits n =
let bit0 = bn_is_odd n in
bn_is_odd_lemma n;
assert (v bit0 == bn_v n % 2);
let m0 = uint #t 0 -. bit0 in
let m1 = bn_gt_pow2_mask n (modBits - 1) in
bn_gt_pow2_mask_lemma n (modBits - 1);
let m2 = bn_check_num_bits modBits n in
let m = m0 &. (m1 &. m2) in
logand_lemma m0 (m1 &. m2);
logand_lemma m1 m2;
m
val rsapss_check_exponent: #t:limb_t -> eBits:size_pos -> e:lbignum t (blocks eBits (bits t)) ->
res:limb t{v res == (if (0 < bn_v e && bn_v e < pow2 eBits) then v (ones t SEC) else v (zeros t SEC))}
let rsapss_check_exponent #t eBits e =
let m0 = bn_is_zero_mask e in
bn_is_zero_mask_lemma e;
let m1 = bn_check_num_bits eBits e in
let m = (lognot m0) &. m1 in
lognot_lemma m0;
logand_lemma (lognot m0) m1;
m
val rsapss_load_pkey_post:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0 | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat{Hacl.Spec.RSAPSS.pkey_len_pre t modBits eBits} ->
nb: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks modBits 8) ->
eb: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks eBits 8) ->
pkey:
Hacl.Spec.Bignum.Definitions.lbignum t
(2 * Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks eBits (Lib.IntTypes.bits t))
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.RSAPSS.pkey_len_pre",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Hacl.Spec.Bignum.Definitions.blocks",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Lib.IntTypes.bits",
"Prims.l_and",
"Hacl.Spec.RSAPSS.rsapss_pkey_pre",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"Spec.RSAPSS.rsapss_pkey",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_Subtraction",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Spec.RSAPSS.__proj__Mk_rsapss_pkey__item__n",
"FStar.Pervasives.Native.__proj__Some__item__v",
"Spec.RSAPSS.__proj__Mk_rsapss_pkey__item__e",
"Hacl.Spec.Bignum.Definitions.limb",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.op_Multiply",
"Prims.l_Forall",
"Prims.nat",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.Sequence.sub",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"FStar.Pervasives.Native.option",
"Spec.RSAPSS.rsapss_load_pkey"
] | [] | false | false | false | false | true | let rsapss_load_pkey_post #t modBits eBits nb eb pkey =
| let bits = bits t in
let pkey_s = S.rsapss_load_pkey modBits eBits nb eb in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let e = sub pkey (nLen + nLen) eLen in
rsapss_pkey_pre modBits eBits pkey /\ Some? pkey_s /\ bn_v n == S.Mk_rsapss_pkey?.n (Some?.v pkey_s) /\
bn_v e == S.Mk_rsapss_pkey?.e (Some?.v pkey_s) | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_check_modulus | val rsapss_check_modulus: #t:limb_t -> modBits:size_pos -> n:lbignum t (blocks modBits (bits t)) ->
res:limb t{v res == (if (bn_v n % 2 = 1 && pow2 (modBits - 1) < bn_v n && bn_v n < pow2 modBits) then v (ones t SEC) else v (zeros t SEC))} | val rsapss_check_modulus: #t:limb_t -> modBits:size_pos -> n:lbignum t (blocks modBits (bits t)) ->
res:limb t{v res == (if (bn_v n % 2 = 1 && pow2 (modBits - 1) < bn_v n && bn_v n < pow2 modBits) then v (ones t SEC) else v (zeros t SEC))} | let rsapss_check_modulus #t modBits n =
let bit0 = bn_is_odd n in
bn_is_odd_lemma n;
assert (v bit0 == bn_v n % 2);
let m0 = uint #t 0 -. bit0 in
let m1 = bn_gt_pow2_mask n (modBits - 1) in
bn_gt_pow2_mask_lemma n (modBits - 1);
let m2 = bn_check_num_bits modBits n in
let m = m0 &. (m1 &. m2) in
logand_lemma m0 (m1 &. m2);
logand_lemma m1 m2;
m | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 767,
"start_col": 0,
"start_line": 754
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)
val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
let rsapss_verify_pre a sLen msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a
val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post #t a modBits eBits pkey sLen sgnt msgLen msg verify =
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify_ a modBits pkeys sLen sgnt msgLen msg)
val rsapss_verify_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post1 #t a modBits eBits pkey sLen k sgnt msgLen msg verify =
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify a modBits pkeys sLen k sgnt msgLen msg)
val rsapss_sign_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_bn #t modBits eBits dBits skey m =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
let s = map (logand eq_m) s in
BB.unsafe_bool_of_limb eq_m, s
val rsapss_sign_msg_to_bn:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (lbignum t (blocks modBits (bits t)))
(requires rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> bn_v res < pow2 (modBits - 1))
let rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be #t emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
m
val rsapss_sign_compute_sgnt:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_compute_sgnt #t modBits eBits dBits skey m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
let eq_b, s = rsapss_sign_bn #t modBits eBits dBits skey m in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let sgnt = bn_to_bytes_be k s in
eq_b, sgnt
val rsapss_sign_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
rsapss_skey_pre modBits eBits dBits skey /\
rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> True)
let rsapss_sign_ #t a modBits eBits dBits skey sLen salt msgLen msg =
let m = rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg in
rsapss_sign_compute_sgnt #t modBits eBits dBits skey m
val rsapss_sign_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey)
(ensures
(let eq_m, s = rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg in
rsapss_sign_post a modBits eBits dBits skey sLen salt msgLen msg eq_m s))
let rsapss_sign_lemma #t a modBits eBits dBits skey sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
assert (bn_v m < bn_v n);
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
bn_eq_mask_lemma m m';
let s' = map (logand eq_m) s in
bn_mask_lemma s eq_m;
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
Math.Lemmas.pow2_le_compat (8 * k) modBits;
assert (bn_v s' < pow2 (8 * k));
let sgnt = bn_to_bytes_be k s' in
bn_to_bytes_be_lemma k s'
val rsapss_sign:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> sgnt:lseq uint8 (blocks modBits 8)
-> Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires rsapss_skey_pre modBits eBits dBits skey)
(ensures fun (b, sgnt) ->
rsapss_sign_post1 a modBits eBits dBits skey sLen salt msgLen msg b sgnt)
let rsapss_sign #t a modBits eBits dBits skey sLen salt msgLen msg sgnt =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
sLen + hLen + 2 <= blocks (modBits - 1) 8 in
if b then begin
rsapss_sign_lemma a modBits eBits dBits skey sLen salt msgLen msg;
rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg end
else
false, sgnt
val rsapss_verify_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> m_def:lbignum t (blocks modBits (bits t))
-> s:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_bn #t modBits eBits pkey m_def s =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
if bn_lt_pow2 modBits m then (true, m)
else false, m end
else false, m_def
val rsapss_verify_bn_to_msg:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> m:lbignum t (blocks modBits (bits t)) ->
Pure bool
(requires rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_bn_to_msg #t a modBits sLen msgLen msg m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let m1 = sub m 0 (blocks emLen numb) in
let em = bn_to_bytes_be emLen m1 in
S.pss_verify a sLen msgLen msg emBits em
val rsapss_verify_compute_msg:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sgnt:lseq uint8 (blocks modBits 8) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_compute_msg #t modBits eBits pkey sgnt =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
let m_def = create nLen (uint #t 0) in
rsapss_verify_bn #t modBits eBits pkey m_def s
val rsapss_verify_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires
rsapss_pkey_pre modBits eBits pkey /\
rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_ #t a modBits eBits pkey sLen sgnt msgLen msg =
let (b, m) = rsapss_verify_compute_msg #t modBits eBits pkey sgnt in
if b then
rsapss_verify_bn_to_msg a modBits sLen msgLen msg m
else
false
val rsapss_verify_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey)
(ensures
rsapss_verify_post a modBits eBits pkey sLen sgnt msgLen msg
(rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg))
let rsapss_verify_lemma #t a modBits eBits pkey sLen sgnt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
bn_from_bytes_be_lemma #t k sgnt;
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
let res =
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
bn_lt_pow2_lemma modBits m;
assert (bn_lt_pow2 modBits m == (bn_v m < pow2 (emLen * 8)));
let res =
if bn_lt_pow2 modBits m then begin
let m1 = sub m 0 (blocks emLen numb) in
bn_eval_sub modBits m;
assert (bn_v m1 == bn_v m);
let em = bn_to_bytes_be emLen m1 in
bn_to_bytes_be_lemma emLen m1;
S.pss_verify a sLen msgLen msg emBits em end
else false in
() end in
()
val rsapss_verify:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun r -> rsapss_verify_post1 a modBits eBits pkey sLen k sgnt msgLen msg r)
let rsapss_verify #t a modBits eBits pkey sLen k sgnt msgLen msg =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
//assert (max_size_t < Hash.max_input_length a);
assert (hLen + 8 < max_size_t);
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
k = blocks modBits 8 in
if b then begin
rsapss_verify_lemma a modBits eBits pkey sLen sgnt msgLen msg;
rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg end
else
false
val bn_check_num_bits: #t:limb_t -> bs:size_pos -> b:lbignum t (blocks bs (bits t)) ->
res:limb t{v res == (if bn_v b < pow2 bs then v (ones t SEC) else v (zeros t SEC))}
let bn_check_num_bits #t bs b =
let bLen = blocks bs (bits t) in
assert (bs <= bits t * bLen);
let m : limb t = if bs = bits t * bLen then ones t SEC else bn_lt_pow2_mask b bs in
(if bs = bits t * bLen then begin
bn_eval_bound b bLen;
Math.Lemmas.pow2_le_compat (bits t * bLen) bs end
else
bn_lt_pow2_mask_lemma b bs);
assert (v m == (if bn_v b < pow2 bs then v (ones t SEC) else v (zeros t SEC)));
m
val rsapss_check_modulus: #t:limb_t -> modBits:size_pos -> n:lbignum t (blocks modBits (bits t)) ->
res:limb t{v res == (if (bn_v n % 2 = 1 && pow2 (modBits - 1) < bn_v n && bn_v n < pow2 modBits) then v (ones t SEC) else v (zeros t SEC))} | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
modBits: Lib.IntTypes.size_pos ->
n:
Hacl.Spec.Bignum.Definitions.lbignum t
(Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t))
-> res:
Hacl.Spec.Bignum.Definitions.limb t
{ Lib.IntTypes.v res ==
(match
Hacl.Spec.Bignum.Definitions.bn_v n % 2 = 1 &&
Prims.pow2 (modBits - 1) < Hacl.Spec.Bignum.Definitions.bn_v n &&
Hacl.Spec.Bignum.Definitions.bn_v n < Prims.pow2 modBits
with
| true -> Lib.IntTypes.v (Lib.IntTypes.ones t Lib.IntTypes.SEC)
| _ -> Lib.IntTypes.v (Lib.IntTypes.zeros t Lib.IntTypes.SEC)) } | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.bits",
"Prims.unit",
"Lib.IntTypes.logand_lemma",
"Lib.IntTypes.SEC",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.int_t",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.eq2",
"Prims.int",
"Lib.IntTypes.range",
"Lib.IntTypes.v",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.pow2",
"Lib.IntTypes.ones",
"Prims.bool",
"Lib.IntTypes.zeros",
"Hacl.Spec.RSAPSS.bn_check_num_bits",
"Hacl.Spec.Bignum.bn_gt_pow2_mask_lemma",
"Prims.op_Subtraction",
"Hacl.Spec.Bignum.bn_gt_pow2_mask",
"Lib.IntTypes.op_Subtraction_Dot",
"Lib.IntTypes.uint",
"Prims._assert",
"Prims.op_Modulus",
"Hacl.Spec.Bignum.bn_is_odd_lemma",
"Hacl.Spec.Bignum.bn_is_odd",
"Lib.IntTypes.range_t",
"Prims.op_AmpAmp",
"Prims.op_Equality"
] | [] | false | false | false | false | false | let rsapss_check_modulus #t modBits n =
| let bit0 = bn_is_odd n in
bn_is_odd_lemma n;
assert (v bit0 == bn_v n % 2);
let m0 = uint #t 0 -. bit0 in
let m1 = bn_gt_pow2_mask n (modBits - 1) in
bn_gt_pow2_mask_lemma n (modBits - 1);
let m2 = bn_check_num_bits modBits n in
let m = m0 &. (m1 &. m2) in
logand_lemma m0 (m1 &. m2);
logand_lemma m1 m2;
m | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_sign_ | val rsapss_sign_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
rsapss_skey_pre modBits eBits dBits skey /\
rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> True) | val rsapss_sign_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
rsapss_skey_pre modBits eBits dBits skey /\
rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> True) | let rsapss_sign_ #t a modBits eBits dBits skey sLen salt msgLen msg =
let m = rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg in
rsapss_sign_compute_sgnt #t modBits eBits dBits skey m | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 56,
"end_line": 412,
"start_col": 0,
"start_line": 410
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)
val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
let rsapss_verify_pre a sLen msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a
val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post #t a modBits eBits pkey sLen sgnt msgLen msg verify =
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify_ a modBits pkeys sLen sgnt msgLen msg)
val rsapss_verify_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post1 #t a modBits eBits pkey sLen k sgnt msgLen msg verify =
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify a modBits pkeys sLen k sgnt msgLen msg)
val rsapss_sign_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_bn #t modBits eBits dBits skey m =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
let s = map (logand eq_m) s in
BB.unsafe_bool_of_limb eq_m, s
val rsapss_sign_msg_to_bn:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (lbignum t (blocks modBits (bits t)))
(requires rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> bn_v res < pow2 (modBits - 1))
let rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be #t emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
m
val rsapss_sign_compute_sgnt:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_compute_sgnt #t modBits eBits dBits skey m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
let eq_b, s = rsapss_sign_bn #t modBits eBits dBits skey m in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let sgnt = bn_to_bytes_be k s in
eq_b, sgnt
val rsapss_sign_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
rsapss_skey_pre modBits eBits dBits skey /\
rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> True) | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat ->
dBits: Lib.IntTypes.size_nat{Hacl.Spec.RSAPSS.skey_len_pre t modBits eBits dBits} ->
skey:
Hacl.Spec.Bignum.Definitions.lbignum t
(2 * Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks eBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks dBits (Lib.IntTypes.bits t)) ->
sLen: Lib.IntTypes.size_nat ->
salt: Lib.Sequence.lseq Lib.IntTypes.uint8 sLen ->
msgLen: Prims.nat ->
msg: Lib.Sequence.seq Lib.IntTypes.uint8 {Lib.Sequence.length msg == msgLen}
-> Prims.Pure
(Prims.bool *
Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks modBits 8)) | Prims.Pure | [] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Lib.IntTypes.size_nat",
"Hacl.Spec.RSAPSS.skey_len_pre",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.bits",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Prims.nat",
"Lib.Sequence.seq",
"Prims.eq2",
"Lib.Sequence.length",
"Hacl.Spec.RSAPSS.rsapss_sign_compute_sgnt",
"Hacl.Spec.RSAPSS.rsapss_sign_msg_to_bn",
"FStar.Pervasives.Native.tuple2",
"Prims.bool"
] | [] | false | false | false | false | false | let rsapss_sign_ #t a modBits eBits dBits skey sLen salt msgLen msg =
| let m = rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg in
rsapss_sign_compute_sgnt #t modBits eBits dBits skey m | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_sign_msg_to_bn | val rsapss_sign_msg_to_bn:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (lbignum t (blocks modBits (bits t)))
(requires rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> bn_v res < pow2 (modBits - 1)) | val rsapss_sign_msg_to_bn:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (lbignum t (blocks modBits (bits t)))
(requires rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> bn_v res < pow2 (modBits - 1)) | let rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be #t emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
m | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 359,
"start_col": 0,
"start_line": 339
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)
val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
let rsapss_verify_pre a sLen msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a
val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post #t a modBits eBits pkey sLen sgnt msgLen msg verify =
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify_ a modBits pkeys sLen sgnt msgLen msg)
val rsapss_verify_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post1 #t a modBits eBits pkey sLen k sgnt msgLen msg verify =
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify a modBits pkeys sLen k sgnt msgLen msg)
val rsapss_sign_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_bn #t modBits eBits dBits skey m =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
let s = map (logand eq_m) s in
BB.unsafe_bool_of_limb eq_m, s
val rsapss_sign_msg_to_bn:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (lbignum t (blocks modBits (bits t)))
(requires rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> bn_v res < pow2 (modBits - 1)) | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
modBits: Lib.IntTypes.size_nat{1 < modBits} ->
sLen: Lib.IntTypes.size_nat ->
salt: Lib.Sequence.lseq Lib.IntTypes.uint8 sLen ->
msgLen: Prims.nat ->
msg: Lib.Sequence.seq Lib.IntTypes.uint8 {Lib.Sequence.length msg == msgLen}
-> Prims.Pure
(Hacl.Spec.Bignum.Definitions.lbignum t
(Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t))) | Prims.Pure | [] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Lib.IntTypes.size_nat",
"Prims.op_LessThan",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Prims.nat",
"Lib.Sequence.seq",
"Prims.eq2",
"Lib.Sequence.length",
"Prims.unit",
"Spec.RSAPSS.os2ip_lemma",
"Hacl.Spec.Bignum.bn_from_bytes_be_lemma",
"Prims._assert",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.numbytes",
"Hacl.Spec.Bignum.Definitions.bn_eval_update_sub",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.l_and",
"Lib.Sequence.sub",
"Prims.l_Forall",
"Prims.l_or",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.index",
"Lib.Sequence.update_sub",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Lib.IntTypes.SEC",
"Prims.l_imp",
"Lib.Sequence.create",
"Lib.IntTypes.uint",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.bn_from_bytes_be",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Lib.IntTypes.size_pos",
"Hacl.Spec.RSAPSS.blocks_numb_lemma",
"Hacl.Spec.RSAPSS.blocks_bits_lemma",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Spec.RSAPSS.blocks",
"Spec.RSAPSS.pss_encode",
"Prims.pos",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_Multiply",
"Prims.int",
"Lib.IntTypes.bits"
] | [] | false | false | false | false | false | let rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg =
| let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be #t emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
m | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_load_skey | val rsapss_load_skey:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8) ->
tuple2 bool (lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))) | val rsapss_load_skey:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8) ->
tuple2 bool (lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))) | let rsapss_load_skey #t modBits eBits dBits nb eb db =
let b, pkey = rsapss_load_pkey modBits eBits nb eb in
let d = bn_from_bytes_be #t (blocks dBits 8) db in
let skey = pkey @| d in
let m0 = rsapss_check_exponent dBits d in
let b1 = b && BB.unsafe_bool_of_limb m0 in
b1, skey | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 911,
"start_col": 0,
"start_line": 904
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)
val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
let rsapss_verify_pre a sLen msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a
val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post #t a modBits eBits pkey sLen sgnt msgLen msg verify =
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify_ a modBits pkeys sLen sgnt msgLen msg)
val rsapss_verify_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post1 #t a modBits eBits pkey sLen k sgnt msgLen msg verify =
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify a modBits pkeys sLen k sgnt msgLen msg)
val rsapss_sign_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_bn #t modBits eBits dBits skey m =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
let s = map (logand eq_m) s in
BB.unsafe_bool_of_limb eq_m, s
val rsapss_sign_msg_to_bn:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (lbignum t (blocks modBits (bits t)))
(requires rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> bn_v res < pow2 (modBits - 1))
let rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be #t emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
m
val rsapss_sign_compute_sgnt:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_compute_sgnt #t modBits eBits dBits skey m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
let eq_b, s = rsapss_sign_bn #t modBits eBits dBits skey m in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let sgnt = bn_to_bytes_be k s in
eq_b, sgnt
val rsapss_sign_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
rsapss_skey_pre modBits eBits dBits skey /\
rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> True)
let rsapss_sign_ #t a modBits eBits dBits skey sLen salt msgLen msg =
let m = rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg in
rsapss_sign_compute_sgnt #t modBits eBits dBits skey m
val rsapss_sign_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey)
(ensures
(let eq_m, s = rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg in
rsapss_sign_post a modBits eBits dBits skey sLen salt msgLen msg eq_m s))
let rsapss_sign_lemma #t a modBits eBits dBits skey sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
assert (bn_v m < bn_v n);
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
bn_eq_mask_lemma m m';
let s' = map (logand eq_m) s in
bn_mask_lemma s eq_m;
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
Math.Lemmas.pow2_le_compat (8 * k) modBits;
assert (bn_v s' < pow2 (8 * k));
let sgnt = bn_to_bytes_be k s' in
bn_to_bytes_be_lemma k s'
val rsapss_sign:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> sgnt:lseq uint8 (blocks modBits 8)
-> Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires rsapss_skey_pre modBits eBits dBits skey)
(ensures fun (b, sgnt) ->
rsapss_sign_post1 a modBits eBits dBits skey sLen salt msgLen msg b sgnt)
let rsapss_sign #t a modBits eBits dBits skey sLen salt msgLen msg sgnt =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
sLen + hLen + 2 <= blocks (modBits - 1) 8 in
if b then begin
rsapss_sign_lemma a modBits eBits dBits skey sLen salt msgLen msg;
rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg end
else
false, sgnt
val rsapss_verify_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> m_def:lbignum t (blocks modBits (bits t))
-> s:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_bn #t modBits eBits pkey m_def s =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
if bn_lt_pow2 modBits m then (true, m)
else false, m end
else false, m_def
val rsapss_verify_bn_to_msg:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> m:lbignum t (blocks modBits (bits t)) ->
Pure bool
(requires rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_bn_to_msg #t a modBits sLen msgLen msg m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let m1 = sub m 0 (blocks emLen numb) in
let em = bn_to_bytes_be emLen m1 in
S.pss_verify a sLen msgLen msg emBits em
val rsapss_verify_compute_msg:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sgnt:lseq uint8 (blocks modBits 8) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_compute_msg #t modBits eBits pkey sgnt =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
let m_def = create nLen (uint #t 0) in
rsapss_verify_bn #t modBits eBits pkey m_def s
val rsapss_verify_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires
rsapss_pkey_pre modBits eBits pkey /\
rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_ #t a modBits eBits pkey sLen sgnt msgLen msg =
let (b, m) = rsapss_verify_compute_msg #t modBits eBits pkey sgnt in
if b then
rsapss_verify_bn_to_msg a modBits sLen msgLen msg m
else
false
val rsapss_verify_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey)
(ensures
rsapss_verify_post a modBits eBits pkey sLen sgnt msgLen msg
(rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg))
let rsapss_verify_lemma #t a modBits eBits pkey sLen sgnt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
bn_from_bytes_be_lemma #t k sgnt;
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
let res =
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
bn_lt_pow2_lemma modBits m;
assert (bn_lt_pow2 modBits m == (bn_v m < pow2 (emLen * 8)));
let res =
if bn_lt_pow2 modBits m then begin
let m1 = sub m 0 (blocks emLen numb) in
bn_eval_sub modBits m;
assert (bn_v m1 == bn_v m);
let em = bn_to_bytes_be emLen m1 in
bn_to_bytes_be_lemma emLen m1;
S.pss_verify a sLen msgLen msg emBits em end
else false in
() end in
()
val rsapss_verify:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun r -> rsapss_verify_post1 a modBits eBits pkey sLen k sgnt msgLen msg r)
let rsapss_verify #t a modBits eBits pkey sLen k sgnt msgLen msg =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
//assert (max_size_t < Hash.max_input_length a);
assert (hLen + 8 < max_size_t);
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
k = blocks modBits 8 in
if b then begin
rsapss_verify_lemma a modBits eBits pkey sLen sgnt msgLen msg;
rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg end
else
false
val bn_check_num_bits: #t:limb_t -> bs:size_pos -> b:lbignum t (blocks bs (bits t)) ->
res:limb t{v res == (if bn_v b < pow2 bs then v (ones t SEC) else v (zeros t SEC))}
let bn_check_num_bits #t bs b =
let bLen = blocks bs (bits t) in
assert (bs <= bits t * bLen);
let m : limb t = if bs = bits t * bLen then ones t SEC else bn_lt_pow2_mask b bs in
(if bs = bits t * bLen then begin
bn_eval_bound b bLen;
Math.Lemmas.pow2_le_compat (bits t * bLen) bs end
else
bn_lt_pow2_mask_lemma b bs);
assert (v m == (if bn_v b < pow2 bs then v (ones t SEC) else v (zeros t SEC)));
m
val rsapss_check_modulus: #t:limb_t -> modBits:size_pos -> n:lbignum t (blocks modBits (bits t)) ->
res:limb t{v res == (if (bn_v n % 2 = 1 && pow2 (modBits - 1) < bn_v n && bn_v n < pow2 modBits) then v (ones t SEC) else v (zeros t SEC))}
let rsapss_check_modulus #t modBits n =
let bit0 = bn_is_odd n in
bn_is_odd_lemma n;
assert (v bit0 == bn_v n % 2);
let m0 = uint #t 0 -. bit0 in
let m1 = bn_gt_pow2_mask n (modBits - 1) in
bn_gt_pow2_mask_lemma n (modBits - 1);
let m2 = bn_check_num_bits modBits n in
let m = m0 &. (m1 &. m2) in
logand_lemma m0 (m1 &. m2);
logand_lemma m1 m2;
m
val rsapss_check_exponent: #t:limb_t -> eBits:size_pos -> e:lbignum t (blocks eBits (bits t)) ->
res:limb t{v res == (if (0 < bn_v e && bn_v e < pow2 eBits) then v (ones t SEC) else v (zeros t SEC))}
let rsapss_check_exponent #t eBits e =
let m0 = bn_is_zero_mask e in
bn_is_zero_mask_lemma e;
let m1 = bn_check_num_bits eBits e in
let m = (lognot m0) &. m1 in
lognot_lemma m0;
logand_lemma (lognot m0) m1;
m
val rsapss_load_pkey_post:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_load_pkey_post #t modBits eBits nb eb pkey =
let bits = bits t in
let pkey_s = S.rsapss_load_pkey modBits eBits nb eb in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let e = sub pkey (nLen + nLen) eLen in
rsapss_pkey_pre modBits eBits pkey /\
Some? pkey_s /\
bn_v n == S.Mk_rsapss_pkey?.n (Some?.v pkey_s) /\
bn_v e == S.Mk_rsapss_pkey?.e (Some?.v pkey_s)
val rsapss_load_skey_post:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8)
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_load_skey_post #t modBits eBits dBits nb eb db skey =
let bits = bits t in
let skey_s = S.rsapss_load_skey modBits eBits dBits nb eb db in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
rsapss_skey_pre modBits eBits dBits skey /\
Some? skey_s /\ (let pkey_s = S.Mk_rsapss_skey?.pkey (Some?.v skey_s) in
bn_v n == S.Mk_rsapss_pkey?.n pkey_s /\
bn_v e == S.Mk_rsapss_pkey?.e pkey_s /\
bn_v d == S.Mk_rsapss_skey?.d (Some?.v skey_s))
val rsapss_load_pkey:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8) ->
tuple2 bool (lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)))
let rsapss_load_pkey #t modBits eBits nb eb =
let n = bn_from_bytes_be (blocks modBits 8) nb in
let r2 = SM.bn_precomp_r2_mod_n (modBits - 1) n in
let e = bn_from_bytes_be (blocks eBits 8) eb in
let pkey = (n @| r2) @| e in
let m0 = rsapss_check_modulus modBits n in
let m1 = rsapss_check_exponent eBits e in
let m = m0 &. m1 in
BB.unsafe_bool_of_limb m, pkey
val rsapss_load_pkey_lemma:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8) ->
Lemma
(let b, pkey = rsapss_load_pkey #t modBits eBits nb eb in
let pkey_s = S.rsapss_load_pkey modBits eBits nb eb in
(if b then rsapss_load_pkey_post modBits eBits nb eb pkey else None? pkey_s))
let rsapss_load_pkey_lemma #t modBits eBits nb eb =
let bits = bits t in
let nbLen = blocks modBits 8 in
let ebLen = blocks eBits 8 in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_from_bytes_be #t nbLen nb in
bn_from_bytes_be_lemma #t nbLen nb;
let r2 = SM.bn_precomp_r2_mod_n (modBits - 1) n in
let e = bn_from_bytes_be #t ebLen eb in
bn_from_bytes_be_lemma #t ebLen eb;
let pkey = (n @| r2) @| e in
eq_intro (sub pkey 0 nLen) n;
eq_intro (sub pkey nLen nLen) r2;
eq_intro (sub pkey (nLen + nLen) eLen) e;
let m0 = rsapss_check_modulus modBits n in
let m1 = rsapss_check_exponent eBits e in
let m = m0 &. m1 in
logand_lemma m0 m1
val rsapss_load_skey:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8) ->
tuple2 bool (lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))) | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat ->
dBits: Lib.IntTypes.size_nat{Hacl.Spec.RSAPSS.skey_len_pre t modBits eBits dBits} ->
nb: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks modBits 8) ->
eb: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks eBits 8) ->
db: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks dBits 8)
-> Prims.bool *
Hacl.Spec.Bignum.Definitions.lbignum t
(2 * Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks eBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks dBits (Lib.IntTypes.bits t)) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.RSAPSS.skey_len_pre",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Hacl.Spec.Bignum.Definitions.blocks",
"Prims.bool",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Lib.IntTypes.bits",
"FStar.Pervasives.Native.Mktuple2",
"Prims.op_AmpAmp",
"Hacl.Spec.Bignum.Base.unsafe_bool_of_limb",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.eq2",
"Prims.int",
"Lib.IntTypes.range",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.pow2",
"Lib.IntTypes.ones",
"Lib.IntTypes.zeros",
"Hacl.Spec.RSAPSS.rsapss_check_exponent",
"Prims.op_Multiply",
"Lib.IntTypes.numbytes",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.append",
"Lib.Sequence.op_At_Bar",
"Hacl.Spec.Bignum.bn_from_bytes_be",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.RSAPSS.rsapss_load_pkey"
] | [] | false | false | false | false | false | let rsapss_load_skey #t modBits eBits dBits nb eb db =
| let b, pkey = rsapss_load_pkey modBits eBits nb eb in
let d = bn_from_bytes_be #t (blocks dBits 8) db in
let skey = pkey @| d in
let m0 = rsapss_check_exponent dBits d in
let b1 = b && BB.unsafe_bool_of_limb m0 in
b1, skey | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_verify_bn | val rsapss_verify_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> m_def:lbignum t (blocks modBits (bits t))
-> s:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True) | val rsapss_verify_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> m_def:lbignum t (blocks modBits (bits t))
-> s:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True) | let rsapss_verify_bn #t modBits eBits pkey m_def s =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
if bn_lt_pow2 modBits m then (true, m)
else false, m end
else false, m_def | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 19,
"end_line": 550,
"start_col": 0,
"start_line": 530
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)
val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
let rsapss_verify_pre a sLen msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a
val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post #t a modBits eBits pkey sLen sgnt msgLen msg verify =
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify_ a modBits pkeys sLen sgnt msgLen msg)
val rsapss_verify_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post1 #t a modBits eBits pkey sLen k sgnt msgLen msg verify =
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify a modBits pkeys sLen k sgnt msgLen msg)
val rsapss_sign_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_bn #t modBits eBits dBits skey m =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
let s = map (logand eq_m) s in
BB.unsafe_bool_of_limb eq_m, s
val rsapss_sign_msg_to_bn:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (lbignum t (blocks modBits (bits t)))
(requires rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> bn_v res < pow2 (modBits - 1))
let rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be #t emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
m
val rsapss_sign_compute_sgnt:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_compute_sgnt #t modBits eBits dBits skey m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
let eq_b, s = rsapss_sign_bn #t modBits eBits dBits skey m in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let sgnt = bn_to_bytes_be k s in
eq_b, sgnt
val rsapss_sign_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
rsapss_skey_pre modBits eBits dBits skey /\
rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> True)
let rsapss_sign_ #t a modBits eBits dBits skey sLen salt msgLen msg =
let m = rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg in
rsapss_sign_compute_sgnt #t modBits eBits dBits skey m
val rsapss_sign_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey)
(ensures
(let eq_m, s = rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg in
rsapss_sign_post a modBits eBits dBits skey sLen salt msgLen msg eq_m s))
let rsapss_sign_lemma #t a modBits eBits dBits skey sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
assert (bn_v m < bn_v n);
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
bn_eq_mask_lemma m m';
let s' = map (logand eq_m) s in
bn_mask_lemma s eq_m;
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
Math.Lemmas.pow2_le_compat (8 * k) modBits;
assert (bn_v s' < pow2 (8 * k));
let sgnt = bn_to_bytes_be k s' in
bn_to_bytes_be_lemma k s'
val rsapss_sign:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> sgnt:lseq uint8 (blocks modBits 8)
-> Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires rsapss_skey_pre modBits eBits dBits skey)
(ensures fun (b, sgnt) ->
rsapss_sign_post1 a modBits eBits dBits skey sLen salt msgLen msg b sgnt)
let rsapss_sign #t a modBits eBits dBits skey sLen salt msgLen msg sgnt =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
sLen + hLen + 2 <= blocks (modBits - 1) 8 in
if b then begin
rsapss_sign_lemma a modBits eBits dBits skey sLen salt msgLen msg;
rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg end
else
false, sgnt
val rsapss_verify_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> m_def:lbignum t (blocks modBits (bits t))
-> s:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True) | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat{Hacl.Spec.RSAPSS.pkey_len_pre t modBits eBits} ->
pkey:
Hacl.Spec.Bignum.Definitions.lbignum t
(2 * Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks eBits (Lib.IntTypes.bits t)) ->
m_def:
Hacl.Spec.Bignum.Definitions.lbignum t
(Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t)) ->
s:
Hacl.Spec.Bignum.Definitions.lbignum t
(Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t))
-> Prims.Pure
(Prims.bool *
Hacl.Spec.Bignum.Definitions.lbignum t
(Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t))) | Prims.Pure | [] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.RSAPSS.pkey_len_pre",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.bits",
"Hacl.Spec.Bignum.Base.unsafe_bool_of_limb",
"Hacl.Spec.RSAPSS.bn_lt_pow2",
"FStar.Pervasives.Native.Mktuple2",
"Prims.bool",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_vartime_precompr2",
"Prims.unit",
"Hacl.Spec.Bignum.Montgomery.bn_precomp_r2_mod_n_lemma",
"Prims.op_Subtraction",
"FStar.Math.Lemmas.pow2_le_compat",
"Hacl.Spec.Bignum.bn_lt_mask_lemma",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.bn_lt_mask",
"Lib.Sequence.lseq",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.op_Multiply",
"Prims.l_Forall",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.Sequence.sub",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"Prims.pow2",
"Prims.int",
"Lib.IntTypes.numbytes"
] | [] | false | false | false | false | false | let rsapss_verify_bn #t modBits eBits pkey m_def s =
| let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
if BB.unsafe_bool_of_limb mask
then
(Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
if bn_lt_pow2 modBits m then (true, m) else false, m)
else false, m_def | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_sign_compute_sgnt | val rsapss_sign_compute_sgnt:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True) | val rsapss_sign_compute_sgnt:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True) | let rsapss_sign_compute_sgnt #t modBits eBits dBits skey m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
let eq_b, s = rsapss_sign_bn #t modBits eBits dBits skey m in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let sgnt = bn_to_bytes_be k s in
eq_b, sgnt | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 12,
"end_line": 389,
"start_col": 0,
"start_line": 377
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)
val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
let rsapss_verify_pre a sLen msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a
val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post #t a modBits eBits pkey sLen sgnt msgLen msg verify =
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify_ a modBits pkeys sLen sgnt msgLen msg)
val rsapss_verify_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post1 #t a modBits eBits pkey sLen k sgnt msgLen msg verify =
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify a modBits pkeys sLen k sgnt msgLen msg)
val rsapss_sign_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_bn #t modBits eBits dBits skey m =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
let s = map (logand eq_m) s in
BB.unsafe_bool_of_limb eq_m, s
val rsapss_sign_msg_to_bn:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (lbignum t (blocks modBits (bits t)))
(requires rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> bn_v res < pow2 (modBits - 1))
let rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be #t emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
m
val rsapss_sign_compute_sgnt:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True) | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat ->
dBits: Lib.IntTypes.size_nat{Hacl.Spec.RSAPSS.skey_len_pre t modBits eBits dBits} ->
skey:
Hacl.Spec.Bignum.Definitions.lbignum t
(2 * Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks eBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks dBits (Lib.IntTypes.bits t)) ->
m:
Hacl.Spec.Bignum.Definitions.lbignum t
(Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t))
-> Prims.Pure
(Prims.bool *
Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks modBits 8)) | Prims.Pure | [] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.RSAPSS.skey_len_pre",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.bits",
"Prims.bool",
"FStar.Pervasives.Native.Mktuple2",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Hacl.Spec.Bignum.bn_to_bytes_be",
"Prims.unit",
"Prims._assert",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.max_size_t",
"Prims.eq2",
"Lib.IntTypes.size_pos",
"Prims.l_or",
"Hacl.Spec.RSAPSS.blocks_numb_lemma",
"Hacl.Spec.RSAPSS.blocks_bits_lemma",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.RSAPSS.rsapss_sign_bn",
"Prims.pos",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_Multiply",
"Prims.int",
"Lib.IntTypes.numbytes"
] | [] | false | false | false | false | false | let rsapss_sign_compute_sgnt #t modBits eBits dBits skey m =
| let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
let eq_b, s = rsapss_sign_bn #t modBits eBits dBits skey m in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let sgnt = bn_to_bytes_be k s in
eq_b, sgnt | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.sub_ptr_value_is | val sub_ptr_value_is (#a: _) (b0 b1: ibuffer a) (h: HS.mem) (i len: U32.t) (v: Seq.seq a)
: Lemma
(requires
U32.v i + U32.v len <= length b1 /\ b0 == mgsub (immutable_preorder a) b1 i len /\
value_is b1 v /\ Seq.length v == length b1)
(ensures value_is b0 (Seq.slice v (U32.v i) (U32.v i + U32.v len))) | val sub_ptr_value_is (#a: _) (b0 b1: ibuffer a) (h: HS.mem) (i len: U32.t) (v: Seq.seq a)
: Lemma
(requires
U32.v i + U32.v len <= length b1 /\ b0 == mgsub (immutable_preorder a) b1 i len /\
value_is b1 v /\ Seq.length v == length b1)
(ensures value_is b0 (Seq.slice v (U32.v i) (U32.v i + U32.v len))) | let sub_ptr_value_is (#a:_) (b0 b1:ibuffer a) (h:HS.mem) (i len:U32.t) (v:Seq.seq a)
: Lemma
(requires
U32.v i + U32.v len <= length b1 /\
b0 == mgsub (immutable_preorder a) b1 i len /\
value_is b1 v /\
Seq.length v == length b1)
(ensures
value_is b0 (Seq.slice v (U32.v i) (U32.v i + U32.v len)))
= let sub_v = Seq.slice v (U32.v i) (U32.v i + U32.v len) in
witnessed_functorial b1 b0 i len (seq_eq (Ghost.hide v)) (seq_eq (Ghost.hide sub_v)) | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 87,
"end_line": 73,
"start_col": 0,
"start_line": 63
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a)
unfold let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
unfold let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a)
inline_for_extraction
type ipointer (a:Type0) = b:ibuffer a{length b == 1}
inline_for_extraction
type ipointer_or_null (a:Type0) = b:ibuffer a{if g_is_null b then True else length b == 1}
inline_for_extraction let isub (#a:Type0) = msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
inline_for_extraction let ioffset (#a:Type0) = moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
(*
* It's a bit sub-optimal that we have both cpred and seq_eq
* Ideally it should only be the erased version seq_eq
*
* However, Lib.Buffer in hacl is already using cpred, so keeping it for now
* But it should be cleaned up when that dependency is gone
*)
let cpred (#a:Type0) (s:Seq.seq a) :spred a = fun s1 -> Seq.equal s s1
let seq_eq (s:Ghost.erased (Seq.seq 'a)) : spred 'a =
fun s' -> s' `Seq.equal` Ghost.reveal s
let value_is #a (b:ibuffer a) (s:Ghost.erased (Seq.seq a)) =
witnessed b (seq_eq s) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b0: LowStar.ImmutableBuffer.ibuffer a ->
b1: LowStar.ImmutableBuffer.ibuffer a ->
h: FStar.Monotonic.HyperStack.mem ->
i: FStar.UInt32.t ->
len: FStar.UInt32.t ->
v: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma
(requires
FStar.UInt32.v i + FStar.UInt32.v len <= LowStar.Monotonic.Buffer.length b1 /\
b0 == LowStar.Monotonic.Buffer.mgsub (LowStar.ImmutableBuffer.immutable_preorder a) b1 i len /\
LowStar.ImmutableBuffer.value_is b1 (FStar.Ghost.hide v) /\
FStar.Seq.Base.length v == LowStar.Monotonic.Buffer.length b1)
(ensures
LowStar.ImmutableBuffer.value_is b0
(FStar.Ghost.hide (FStar.Seq.Base.slice v
(FStar.UInt32.v i)
(FStar.UInt32.v i + FStar.UInt32.v len)))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.ImmutableBuffer.ibuffer",
"FStar.Monotonic.HyperStack.mem",
"FStar.UInt32.t",
"FStar.Seq.Base.seq",
"LowStar.Monotonic.Buffer.witnessed_functorial",
"LowStar.ImmutableBuffer.immutable_preorder",
"LowStar.ImmutableBuffer.seq_eq",
"FStar.Ghost.hide",
"FStar.Seq.Base.slice",
"FStar.UInt32.v",
"Prims.op_Addition",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowStar.Monotonic.Buffer.length",
"Prims.eq2",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Monotonic.Buffer.mgsub",
"LowStar.ImmutableBuffer.value_is",
"Prims.nat",
"FStar.Seq.Base.length",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let sub_ptr_value_is (#a: _) (b0 b1: ibuffer a) (h: HS.mem) (i len: U32.t) (v: Seq.seq a)
: Lemma
(requires
U32.v i + U32.v len <= length b1 /\ b0 == mgsub (immutable_preorder a) b1 i len /\
value_is b1 v /\ Seq.length v == length b1)
(ensures value_is b0 (Seq.slice v (U32.v i) (U32.v i + U32.v len))) =
| let sub_v = Seq.slice v (U32.v i) (U32.v i + U32.v len) in
witnessed_functorial b1 b0 i len (seq_eq (Ghost.hide v)) (seq_eq (Ghost.hide sub_v)) | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.ialloca | val ialloca (#a: Type0) (init: a) (len: U32.t)
: HST.StackInline (libuffer a (U32.v len) (Seq.create (U32.v len) init))
(requires (fun _ -> alloca_pre len))
(ensures
(fun h0 b h1 ->
alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init) /\
frameOf b == HS.get_tip h0)) | val ialloca (#a: Type0) (init: a) (len: U32.t)
: HST.StackInline (libuffer a (U32.v len) (Seq.create (U32.v len) init))
(requires (fun _ -> alloca_pre len))
(ensures
(fun h0 b h1 ->
alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init) /\
frameOf b == HS.get_tip h0)) | let ialloca (#a:Type0) (init:a) (len:U32.t)
:HST.StackInline (libuffer a (U32.v len) (Seq.create (U32.v len) init))
(requires (fun _ -> alloca_pre len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init) /\
frameOf b == HS.get_tip h0))
= let b = malloca init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 155,
"start_col": 0,
"start_line": 148
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a)
unfold let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
unfold let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a)
inline_for_extraction
type ipointer (a:Type0) = b:ibuffer a{length b == 1}
inline_for_extraction
type ipointer_or_null (a:Type0) = b:ibuffer a{if g_is_null b then True else length b == 1}
inline_for_extraction let isub (#a:Type0) = msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
inline_for_extraction let ioffset (#a:Type0) = moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
(*
* It's a bit sub-optimal that we have both cpred and seq_eq
* Ideally it should only be the erased version seq_eq
*
* However, Lib.Buffer in hacl is already using cpred, so keeping it for now
* But it should be cleaned up when that dependency is gone
*)
let cpred (#a:Type0) (s:Seq.seq a) :spred a = fun s1 -> Seq.equal s s1
let seq_eq (s:Ghost.erased (Seq.seq 'a)) : spred 'a =
fun s' -> s' `Seq.equal` Ghost.reveal s
let value_is #a (b:ibuffer a) (s:Ghost.erased (Seq.seq a)) =
witnessed b (seq_eq s)
let sub_ptr_value_is (#a:_) (b0 b1:ibuffer a) (h:HS.mem) (i len:U32.t) (v:Seq.seq a)
: Lemma
(requires
U32.v i + U32.v len <= length b1 /\
b0 == mgsub (immutable_preorder a) b1 i len /\
value_is b1 v /\
Seq.length v == length b1)
(ensures
value_is b0 (Seq.slice v (U32.v i) (U32.v i + U32.v len)))
= let sub_v = Seq.slice v (U32.v i) (U32.v i + U32.v len) in
witnessed_functorial b1 b0 i len (seq_eq (Ghost.hide v)) (seq_eq (Ghost.hide sub_v))
unfold let libuffer (a:Type0) (len:nat) (s:Seq.seq a) =
b:lmbuffer a (immutable_preorder a) (immutable_preorder a) len{witnessed b (cpred s)}
unfold let libuffer_or_null (a:Type0) (len:nat) (r:HS.rid) (s:Seq.seq a) =
b:lmbuffer_or_null a (immutable_preorder a) (immutable_preorder a) len r{(not (g_is_null b)) ==>
witnessed b (cpred s)}
let igcmalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mgcmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
(*
* Unlike other allocation functions in this module,
* this function (and other flavors of alloc_and_blit) don't provide the witnessed contents
* as the refinement of the return type
* This is because the contents depend on the input memory (== the contents of src)
*)
let igcmalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mgcmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
inline_for_extraction
let igcmalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= igcmalloc r init len
let imalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
let imalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r /\ freeable b})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
inline_for_extraction
let imalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){(not (g_is_null b)) ==> freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= imalloc r init len | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | init: a -> len: FStar.UInt32.t
-> FStar.HyperStack.ST.StackInline
(LowStar.ImmutableBuffer.libuffer a
(FStar.UInt32.v len)
(FStar.Seq.Base.create (FStar.UInt32.v len) init)) | FStar.HyperStack.ST.StackInline | [] | [] | [
"FStar.UInt32.t",
"LowStar.ImmutableBuffer.libuffer",
"FStar.UInt32.v",
"FStar.Seq.Base.create",
"Prims.unit",
"LowStar.Monotonic.Buffer.witness_p",
"LowStar.ImmutableBuffer.immutable_preorder",
"LowStar.ImmutableBuffer.cpred",
"LowStar.Monotonic.Buffer.mbuffer",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"LowStar.Monotonic.Buffer.malloca",
"LowStar.Monotonic.Buffer.lmbuffer",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.alloca_pre",
"LowStar.Monotonic.Buffer.alloc_post_mem_common",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"FStar.Monotonic.HyperStack.get_tip"
] | [] | false | true | false | false | false | let ialloca (#a: Type0) (init: a) (len: U32.t)
: HST.StackInline (libuffer a (U32.v len) (Seq.create (U32.v len) init))
(requires (fun _ -> alloca_pre len))
(ensures
(fun h0 b h1 ->
alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init) /\
frameOf b == HS.get_tip h0)) =
| let b = malloca init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.igcmalloc | val igcmalloc (#a: Type0) (r: HS.rid) (init: a) (len: U32.t)
: HST.ST
(b: libuffer a (U32.v len) (Seq.create (U32.v len) init) {frameOf b == r /\ recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init))) | val igcmalloc (#a: Type0) (r: HS.rid) (init: a) (len: U32.t)
: HST.ST
(b: libuffer a (U32.v len) (Seq.create (U32.v len) init) {frameOf b == r /\ recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init))) | let igcmalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mgcmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 88,
"start_col": 0,
"start_line": 82
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a)
unfold let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
unfold let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a)
inline_for_extraction
type ipointer (a:Type0) = b:ibuffer a{length b == 1}
inline_for_extraction
type ipointer_or_null (a:Type0) = b:ibuffer a{if g_is_null b then True else length b == 1}
inline_for_extraction let isub (#a:Type0) = msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
inline_for_extraction let ioffset (#a:Type0) = moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
(*
* It's a bit sub-optimal that we have both cpred and seq_eq
* Ideally it should only be the erased version seq_eq
*
* However, Lib.Buffer in hacl is already using cpred, so keeping it for now
* But it should be cleaned up when that dependency is gone
*)
let cpred (#a:Type0) (s:Seq.seq a) :spred a = fun s1 -> Seq.equal s s1
let seq_eq (s:Ghost.erased (Seq.seq 'a)) : spred 'a =
fun s' -> s' `Seq.equal` Ghost.reveal s
let value_is #a (b:ibuffer a) (s:Ghost.erased (Seq.seq a)) =
witnessed b (seq_eq s)
let sub_ptr_value_is (#a:_) (b0 b1:ibuffer a) (h:HS.mem) (i len:U32.t) (v:Seq.seq a)
: Lemma
(requires
U32.v i + U32.v len <= length b1 /\
b0 == mgsub (immutable_preorder a) b1 i len /\
value_is b1 v /\
Seq.length v == length b1)
(ensures
value_is b0 (Seq.slice v (U32.v i) (U32.v i + U32.v len)))
= let sub_v = Seq.slice v (U32.v i) (U32.v i + U32.v len) in
witnessed_functorial b1 b0 i len (seq_eq (Ghost.hide v)) (seq_eq (Ghost.hide sub_v))
unfold let libuffer (a:Type0) (len:nat) (s:Seq.seq a) =
b:lmbuffer a (immutable_preorder a) (immutable_preorder a) len{witnessed b (cpred s)}
unfold let libuffer_or_null (a:Type0) (len:nat) (r:HS.rid) (s:Seq.seq a) =
b:lmbuffer_or_null a (immutable_preorder a) (immutable_preorder a) len r{(not (g_is_null b)) ==>
witnessed b (cpred s)} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: FStar.Monotonic.HyperHeap.rid -> init: a -> len: FStar.UInt32.t
-> FStar.HyperStack.ST.ST
(b:
LowStar.ImmutableBuffer.libuffer a
(FStar.UInt32.v len)
(FStar.Seq.Base.create (FStar.UInt32.v len) init)
{LowStar.Monotonic.Buffer.frameOf b == r /\ LowStar.Monotonic.Buffer.recallable b}) | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Monotonic.HyperHeap.rid",
"FStar.UInt32.t",
"LowStar.ImmutableBuffer.libuffer",
"FStar.UInt32.v",
"FStar.Seq.Base.create",
"Prims.l_and",
"Prims.eq2",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.ImmutableBuffer.immutable_preorder",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"LowStar.Monotonic.Buffer.witness_p",
"LowStar.ImmutableBuffer.cpred",
"LowStar.Monotonic.Buffer.mbuffer",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"LowStar.Monotonic.Buffer.mgcmalloc",
"LowStar.Monotonic.Buffer.lmbuffer",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.malloc_pre",
"LowStar.Monotonic.Buffer.alloc_post_mem_common"
] | [] | false | true | false | false | false | let igcmalloc (#a: Type0) (r: HS.rid) (init: a) (len: U32.t)
: HST.ST
(b: libuffer a (U32.v len) (Seq.create (U32.v len) init) {frameOf b == r /\ recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init))) =
| let b = mgcmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.igcmalloc_partial | val igcmalloc_partial (#a: Type0) (r: HS.rid) (init: a) (len: U32.t)
: HST.ST (b: libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init) {recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init))) | val igcmalloc_partial (#a: Type0) (r: HS.rid) (init: a) (len: U32.t)
: HST.ST (b: libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init) {recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init))) | let igcmalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= igcmalloc r init len | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 24,
"end_line": 116,
"start_col": 0,
"start_line": 112
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a)
unfold let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
unfold let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a)
inline_for_extraction
type ipointer (a:Type0) = b:ibuffer a{length b == 1}
inline_for_extraction
type ipointer_or_null (a:Type0) = b:ibuffer a{if g_is_null b then True else length b == 1}
inline_for_extraction let isub (#a:Type0) = msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
inline_for_extraction let ioffset (#a:Type0) = moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
(*
* It's a bit sub-optimal that we have both cpred and seq_eq
* Ideally it should only be the erased version seq_eq
*
* However, Lib.Buffer in hacl is already using cpred, so keeping it for now
* But it should be cleaned up when that dependency is gone
*)
let cpred (#a:Type0) (s:Seq.seq a) :spred a = fun s1 -> Seq.equal s s1
let seq_eq (s:Ghost.erased (Seq.seq 'a)) : spred 'a =
fun s' -> s' `Seq.equal` Ghost.reveal s
let value_is #a (b:ibuffer a) (s:Ghost.erased (Seq.seq a)) =
witnessed b (seq_eq s)
let sub_ptr_value_is (#a:_) (b0 b1:ibuffer a) (h:HS.mem) (i len:U32.t) (v:Seq.seq a)
: Lemma
(requires
U32.v i + U32.v len <= length b1 /\
b0 == mgsub (immutable_preorder a) b1 i len /\
value_is b1 v /\
Seq.length v == length b1)
(ensures
value_is b0 (Seq.slice v (U32.v i) (U32.v i + U32.v len)))
= let sub_v = Seq.slice v (U32.v i) (U32.v i + U32.v len) in
witnessed_functorial b1 b0 i len (seq_eq (Ghost.hide v)) (seq_eq (Ghost.hide sub_v))
unfold let libuffer (a:Type0) (len:nat) (s:Seq.seq a) =
b:lmbuffer a (immutable_preorder a) (immutable_preorder a) len{witnessed b (cpred s)}
unfold let libuffer_or_null (a:Type0) (len:nat) (r:HS.rid) (s:Seq.seq a) =
b:lmbuffer_or_null a (immutable_preorder a) (immutable_preorder a) len r{(not (g_is_null b)) ==>
witnessed b (cpred s)}
let igcmalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mgcmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
(*
* Unlike other allocation functions in this module,
* this function (and other flavors of alloc_and_blit) don't provide the witnessed contents
* as the refinement of the return type
* This is because the contents depend on the input memory (== the contents of src)
*)
let igcmalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mgcmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: FStar.Monotonic.HyperHeap.rid -> init: a -> len: FStar.UInt32.t
-> FStar.HyperStack.ST.ST
(b:
LowStar.ImmutableBuffer.libuffer_or_null a
(FStar.UInt32.v len)
r
(FStar.Seq.Base.create (FStar.UInt32.v len) init) {LowStar.Monotonic.Buffer.recallable b}) | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Monotonic.HyperHeap.rid",
"FStar.UInt32.t",
"LowStar.ImmutableBuffer.igcmalloc",
"LowStar.ImmutableBuffer.libuffer",
"FStar.UInt32.v",
"FStar.Seq.Base.create",
"Prims.l_and",
"Prims.eq2",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.ImmutableBuffer.immutable_preorder",
"LowStar.Monotonic.Buffer.recallable",
"LowStar.ImmutableBuffer.libuffer_or_null",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.malloc_pre",
"LowStar.Monotonic.Buffer.alloc_partial_post_mem_common"
] | [] | false | true | false | false | false | let igcmalloc_partial (#a: Type0) (r: HS.rid) (init: a) (len: U32.t)
: HST.ST (b: libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init) {recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init))) =
| igcmalloc r init len | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_load_pkey | val rsapss_load_pkey:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8) ->
tuple2 bool (lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))) | val rsapss_load_pkey:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8) ->
tuple2 bool (lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))) | let rsapss_load_pkey #t modBits eBits nb eb =
let n = bn_from_bytes_be (blocks modBits 8) nb in
let r2 = SM.bn_precomp_r2_mod_n (modBits - 1) n in
let e = bn_from_bytes_be (blocks eBits 8) eb in
let pkey = (n @| r2) @| e in
let m0 = rsapss_check_modulus modBits n in
let m1 = rsapss_check_exponent eBits e in
let m = m0 &. m1 in
BB.unsafe_bool_of_limb m, pkey | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 32,
"end_line": 854,
"start_col": 0,
"start_line": 845
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)
val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
let rsapss_verify_pre a sLen msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a
val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post #t a modBits eBits pkey sLen sgnt msgLen msg verify =
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify_ a modBits pkeys sLen sgnt msgLen msg)
val rsapss_verify_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post1 #t a modBits eBits pkey sLen k sgnt msgLen msg verify =
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify a modBits pkeys sLen k sgnt msgLen msg)
val rsapss_sign_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_bn #t modBits eBits dBits skey m =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
let s = map (logand eq_m) s in
BB.unsafe_bool_of_limb eq_m, s
val rsapss_sign_msg_to_bn:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (lbignum t (blocks modBits (bits t)))
(requires rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> bn_v res < pow2 (modBits - 1))
let rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be #t emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
m
val rsapss_sign_compute_sgnt:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_compute_sgnt #t modBits eBits dBits skey m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
let eq_b, s = rsapss_sign_bn #t modBits eBits dBits skey m in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let sgnt = bn_to_bytes_be k s in
eq_b, sgnt
val rsapss_sign_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
rsapss_skey_pre modBits eBits dBits skey /\
rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> True)
let rsapss_sign_ #t a modBits eBits dBits skey sLen salt msgLen msg =
let m = rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg in
rsapss_sign_compute_sgnt #t modBits eBits dBits skey m
val rsapss_sign_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey)
(ensures
(let eq_m, s = rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg in
rsapss_sign_post a modBits eBits dBits skey sLen salt msgLen msg eq_m s))
let rsapss_sign_lemma #t a modBits eBits dBits skey sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
assert (bn_v m < bn_v n);
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
bn_eq_mask_lemma m m';
let s' = map (logand eq_m) s in
bn_mask_lemma s eq_m;
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
Math.Lemmas.pow2_le_compat (8 * k) modBits;
assert (bn_v s' < pow2 (8 * k));
let sgnt = bn_to_bytes_be k s' in
bn_to_bytes_be_lemma k s'
val rsapss_sign:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> sgnt:lseq uint8 (blocks modBits 8)
-> Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires rsapss_skey_pre modBits eBits dBits skey)
(ensures fun (b, sgnt) ->
rsapss_sign_post1 a modBits eBits dBits skey sLen salt msgLen msg b sgnt)
let rsapss_sign #t a modBits eBits dBits skey sLen salt msgLen msg sgnt =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
sLen + hLen + 2 <= blocks (modBits - 1) 8 in
if b then begin
rsapss_sign_lemma a modBits eBits dBits skey sLen salt msgLen msg;
rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg end
else
false, sgnt
val rsapss_verify_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> m_def:lbignum t (blocks modBits (bits t))
-> s:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_bn #t modBits eBits pkey m_def s =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
if bn_lt_pow2 modBits m then (true, m)
else false, m end
else false, m_def
val rsapss_verify_bn_to_msg:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> m:lbignum t (blocks modBits (bits t)) ->
Pure bool
(requires rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_bn_to_msg #t a modBits sLen msgLen msg m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let m1 = sub m 0 (blocks emLen numb) in
let em = bn_to_bytes_be emLen m1 in
S.pss_verify a sLen msgLen msg emBits em
val rsapss_verify_compute_msg:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sgnt:lseq uint8 (blocks modBits 8) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_compute_msg #t modBits eBits pkey sgnt =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
let m_def = create nLen (uint #t 0) in
rsapss_verify_bn #t modBits eBits pkey m_def s
val rsapss_verify_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires
rsapss_pkey_pre modBits eBits pkey /\
rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_ #t a modBits eBits pkey sLen sgnt msgLen msg =
let (b, m) = rsapss_verify_compute_msg #t modBits eBits pkey sgnt in
if b then
rsapss_verify_bn_to_msg a modBits sLen msgLen msg m
else
false
val rsapss_verify_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey)
(ensures
rsapss_verify_post a modBits eBits pkey sLen sgnt msgLen msg
(rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg))
let rsapss_verify_lemma #t a modBits eBits pkey sLen sgnt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
bn_from_bytes_be_lemma #t k sgnt;
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
let res =
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
bn_lt_pow2_lemma modBits m;
assert (bn_lt_pow2 modBits m == (bn_v m < pow2 (emLen * 8)));
let res =
if bn_lt_pow2 modBits m then begin
let m1 = sub m 0 (blocks emLen numb) in
bn_eval_sub modBits m;
assert (bn_v m1 == bn_v m);
let em = bn_to_bytes_be emLen m1 in
bn_to_bytes_be_lemma emLen m1;
S.pss_verify a sLen msgLen msg emBits em end
else false in
() end in
()
val rsapss_verify:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun r -> rsapss_verify_post1 a modBits eBits pkey sLen k sgnt msgLen msg r)
let rsapss_verify #t a modBits eBits pkey sLen k sgnt msgLen msg =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
//assert (max_size_t < Hash.max_input_length a);
assert (hLen + 8 < max_size_t);
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
k = blocks modBits 8 in
if b then begin
rsapss_verify_lemma a modBits eBits pkey sLen sgnt msgLen msg;
rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg end
else
false
val bn_check_num_bits: #t:limb_t -> bs:size_pos -> b:lbignum t (blocks bs (bits t)) ->
res:limb t{v res == (if bn_v b < pow2 bs then v (ones t SEC) else v (zeros t SEC))}
let bn_check_num_bits #t bs b =
let bLen = blocks bs (bits t) in
assert (bs <= bits t * bLen);
let m : limb t = if bs = bits t * bLen then ones t SEC else bn_lt_pow2_mask b bs in
(if bs = bits t * bLen then begin
bn_eval_bound b bLen;
Math.Lemmas.pow2_le_compat (bits t * bLen) bs end
else
bn_lt_pow2_mask_lemma b bs);
assert (v m == (if bn_v b < pow2 bs then v (ones t SEC) else v (zeros t SEC)));
m
val rsapss_check_modulus: #t:limb_t -> modBits:size_pos -> n:lbignum t (blocks modBits (bits t)) ->
res:limb t{v res == (if (bn_v n % 2 = 1 && pow2 (modBits - 1) < bn_v n && bn_v n < pow2 modBits) then v (ones t SEC) else v (zeros t SEC))}
let rsapss_check_modulus #t modBits n =
let bit0 = bn_is_odd n in
bn_is_odd_lemma n;
assert (v bit0 == bn_v n % 2);
let m0 = uint #t 0 -. bit0 in
let m1 = bn_gt_pow2_mask n (modBits - 1) in
bn_gt_pow2_mask_lemma n (modBits - 1);
let m2 = bn_check_num_bits modBits n in
let m = m0 &. (m1 &. m2) in
logand_lemma m0 (m1 &. m2);
logand_lemma m1 m2;
m
val rsapss_check_exponent: #t:limb_t -> eBits:size_pos -> e:lbignum t (blocks eBits (bits t)) ->
res:limb t{v res == (if (0 < bn_v e && bn_v e < pow2 eBits) then v (ones t SEC) else v (zeros t SEC))}
let rsapss_check_exponent #t eBits e =
let m0 = bn_is_zero_mask e in
bn_is_zero_mask_lemma e;
let m1 = bn_check_num_bits eBits e in
let m = (lognot m0) &. m1 in
lognot_lemma m0;
logand_lemma (lognot m0) m1;
m
val rsapss_load_pkey_post:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_load_pkey_post #t modBits eBits nb eb pkey =
let bits = bits t in
let pkey_s = S.rsapss_load_pkey modBits eBits nb eb in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let e = sub pkey (nLen + nLen) eLen in
rsapss_pkey_pre modBits eBits pkey /\
Some? pkey_s /\
bn_v n == S.Mk_rsapss_pkey?.n (Some?.v pkey_s) /\
bn_v e == S.Mk_rsapss_pkey?.e (Some?.v pkey_s)
val rsapss_load_skey_post:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8)
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_load_skey_post #t modBits eBits dBits nb eb db skey =
let bits = bits t in
let skey_s = S.rsapss_load_skey modBits eBits dBits nb eb db in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
rsapss_skey_pre modBits eBits dBits skey /\
Some? skey_s /\ (let pkey_s = S.Mk_rsapss_skey?.pkey (Some?.v skey_s) in
bn_v n == S.Mk_rsapss_pkey?.n pkey_s /\
bn_v e == S.Mk_rsapss_pkey?.e pkey_s /\
bn_v d == S.Mk_rsapss_skey?.d (Some?.v skey_s))
val rsapss_load_pkey:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8) ->
tuple2 bool (lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))) | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat{Hacl.Spec.RSAPSS.pkey_len_pre t modBits eBits} ->
nb: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks modBits 8) ->
eb: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks eBits 8)
-> Prims.bool *
Hacl.Spec.Bignum.Definitions.lbignum t
(2 * Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks eBits (Lib.IntTypes.bits t)) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.RSAPSS.pkey_len_pre",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Hacl.Spec.Bignum.Definitions.blocks",
"FStar.Pervasives.Native.Mktuple2",
"Prims.bool",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Lib.IntTypes.bits",
"Hacl.Spec.Bignum.Base.unsafe_bool_of_limb",
"Lib.IntTypes.int_t",
"Lib.IntTypes.SEC",
"Lib.IntTypes.op_Amp_Dot",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.eq2",
"Prims.int",
"Lib.IntTypes.range",
"Lib.IntTypes.v",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.pow2",
"Lib.IntTypes.ones",
"Lib.IntTypes.zeros",
"Hacl.Spec.RSAPSS.rsapss_check_exponent",
"Prims.op_Equality",
"Prims.op_Modulus",
"Prims.op_Subtraction",
"Hacl.Spec.RSAPSS.rsapss_check_modulus",
"Lib.IntTypes.numbytes",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.append",
"Lib.Sequence.op_At_Bar",
"Hacl.Spec.Bignum.bn_from_bytes_be",
"Hacl.Spec.Bignum.Montgomery.bn_precomp_r2_mod_n",
"FStar.Pervasives.Native.tuple2"
] | [] | false | false | false | false | false | let rsapss_load_pkey #t modBits eBits nb eb =
| let n = bn_from_bytes_be (blocks modBits 8) nb in
let r2 = SM.bn_precomp_r2_mod_n (modBits - 1) n in
let e = bn_from_bytes_be (blocks eBits 8) eb in
let pkey = (n @| r2) @| e in
let m0 = rsapss_check_modulus modBits n in
let m1 = rsapss_check_exponent eBits e in
let m = m0 &. m1 in
BB.unsafe_bool_of_limb m, pkey | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_skey_sign | val rsapss_skey_sign:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8)
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> sgnt:lseq uint8 (blocks modBits 8)
-> Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires True)
(ensures fun (b, sgnt) ->
(let sgnt_s = S.rsapss_skey_sign a modBits eBits dBits nb eb db sLen salt msgLen msg in
if b then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)) | val rsapss_skey_sign:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8)
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> sgnt:lseq uint8 (blocks modBits 8)
-> Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires True)
(ensures fun (b, sgnt) ->
(let sgnt_s = S.rsapss_skey_sign a modBits eBits dBits nb eb db sLen salt msgLen msg in
if b then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)) | let rsapss_skey_sign #t a modBits eBits dBits nb eb db sLen salt msgLen msg sgnt =
let b, skey = rsapss_load_skey #t modBits eBits dBits nb eb db in
rsapss_load_skey_lemma #t modBits eBits dBits nb eb db;
if b then
rsapss_sign a modBits eBits dBits skey sLen salt msgLen msg sgnt
else
false, sgnt | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 975,
"start_col": 0,
"start_line": 968
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)
val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
let rsapss_verify_pre a sLen msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a
val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post #t a modBits eBits pkey sLen sgnt msgLen msg verify =
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify_ a modBits pkeys sLen sgnt msgLen msg)
val rsapss_verify_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post1 #t a modBits eBits pkey sLen k sgnt msgLen msg verify =
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify a modBits pkeys sLen k sgnt msgLen msg)
val rsapss_sign_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_bn #t modBits eBits dBits skey m =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
let s = map (logand eq_m) s in
BB.unsafe_bool_of_limb eq_m, s
val rsapss_sign_msg_to_bn:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (lbignum t (blocks modBits (bits t)))
(requires rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> bn_v res < pow2 (modBits - 1))
let rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be #t emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
m
val rsapss_sign_compute_sgnt:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_compute_sgnt #t modBits eBits dBits skey m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
let eq_b, s = rsapss_sign_bn #t modBits eBits dBits skey m in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let sgnt = bn_to_bytes_be k s in
eq_b, sgnt
val rsapss_sign_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
rsapss_skey_pre modBits eBits dBits skey /\
rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> True)
let rsapss_sign_ #t a modBits eBits dBits skey sLen salt msgLen msg =
let m = rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg in
rsapss_sign_compute_sgnt #t modBits eBits dBits skey m
val rsapss_sign_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey)
(ensures
(let eq_m, s = rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg in
rsapss_sign_post a modBits eBits dBits skey sLen salt msgLen msg eq_m s))
let rsapss_sign_lemma #t a modBits eBits dBits skey sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
assert (bn_v m < bn_v n);
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
bn_eq_mask_lemma m m';
let s' = map (logand eq_m) s in
bn_mask_lemma s eq_m;
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
Math.Lemmas.pow2_le_compat (8 * k) modBits;
assert (bn_v s' < pow2 (8 * k));
let sgnt = bn_to_bytes_be k s' in
bn_to_bytes_be_lemma k s'
val rsapss_sign:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> sgnt:lseq uint8 (blocks modBits 8)
-> Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires rsapss_skey_pre modBits eBits dBits skey)
(ensures fun (b, sgnt) ->
rsapss_sign_post1 a modBits eBits dBits skey sLen salt msgLen msg b sgnt)
let rsapss_sign #t a modBits eBits dBits skey sLen salt msgLen msg sgnt =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
sLen + hLen + 2 <= blocks (modBits - 1) 8 in
if b then begin
rsapss_sign_lemma a modBits eBits dBits skey sLen salt msgLen msg;
rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg end
else
false, sgnt
val rsapss_verify_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> m_def:lbignum t (blocks modBits (bits t))
-> s:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_bn #t modBits eBits pkey m_def s =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
if bn_lt_pow2 modBits m then (true, m)
else false, m end
else false, m_def
val rsapss_verify_bn_to_msg:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> m:lbignum t (blocks modBits (bits t)) ->
Pure bool
(requires rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_bn_to_msg #t a modBits sLen msgLen msg m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let m1 = sub m 0 (blocks emLen numb) in
let em = bn_to_bytes_be emLen m1 in
S.pss_verify a sLen msgLen msg emBits em
val rsapss_verify_compute_msg:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sgnt:lseq uint8 (blocks modBits 8) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_compute_msg #t modBits eBits pkey sgnt =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
let m_def = create nLen (uint #t 0) in
rsapss_verify_bn #t modBits eBits pkey m_def s
val rsapss_verify_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires
rsapss_pkey_pre modBits eBits pkey /\
rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_ #t a modBits eBits pkey sLen sgnt msgLen msg =
let (b, m) = rsapss_verify_compute_msg #t modBits eBits pkey sgnt in
if b then
rsapss_verify_bn_to_msg a modBits sLen msgLen msg m
else
false
val rsapss_verify_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey)
(ensures
rsapss_verify_post a modBits eBits pkey sLen sgnt msgLen msg
(rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg))
let rsapss_verify_lemma #t a modBits eBits pkey sLen sgnt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
bn_from_bytes_be_lemma #t k sgnt;
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
let res =
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
bn_lt_pow2_lemma modBits m;
assert (bn_lt_pow2 modBits m == (bn_v m < pow2 (emLen * 8)));
let res =
if bn_lt_pow2 modBits m then begin
let m1 = sub m 0 (blocks emLen numb) in
bn_eval_sub modBits m;
assert (bn_v m1 == bn_v m);
let em = bn_to_bytes_be emLen m1 in
bn_to_bytes_be_lemma emLen m1;
S.pss_verify a sLen msgLen msg emBits em end
else false in
() end in
()
val rsapss_verify:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun r -> rsapss_verify_post1 a modBits eBits pkey sLen k sgnt msgLen msg r)
let rsapss_verify #t a modBits eBits pkey sLen k sgnt msgLen msg =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
//assert (max_size_t < Hash.max_input_length a);
assert (hLen + 8 < max_size_t);
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
k = blocks modBits 8 in
if b then begin
rsapss_verify_lemma a modBits eBits pkey sLen sgnt msgLen msg;
rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg end
else
false
val bn_check_num_bits: #t:limb_t -> bs:size_pos -> b:lbignum t (blocks bs (bits t)) ->
res:limb t{v res == (if bn_v b < pow2 bs then v (ones t SEC) else v (zeros t SEC))}
let bn_check_num_bits #t bs b =
let bLen = blocks bs (bits t) in
assert (bs <= bits t * bLen);
let m : limb t = if bs = bits t * bLen then ones t SEC else bn_lt_pow2_mask b bs in
(if bs = bits t * bLen then begin
bn_eval_bound b bLen;
Math.Lemmas.pow2_le_compat (bits t * bLen) bs end
else
bn_lt_pow2_mask_lemma b bs);
assert (v m == (if bn_v b < pow2 bs then v (ones t SEC) else v (zeros t SEC)));
m
val rsapss_check_modulus: #t:limb_t -> modBits:size_pos -> n:lbignum t (blocks modBits (bits t)) ->
res:limb t{v res == (if (bn_v n % 2 = 1 && pow2 (modBits - 1) < bn_v n && bn_v n < pow2 modBits) then v (ones t SEC) else v (zeros t SEC))}
let rsapss_check_modulus #t modBits n =
let bit0 = bn_is_odd n in
bn_is_odd_lemma n;
assert (v bit0 == bn_v n % 2);
let m0 = uint #t 0 -. bit0 in
let m1 = bn_gt_pow2_mask n (modBits - 1) in
bn_gt_pow2_mask_lemma n (modBits - 1);
let m2 = bn_check_num_bits modBits n in
let m = m0 &. (m1 &. m2) in
logand_lemma m0 (m1 &. m2);
logand_lemma m1 m2;
m
val rsapss_check_exponent: #t:limb_t -> eBits:size_pos -> e:lbignum t (blocks eBits (bits t)) ->
res:limb t{v res == (if (0 < bn_v e && bn_v e < pow2 eBits) then v (ones t SEC) else v (zeros t SEC))}
let rsapss_check_exponent #t eBits e =
let m0 = bn_is_zero_mask e in
bn_is_zero_mask_lemma e;
let m1 = bn_check_num_bits eBits e in
let m = (lognot m0) &. m1 in
lognot_lemma m0;
logand_lemma (lognot m0) m1;
m
val rsapss_load_pkey_post:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_load_pkey_post #t modBits eBits nb eb pkey =
let bits = bits t in
let pkey_s = S.rsapss_load_pkey modBits eBits nb eb in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let e = sub pkey (nLen + nLen) eLen in
rsapss_pkey_pre modBits eBits pkey /\
Some? pkey_s /\
bn_v n == S.Mk_rsapss_pkey?.n (Some?.v pkey_s) /\
bn_v e == S.Mk_rsapss_pkey?.e (Some?.v pkey_s)
val rsapss_load_skey_post:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8)
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_load_skey_post #t modBits eBits dBits nb eb db skey =
let bits = bits t in
let skey_s = S.rsapss_load_skey modBits eBits dBits nb eb db in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
rsapss_skey_pre modBits eBits dBits skey /\
Some? skey_s /\ (let pkey_s = S.Mk_rsapss_skey?.pkey (Some?.v skey_s) in
bn_v n == S.Mk_rsapss_pkey?.n pkey_s /\
bn_v e == S.Mk_rsapss_pkey?.e pkey_s /\
bn_v d == S.Mk_rsapss_skey?.d (Some?.v skey_s))
val rsapss_load_pkey:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8) ->
tuple2 bool (lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)))
let rsapss_load_pkey #t modBits eBits nb eb =
let n = bn_from_bytes_be (blocks modBits 8) nb in
let r2 = SM.bn_precomp_r2_mod_n (modBits - 1) n in
let e = bn_from_bytes_be (blocks eBits 8) eb in
let pkey = (n @| r2) @| e in
let m0 = rsapss_check_modulus modBits n in
let m1 = rsapss_check_exponent eBits e in
let m = m0 &. m1 in
BB.unsafe_bool_of_limb m, pkey
val rsapss_load_pkey_lemma:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8) ->
Lemma
(let b, pkey = rsapss_load_pkey #t modBits eBits nb eb in
let pkey_s = S.rsapss_load_pkey modBits eBits nb eb in
(if b then rsapss_load_pkey_post modBits eBits nb eb pkey else None? pkey_s))
let rsapss_load_pkey_lemma #t modBits eBits nb eb =
let bits = bits t in
let nbLen = blocks modBits 8 in
let ebLen = blocks eBits 8 in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_from_bytes_be #t nbLen nb in
bn_from_bytes_be_lemma #t nbLen nb;
let r2 = SM.bn_precomp_r2_mod_n (modBits - 1) n in
let e = bn_from_bytes_be #t ebLen eb in
bn_from_bytes_be_lemma #t ebLen eb;
let pkey = (n @| r2) @| e in
eq_intro (sub pkey 0 nLen) n;
eq_intro (sub pkey nLen nLen) r2;
eq_intro (sub pkey (nLen + nLen) eLen) e;
let m0 = rsapss_check_modulus modBits n in
let m1 = rsapss_check_exponent eBits e in
let m = m0 &. m1 in
logand_lemma m0 m1
val rsapss_load_skey:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8) ->
tuple2 bool (lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)))
let rsapss_load_skey #t modBits eBits dBits nb eb db =
let b, pkey = rsapss_load_pkey modBits eBits nb eb in
let d = bn_from_bytes_be #t (blocks dBits 8) db in
let skey = pkey @| d in
let m0 = rsapss_check_exponent dBits d in
let b1 = b && BB.unsafe_bool_of_limb m0 in
b1, skey
val rsapss_load_skey_lemma:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8) ->
Lemma
(let b, skey = rsapss_load_skey #t modBits eBits dBits nb eb db in
let skey_s = S.rsapss_load_skey modBits eBits dBits nb eb db in
(if b then rsapss_load_skey_post modBits eBits dBits nb eb db skey else None? skey_s))
let rsapss_load_skey_lemma #t modBits eBits dBits nb eb db =
let bits = bits t in
let nbLen = blocks modBits 8 in
let ebLen = blocks eBits 8 in
let dbLen = blocks dBits 8 in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let b, pkey = rsapss_load_pkey #t modBits eBits nb eb in
rsapss_load_pkey_lemma #t modBits eBits nb eb;
let d = bn_from_bytes_be #t (blocks dBits 8) db in
bn_from_bytes_be_lemma #t (blocks dBits 8) db;
let skey = pkey @| d in
eq_intro (sub skey 0 (nLen + nLen + eLen)) pkey;
eq_intro (sub skey (nLen + nLen + eLen) dLen) d
val rsapss_skey_sign:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8)
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> sgnt:lseq uint8 (blocks modBits 8)
-> Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires True)
(ensures fun (b, sgnt) ->
(let sgnt_s = S.rsapss_skey_sign a modBits eBits dBits nb eb db sLen salt msgLen msg in
if b then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)) | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat ->
dBits: Lib.IntTypes.size_nat{Hacl.Spec.RSAPSS.skey_len_pre t modBits eBits dBits} ->
nb: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks modBits 8) ->
eb: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks eBits 8) ->
db: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks dBits 8) ->
sLen: Lib.IntTypes.size_nat ->
salt: Lib.Sequence.lseq Lib.IntTypes.uint8 sLen ->
msgLen: Prims.nat ->
msg: Lib.Sequence.seq Lib.IntTypes.uint8 {Lib.Sequence.length msg == msgLen} ->
sgnt: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks modBits 8)
-> Prims.Pure
(Prims.bool *
Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks modBits 8)) | Prims.Pure | [] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Lib.IntTypes.size_nat",
"Hacl.Spec.RSAPSS.skey_len_pre",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Hacl.Spec.Bignum.Definitions.blocks",
"Prims.nat",
"Lib.Sequence.seq",
"Prims.eq2",
"Lib.Sequence.length",
"Prims.bool",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Lib.IntTypes.bits",
"Hacl.Spec.RSAPSS.rsapss_sign",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.tuple2",
"Prims.unit",
"Hacl.Spec.RSAPSS.rsapss_load_skey_lemma",
"Prims.op_Multiply",
"Hacl.Spec.RSAPSS.rsapss_load_skey"
] | [] | false | false | false | false | false | let rsapss_skey_sign #t a modBits eBits dBits nb eb db sLen salt msgLen msg sgnt =
| let b, skey = rsapss_load_skey #t modBits eBits dBits nb eb db in
rsapss_load_skey_lemma #t modBits eBits dBits nb eb db;
if b then rsapss_sign a modBits eBits dBits skey sLen salt msgLen msg sgnt else false, sgnt | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.imalloc | val imalloc (#a: Type0) (r: HS.rid) (init: a) (len: U32.t)
: HST.ST
(b: libuffer a (U32.v len) (Seq.create (U32.v len) init) {frameOf b == r /\ freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init))) | val imalloc (#a: Type0) (r: HS.rid) (init: a) (len: U32.t)
: HST.ST
(b: libuffer a (U32.v len) (Seq.create (U32.v len) init) {frameOf b == r /\ freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init))) | let imalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 124,
"start_col": 0,
"start_line": 118
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a)
unfold let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
unfold let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a)
inline_for_extraction
type ipointer (a:Type0) = b:ibuffer a{length b == 1}
inline_for_extraction
type ipointer_or_null (a:Type0) = b:ibuffer a{if g_is_null b then True else length b == 1}
inline_for_extraction let isub (#a:Type0) = msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
inline_for_extraction let ioffset (#a:Type0) = moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
(*
* It's a bit sub-optimal that we have both cpred and seq_eq
* Ideally it should only be the erased version seq_eq
*
* However, Lib.Buffer in hacl is already using cpred, so keeping it for now
* But it should be cleaned up when that dependency is gone
*)
let cpred (#a:Type0) (s:Seq.seq a) :spred a = fun s1 -> Seq.equal s s1
let seq_eq (s:Ghost.erased (Seq.seq 'a)) : spred 'a =
fun s' -> s' `Seq.equal` Ghost.reveal s
let value_is #a (b:ibuffer a) (s:Ghost.erased (Seq.seq a)) =
witnessed b (seq_eq s)
let sub_ptr_value_is (#a:_) (b0 b1:ibuffer a) (h:HS.mem) (i len:U32.t) (v:Seq.seq a)
: Lemma
(requires
U32.v i + U32.v len <= length b1 /\
b0 == mgsub (immutable_preorder a) b1 i len /\
value_is b1 v /\
Seq.length v == length b1)
(ensures
value_is b0 (Seq.slice v (U32.v i) (U32.v i + U32.v len)))
= let sub_v = Seq.slice v (U32.v i) (U32.v i + U32.v len) in
witnessed_functorial b1 b0 i len (seq_eq (Ghost.hide v)) (seq_eq (Ghost.hide sub_v))
unfold let libuffer (a:Type0) (len:nat) (s:Seq.seq a) =
b:lmbuffer a (immutable_preorder a) (immutable_preorder a) len{witnessed b (cpred s)}
unfold let libuffer_or_null (a:Type0) (len:nat) (r:HS.rid) (s:Seq.seq a) =
b:lmbuffer_or_null a (immutable_preorder a) (immutable_preorder a) len r{(not (g_is_null b)) ==>
witnessed b (cpred s)}
let igcmalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mgcmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
(*
* Unlike other allocation functions in this module,
* this function (and other flavors of alloc_and_blit) don't provide the witnessed contents
* as the refinement of the return type
* This is because the contents depend on the input memory (== the contents of src)
*)
let igcmalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mgcmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
inline_for_extraction
let igcmalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= igcmalloc r init len | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: FStar.Monotonic.HyperHeap.rid -> init: a -> len: FStar.UInt32.t
-> FStar.HyperStack.ST.ST
(b:
LowStar.ImmutableBuffer.libuffer a
(FStar.UInt32.v len)
(FStar.Seq.Base.create (FStar.UInt32.v len) init)
{LowStar.Monotonic.Buffer.frameOf b == r /\ LowStar.Monotonic.Buffer.freeable b}) | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Monotonic.HyperHeap.rid",
"FStar.UInt32.t",
"LowStar.ImmutableBuffer.libuffer",
"FStar.UInt32.v",
"FStar.Seq.Base.create",
"Prims.l_and",
"Prims.eq2",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.ImmutableBuffer.immutable_preorder",
"LowStar.Monotonic.Buffer.freeable",
"Prims.unit",
"LowStar.Monotonic.Buffer.witness_p",
"LowStar.ImmutableBuffer.cpred",
"LowStar.Monotonic.Buffer.mbuffer",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"LowStar.Monotonic.Buffer.mmalloc",
"LowStar.Monotonic.Buffer.lmbuffer",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.malloc_pre",
"LowStar.Monotonic.Buffer.alloc_post_mem_common"
] | [] | false | true | false | false | false | let imalloc (#a: Type0) (r: HS.rid) (init: a) (len: U32.t)
: HST.ST
(b: libuffer a (U32.v len) (Seq.create (U32.v len) init) {frameOf b == r /\ freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init))) =
| let b = mmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_pkey_verify | val rsapss_pkey_verify:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires True)
(ensures fun r ->
r == S.rsapss_pkey_verify a modBits eBits nb eb sLen k sgnt msgLen msg) | val rsapss_pkey_verify:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires True)
(ensures fun r ->
r == S.rsapss_pkey_verify a modBits eBits nb eb sLen k sgnt msgLen msg) | let rsapss_pkey_verify #t a modBits eBits nb eb sLen k sgnt msgLen msg =
let b, pkey = rsapss_load_pkey #t modBits eBits nb eb in
rsapss_load_pkey_lemma #t modBits eBits nb eb;
if b then
rsapss_verify a modBits eBits pkey sLen k sgnt msgLen msg
else
false | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 9,
"end_line": 1002,
"start_col": 0,
"start_line": 995
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)
val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
let rsapss_verify_pre a sLen msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a
val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post #t a modBits eBits pkey sLen sgnt msgLen msg verify =
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify_ a modBits pkeys sLen sgnt msgLen msg)
val rsapss_verify_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post1 #t a modBits eBits pkey sLen k sgnt msgLen msg verify =
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify a modBits pkeys sLen k sgnt msgLen msg)
val rsapss_sign_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_bn #t modBits eBits dBits skey m =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
let s = map (logand eq_m) s in
BB.unsafe_bool_of_limb eq_m, s
val rsapss_sign_msg_to_bn:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (lbignum t (blocks modBits (bits t)))
(requires rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> bn_v res < pow2 (modBits - 1))
let rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be #t emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
m
val rsapss_sign_compute_sgnt:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_compute_sgnt #t modBits eBits dBits skey m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
let eq_b, s = rsapss_sign_bn #t modBits eBits dBits skey m in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let sgnt = bn_to_bytes_be k s in
eq_b, sgnt
val rsapss_sign_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
rsapss_skey_pre modBits eBits dBits skey /\
rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> True)
let rsapss_sign_ #t a modBits eBits dBits skey sLen salt msgLen msg =
let m = rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg in
rsapss_sign_compute_sgnt #t modBits eBits dBits skey m
val rsapss_sign_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey)
(ensures
(let eq_m, s = rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg in
rsapss_sign_post a modBits eBits dBits skey sLen salt msgLen msg eq_m s))
let rsapss_sign_lemma #t a modBits eBits dBits skey sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
assert (bn_v m < bn_v n);
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
bn_eq_mask_lemma m m';
let s' = map (logand eq_m) s in
bn_mask_lemma s eq_m;
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
Math.Lemmas.pow2_le_compat (8 * k) modBits;
assert (bn_v s' < pow2 (8 * k));
let sgnt = bn_to_bytes_be k s' in
bn_to_bytes_be_lemma k s'
val rsapss_sign:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> sgnt:lseq uint8 (blocks modBits 8)
-> Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires rsapss_skey_pre modBits eBits dBits skey)
(ensures fun (b, sgnt) ->
rsapss_sign_post1 a modBits eBits dBits skey sLen salt msgLen msg b sgnt)
let rsapss_sign #t a modBits eBits dBits skey sLen salt msgLen msg sgnt =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
sLen + hLen + 2 <= blocks (modBits - 1) 8 in
if b then begin
rsapss_sign_lemma a modBits eBits dBits skey sLen salt msgLen msg;
rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg end
else
false, sgnt
val rsapss_verify_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> m_def:lbignum t (blocks modBits (bits t))
-> s:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_bn #t modBits eBits pkey m_def s =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
if bn_lt_pow2 modBits m then (true, m)
else false, m end
else false, m_def
val rsapss_verify_bn_to_msg:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> m:lbignum t (blocks modBits (bits t)) ->
Pure bool
(requires rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_bn_to_msg #t a modBits sLen msgLen msg m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let m1 = sub m 0 (blocks emLen numb) in
let em = bn_to_bytes_be emLen m1 in
S.pss_verify a sLen msgLen msg emBits em
val rsapss_verify_compute_msg:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sgnt:lseq uint8 (blocks modBits 8) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_compute_msg #t modBits eBits pkey sgnt =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
let m_def = create nLen (uint #t 0) in
rsapss_verify_bn #t modBits eBits pkey m_def s
val rsapss_verify_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires
rsapss_pkey_pre modBits eBits pkey /\
rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_ #t a modBits eBits pkey sLen sgnt msgLen msg =
let (b, m) = rsapss_verify_compute_msg #t modBits eBits pkey sgnt in
if b then
rsapss_verify_bn_to_msg a modBits sLen msgLen msg m
else
false
val rsapss_verify_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey)
(ensures
rsapss_verify_post a modBits eBits pkey sLen sgnt msgLen msg
(rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg))
let rsapss_verify_lemma #t a modBits eBits pkey sLen sgnt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
bn_from_bytes_be_lemma #t k sgnt;
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
let res =
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
bn_lt_pow2_lemma modBits m;
assert (bn_lt_pow2 modBits m == (bn_v m < pow2 (emLen * 8)));
let res =
if bn_lt_pow2 modBits m then begin
let m1 = sub m 0 (blocks emLen numb) in
bn_eval_sub modBits m;
assert (bn_v m1 == bn_v m);
let em = bn_to_bytes_be emLen m1 in
bn_to_bytes_be_lemma emLen m1;
S.pss_verify a sLen msgLen msg emBits em end
else false in
() end in
()
val rsapss_verify:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun r -> rsapss_verify_post1 a modBits eBits pkey sLen k sgnt msgLen msg r)
let rsapss_verify #t a modBits eBits pkey sLen k sgnt msgLen msg =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
//assert (max_size_t < Hash.max_input_length a);
assert (hLen + 8 < max_size_t);
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
k = blocks modBits 8 in
if b then begin
rsapss_verify_lemma a modBits eBits pkey sLen sgnt msgLen msg;
rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg end
else
false
val bn_check_num_bits: #t:limb_t -> bs:size_pos -> b:lbignum t (blocks bs (bits t)) ->
res:limb t{v res == (if bn_v b < pow2 bs then v (ones t SEC) else v (zeros t SEC))}
let bn_check_num_bits #t bs b =
let bLen = blocks bs (bits t) in
assert (bs <= bits t * bLen);
let m : limb t = if bs = bits t * bLen then ones t SEC else bn_lt_pow2_mask b bs in
(if bs = bits t * bLen then begin
bn_eval_bound b bLen;
Math.Lemmas.pow2_le_compat (bits t * bLen) bs end
else
bn_lt_pow2_mask_lemma b bs);
assert (v m == (if bn_v b < pow2 bs then v (ones t SEC) else v (zeros t SEC)));
m
val rsapss_check_modulus: #t:limb_t -> modBits:size_pos -> n:lbignum t (blocks modBits (bits t)) ->
res:limb t{v res == (if (bn_v n % 2 = 1 && pow2 (modBits - 1) < bn_v n && bn_v n < pow2 modBits) then v (ones t SEC) else v (zeros t SEC))}
let rsapss_check_modulus #t modBits n =
let bit0 = bn_is_odd n in
bn_is_odd_lemma n;
assert (v bit0 == bn_v n % 2);
let m0 = uint #t 0 -. bit0 in
let m1 = bn_gt_pow2_mask n (modBits - 1) in
bn_gt_pow2_mask_lemma n (modBits - 1);
let m2 = bn_check_num_bits modBits n in
let m = m0 &. (m1 &. m2) in
logand_lemma m0 (m1 &. m2);
logand_lemma m1 m2;
m
val rsapss_check_exponent: #t:limb_t -> eBits:size_pos -> e:lbignum t (blocks eBits (bits t)) ->
res:limb t{v res == (if (0 < bn_v e && bn_v e < pow2 eBits) then v (ones t SEC) else v (zeros t SEC))}
let rsapss_check_exponent #t eBits e =
let m0 = bn_is_zero_mask e in
bn_is_zero_mask_lemma e;
let m1 = bn_check_num_bits eBits e in
let m = (lognot m0) &. m1 in
lognot_lemma m0;
logand_lemma (lognot m0) m1;
m
val rsapss_load_pkey_post:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_load_pkey_post #t modBits eBits nb eb pkey =
let bits = bits t in
let pkey_s = S.rsapss_load_pkey modBits eBits nb eb in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let e = sub pkey (nLen + nLen) eLen in
rsapss_pkey_pre modBits eBits pkey /\
Some? pkey_s /\
bn_v n == S.Mk_rsapss_pkey?.n (Some?.v pkey_s) /\
bn_v e == S.Mk_rsapss_pkey?.e (Some?.v pkey_s)
val rsapss_load_skey_post:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8)
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_load_skey_post #t modBits eBits dBits nb eb db skey =
let bits = bits t in
let skey_s = S.rsapss_load_skey modBits eBits dBits nb eb db in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
rsapss_skey_pre modBits eBits dBits skey /\
Some? skey_s /\ (let pkey_s = S.Mk_rsapss_skey?.pkey (Some?.v skey_s) in
bn_v n == S.Mk_rsapss_pkey?.n pkey_s /\
bn_v e == S.Mk_rsapss_pkey?.e pkey_s /\
bn_v d == S.Mk_rsapss_skey?.d (Some?.v skey_s))
val rsapss_load_pkey:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8) ->
tuple2 bool (lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)))
let rsapss_load_pkey #t modBits eBits nb eb =
let n = bn_from_bytes_be (blocks modBits 8) nb in
let r2 = SM.bn_precomp_r2_mod_n (modBits - 1) n in
let e = bn_from_bytes_be (blocks eBits 8) eb in
let pkey = (n @| r2) @| e in
let m0 = rsapss_check_modulus modBits n in
let m1 = rsapss_check_exponent eBits e in
let m = m0 &. m1 in
BB.unsafe_bool_of_limb m, pkey
val rsapss_load_pkey_lemma:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8) ->
Lemma
(let b, pkey = rsapss_load_pkey #t modBits eBits nb eb in
let pkey_s = S.rsapss_load_pkey modBits eBits nb eb in
(if b then rsapss_load_pkey_post modBits eBits nb eb pkey else None? pkey_s))
let rsapss_load_pkey_lemma #t modBits eBits nb eb =
let bits = bits t in
let nbLen = blocks modBits 8 in
let ebLen = blocks eBits 8 in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_from_bytes_be #t nbLen nb in
bn_from_bytes_be_lemma #t nbLen nb;
let r2 = SM.bn_precomp_r2_mod_n (modBits - 1) n in
let e = bn_from_bytes_be #t ebLen eb in
bn_from_bytes_be_lemma #t ebLen eb;
let pkey = (n @| r2) @| e in
eq_intro (sub pkey 0 nLen) n;
eq_intro (sub pkey nLen nLen) r2;
eq_intro (sub pkey (nLen + nLen) eLen) e;
let m0 = rsapss_check_modulus modBits n in
let m1 = rsapss_check_exponent eBits e in
let m = m0 &. m1 in
logand_lemma m0 m1
val rsapss_load_skey:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8) ->
tuple2 bool (lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)))
let rsapss_load_skey #t modBits eBits dBits nb eb db =
let b, pkey = rsapss_load_pkey modBits eBits nb eb in
let d = bn_from_bytes_be #t (blocks dBits 8) db in
let skey = pkey @| d in
let m0 = rsapss_check_exponent dBits d in
let b1 = b && BB.unsafe_bool_of_limb m0 in
b1, skey
val rsapss_load_skey_lemma:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8) ->
Lemma
(let b, skey = rsapss_load_skey #t modBits eBits dBits nb eb db in
let skey_s = S.rsapss_load_skey modBits eBits dBits nb eb db in
(if b then rsapss_load_skey_post modBits eBits dBits nb eb db skey else None? skey_s))
let rsapss_load_skey_lemma #t modBits eBits dBits nb eb db =
let bits = bits t in
let nbLen = blocks modBits 8 in
let ebLen = blocks eBits 8 in
let dbLen = blocks dBits 8 in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let b, pkey = rsapss_load_pkey #t modBits eBits nb eb in
rsapss_load_pkey_lemma #t modBits eBits nb eb;
let d = bn_from_bytes_be #t (blocks dBits 8) db in
bn_from_bytes_be_lemma #t (blocks dBits 8) db;
let skey = pkey @| d in
eq_intro (sub skey 0 (nLen + nLen + eLen)) pkey;
eq_intro (sub skey (nLen + nLen + eLen) dLen) d
val rsapss_skey_sign:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8)
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> sgnt:lseq uint8 (blocks modBits 8)
-> Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires True)
(ensures fun (b, sgnt) ->
(let sgnt_s = S.rsapss_skey_sign a modBits eBits dBits nb eb db sLen salt msgLen msg in
if b then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s))
let rsapss_skey_sign #t a modBits eBits dBits nb eb db sLen salt msgLen msg sgnt =
let b, skey = rsapss_load_skey #t modBits eBits dBits nb eb db in
rsapss_load_skey_lemma #t modBits eBits dBits nb eb db;
if b then
rsapss_sign a modBits eBits dBits skey sLen salt msgLen msg sgnt
else
false, sgnt
val rsapss_pkey_verify:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires True)
(ensures fun r ->
r == S.rsapss_pkey_verify a modBits eBits nb eb sLen k sgnt msgLen msg) | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat{Hacl.Spec.RSAPSS.pkey_len_pre t modBits eBits} ->
nb: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks modBits 8) ->
eb: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks eBits 8) ->
sLen: Lib.IntTypes.size_nat ->
k: Lib.IntTypes.size_nat ->
sgnt: Lib.Sequence.lseq Lib.IntTypes.uint8 k ->
msgLen: Prims.nat ->
msg: Lib.Sequence.seq Lib.IntTypes.uint8 {Lib.Sequence.length msg == msgLen}
-> Prims.Pure Prims.bool | Prims.Pure | [] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Lib.IntTypes.size_nat",
"Hacl.Spec.RSAPSS.pkey_len_pre",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Hacl.Spec.Bignum.Definitions.blocks",
"Prims.nat",
"Lib.Sequence.seq",
"Prims.eq2",
"Lib.Sequence.length",
"Prims.bool",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Lib.IntTypes.bits",
"Hacl.Spec.RSAPSS.rsapss_verify",
"Prims.unit",
"Hacl.Spec.RSAPSS.rsapss_load_pkey_lemma",
"FStar.Pervasives.Native.tuple2",
"Prims.op_Multiply",
"Hacl.Spec.RSAPSS.rsapss_load_pkey"
] | [] | false | false | false | false | false | let rsapss_pkey_verify #t a modBits eBits nb eb sLen k sgnt msgLen msg =
| let b, pkey = rsapss_load_pkey #t modBits eBits nb eb in
rsapss_load_pkey_lemma #t modBits eBits nb eb;
if b then rsapss_verify a modBits eBits pkey sLen k sgnt msgLen msg else false | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.igcmalloc_and_blit | val igcmalloc_and_blit
(#a: Type0)
(r: HS.rid)
(#rrel1 #rel1: srel a)
(src: mbuffer a rrel1 rel1)
(id_src len: U32.t)
: HST.ST
(b: lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len) {frameOf b == r})
(requires fun h0 -> malloc_pre r len /\ live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures
fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\ b `value_is` (G.hide s)) | val igcmalloc_and_blit
(#a: Type0)
(r: HS.rid)
(#rrel1 #rel1: srel a)
(src: mbuffer a rrel1 rel1)
(id_src len: U32.t)
: HST.ST
(b: lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len) {frameOf b == r})
(requires fun h0 -> malloc_pre r len /\ live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures
fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\ b `value_is` (G.hide s)) | let igcmalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mgcmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 109,
"start_col": 0,
"start_line": 96
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a)
unfold let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
unfold let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a)
inline_for_extraction
type ipointer (a:Type0) = b:ibuffer a{length b == 1}
inline_for_extraction
type ipointer_or_null (a:Type0) = b:ibuffer a{if g_is_null b then True else length b == 1}
inline_for_extraction let isub (#a:Type0) = msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
inline_for_extraction let ioffset (#a:Type0) = moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
(*
* It's a bit sub-optimal that we have both cpred and seq_eq
* Ideally it should only be the erased version seq_eq
*
* However, Lib.Buffer in hacl is already using cpred, so keeping it for now
* But it should be cleaned up when that dependency is gone
*)
let cpred (#a:Type0) (s:Seq.seq a) :spred a = fun s1 -> Seq.equal s s1
let seq_eq (s:Ghost.erased (Seq.seq 'a)) : spred 'a =
fun s' -> s' `Seq.equal` Ghost.reveal s
let value_is #a (b:ibuffer a) (s:Ghost.erased (Seq.seq a)) =
witnessed b (seq_eq s)
let sub_ptr_value_is (#a:_) (b0 b1:ibuffer a) (h:HS.mem) (i len:U32.t) (v:Seq.seq a)
: Lemma
(requires
U32.v i + U32.v len <= length b1 /\
b0 == mgsub (immutable_preorder a) b1 i len /\
value_is b1 v /\
Seq.length v == length b1)
(ensures
value_is b0 (Seq.slice v (U32.v i) (U32.v i + U32.v len)))
= let sub_v = Seq.slice v (U32.v i) (U32.v i + U32.v len) in
witnessed_functorial b1 b0 i len (seq_eq (Ghost.hide v)) (seq_eq (Ghost.hide sub_v))
unfold let libuffer (a:Type0) (len:nat) (s:Seq.seq a) =
b:lmbuffer a (immutable_preorder a) (immutable_preorder a) len{witnessed b (cpred s)}
unfold let libuffer_or_null (a:Type0) (len:nat) (r:HS.rid) (s:Seq.seq a) =
b:lmbuffer_or_null a (immutable_preorder a) (immutable_preorder a) len r{(not (g_is_null b)) ==>
witnessed b (cpred s)}
let igcmalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mgcmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
(*
* Unlike other allocation functions in this module,
* this function (and other flavors of alloc_and_blit) don't provide the witnessed contents
* as the refinement of the return type
* This is because the contents depend on the input memory (== the contents of src) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
r: FStar.Monotonic.HyperHeap.rid ->
src: LowStar.Monotonic.Buffer.mbuffer a rrel1 rel1 ->
id_src: FStar.UInt32.t ->
len: FStar.UInt32.t
-> FStar.HyperStack.ST.ST
(b:
LowStar.Monotonic.Buffer.lmbuffer a
(LowStar.ImmutableBuffer.immutable_preorder a)
(LowStar.ImmutableBuffer.immutable_preorder a)
(FStar.UInt32.v len) {LowStar.Monotonic.Buffer.frameOf b == r}) | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.lmbuffer",
"LowStar.ImmutableBuffer.immutable_preorder",
"FStar.UInt32.v",
"Prims.eq2",
"LowStar.Monotonic.Buffer.frameOf",
"Prims.unit",
"LowStar.Monotonic.Buffer.witness_p",
"LowStar.ImmutableBuffer.seq_eq",
"FStar.Ghost.hide",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.slice",
"LowStar.Monotonic.Buffer.as_seq",
"Prims.op_Addition",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Prims.l_and",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"LowStar.Monotonic.Buffer.recallable",
"LowStar.Monotonic.Buffer.mgcmalloc_and_blit",
"LowStar.Monotonic.Buffer.malloc_pre",
"LowStar.Monotonic.Buffer.live",
"Prims.op_LessThanOrEqual",
"LowStar.Monotonic.Buffer.alloc_post_mem_common",
"LowStar.ImmutableBuffer.value_is"
] | [] | false | true | false | false | false | let igcmalloc_and_blit
(#a: Type0)
(r: HS.rid)
(#rrel1 #rel1: srel a)
(src: mbuffer a rrel1 rel1)
(id_src len: U32.t)
: HST.ST
(b: lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len) {frameOf b == r})
(requires fun h0 -> malloc_pre r len /\ live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures
fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\ b `value_is` (G.hide s)) =
| let b = mgcmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.ialloca_of_list | val ialloca_of_list (#a: Type0) (init: list a)
: HST.StackInline (libuffer a (normalize_term (List.Tot.length init)) (Seq.seq_of_list init))
(requires (fun _ -> alloca_of_list_pre init))
(ensures
(fun h0 b h1 ->
alloc_post_mem_common b h0 h1 (Seq.seq_of_list init) /\ frameOf b == HS.get_tip h0)) | val ialloca_of_list (#a: Type0) (init: list a)
: HST.StackInline (libuffer a (normalize_term (List.Tot.length init)) (Seq.seq_of_list init))
(requires (fun _ -> alloca_of_list_pre init))
(ensures
(fun h0 b h1 ->
alloc_post_mem_common b h0 h1 (Seq.seq_of_list init) /\ frameOf b == HS.get_tip h0)) | let ialloca_of_list (#a:Type0) (init: list a)
:HST.StackInline (libuffer a (normalize_term (List.Tot.length init)) (Seq.seq_of_list init))
(requires (fun _ -> alloca_of_list_pre init))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.seq_of_list init) /\
frameOf b == HS.get_tip h0))
= let b = malloca_of_list init in
witness_p b (cpred (Seq.seq_of_list init));
b | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 180,
"start_col": 0,
"start_line": 173
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a)
unfold let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
unfold let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a)
inline_for_extraction
type ipointer (a:Type0) = b:ibuffer a{length b == 1}
inline_for_extraction
type ipointer_or_null (a:Type0) = b:ibuffer a{if g_is_null b then True else length b == 1}
inline_for_extraction let isub (#a:Type0) = msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
inline_for_extraction let ioffset (#a:Type0) = moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
(*
* It's a bit sub-optimal that we have both cpred and seq_eq
* Ideally it should only be the erased version seq_eq
*
* However, Lib.Buffer in hacl is already using cpred, so keeping it for now
* But it should be cleaned up when that dependency is gone
*)
let cpred (#a:Type0) (s:Seq.seq a) :spred a = fun s1 -> Seq.equal s s1
let seq_eq (s:Ghost.erased (Seq.seq 'a)) : spred 'a =
fun s' -> s' `Seq.equal` Ghost.reveal s
let value_is #a (b:ibuffer a) (s:Ghost.erased (Seq.seq a)) =
witnessed b (seq_eq s)
let sub_ptr_value_is (#a:_) (b0 b1:ibuffer a) (h:HS.mem) (i len:U32.t) (v:Seq.seq a)
: Lemma
(requires
U32.v i + U32.v len <= length b1 /\
b0 == mgsub (immutable_preorder a) b1 i len /\
value_is b1 v /\
Seq.length v == length b1)
(ensures
value_is b0 (Seq.slice v (U32.v i) (U32.v i + U32.v len)))
= let sub_v = Seq.slice v (U32.v i) (U32.v i + U32.v len) in
witnessed_functorial b1 b0 i len (seq_eq (Ghost.hide v)) (seq_eq (Ghost.hide sub_v))
unfold let libuffer (a:Type0) (len:nat) (s:Seq.seq a) =
b:lmbuffer a (immutable_preorder a) (immutable_preorder a) len{witnessed b (cpred s)}
unfold let libuffer_or_null (a:Type0) (len:nat) (r:HS.rid) (s:Seq.seq a) =
b:lmbuffer_or_null a (immutable_preorder a) (immutable_preorder a) len r{(not (g_is_null b)) ==>
witnessed b (cpred s)}
let igcmalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mgcmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
(*
* Unlike other allocation functions in this module,
* this function (and other flavors of alloc_and_blit) don't provide the witnessed contents
* as the refinement of the return type
* This is because the contents depend on the input memory (== the contents of src)
*)
let igcmalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mgcmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
inline_for_extraction
let igcmalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= igcmalloc r init len
let imalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
let imalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r /\ freeable b})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
inline_for_extraction
let imalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){(not (g_is_null b)) ==> freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= imalloc r init len
let ialloca (#a:Type0) (init:a) (len:U32.t)
:HST.StackInline (libuffer a (U32.v len) (Seq.create (U32.v len) init))
(requires (fun _ -> alloca_pre len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init) /\
frameOf b == HS.get_tip h0))
= let b = malloca init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
let ialloca_and_blit (#a:Type0)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.StackInline (lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len))
(requires fun h0 ->
alloca_pre len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
frameOf b == HS.get_tip h0 /\
b `value_is` G.hide s)
= let b = malloca_and_blit src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | init: Prims.list a
-> FStar.HyperStack.ST.StackInline
(LowStar.ImmutableBuffer.libuffer a
(FStar.Pervasives.normalize_term (FStar.List.Tot.Base.length init))
(FStar.Seq.Base.seq_of_list init)) | FStar.HyperStack.ST.StackInline | [] | [] | [
"Prims.list",
"LowStar.ImmutableBuffer.libuffer",
"FStar.Pervasives.normalize_term",
"Prims.nat",
"FStar.List.Tot.Base.length",
"FStar.Seq.Base.seq_of_list",
"Prims.unit",
"LowStar.Monotonic.Buffer.witness_p",
"LowStar.ImmutableBuffer.immutable_preorder",
"LowStar.ImmutableBuffer.cpred",
"LowStar.Monotonic.Buffer.mbuffer",
"Prims.l_and",
"Prims.eq2",
"LowStar.Monotonic.Buffer.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"LowStar.Monotonic.Buffer.malloca_of_list",
"LowStar.Monotonic.Buffer.lmbuffer",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.alloca_of_list_pre",
"LowStar.Monotonic.Buffer.alloc_post_mem_common",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"FStar.Monotonic.HyperStack.get_tip"
] | [] | false | true | false | false | false | let ialloca_of_list (#a: Type0) (init: list a)
: HST.StackInline (libuffer a (normalize_term (List.Tot.length init)) (Seq.seq_of_list init))
(requires (fun _ -> alloca_of_list_pre init))
(ensures
(fun h0 b h1 ->
alloc_post_mem_common b h0 h1 (Seq.seq_of_list init) /\ frameOf b == HS.get_tip h0)) =
| let b = malloca_of_list init in
witness_p b (cpred (Seq.seq_of_list init));
b | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.imalloc_and_blit | val imalloc_and_blit
(#a: Type0)
(r: HS.rid)
(#rrel1 #rel1: srel a)
(src: mbuffer a rrel1 rel1)
(id_src len: U32.t)
: HST.ST
(b:
lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len)
{frameOf b == r /\ freeable b})
(requires fun h0 -> malloc_pre r len /\ live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures
fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\ b `value_is` (G.hide s)) | val imalloc_and_blit
(#a: Type0)
(r: HS.rid)
(#rrel1 #rel1: srel a)
(src: mbuffer a rrel1 rel1)
(id_src len: U32.t)
: HST.ST
(b:
lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len)
{frameOf b == r /\ freeable b})
(requires fun h0 -> malloc_pre r len /\ live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures
fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\ b `value_is` (G.hide s)) | let imalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r /\ freeable b})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 139,
"start_col": 0,
"start_line": 126
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a)
unfold let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
unfold let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a)
inline_for_extraction
type ipointer (a:Type0) = b:ibuffer a{length b == 1}
inline_for_extraction
type ipointer_or_null (a:Type0) = b:ibuffer a{if g_is_null b then True else length b == 1}
inline_for_extraction let isub (#a:Type0) = msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
inline_for_extraction let ioffset (#a:Type0) = moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
(*
* It's a bit sub-optimal that we have both cpred and seq_eq
* Ideally it should only be the erased version seq_eq
*
* However, Lib.Buffer in hacl is already using cpred, so keeping it for now
* But it should be cleaned up when that dependency is gone
*)
let cpred (#a:Type0) (s:Seq.seq a) :spred a = fun s1 -> Seq.equal s s1
let seq_eq (s:Ghost.erased (Seq.seq 'a)) : spred 'a =
fun s' -> s' `Seq.equal` Ghost.reveal s
let value_is #a (b:ibuffer a) (s:Ghost.erased (Seq.seq a)) =
witnessed b (seq_eq s)
let sub_ptr_value_is (#a:_) (b0 b1:ibuffer a) (h:HS.mem) (i len:U32.t) (v:Seq.seq a)
: Lemma
(requires
U32.v i + U32.v len <= length b1 /\
b0 == mgsub (immutable_preorder a) b1 i len /\
value_is b1 v /\
Seq.length v == length b1)
(ensures
value_is b0 (Seq.slice v (U32.v i) (U32.v i + U32.v len)))
= let sub_v = Seq.slice v (U32.v i) (U32.v i + U32.v len) in
witnessed_functorial b1 b0 i len (seq_eq (Ghost.hide v)) (seq_eq (Ghost.hide sub_v))
unfold let libuffer (a:Type0) (len:nat) (s:Seq.seq a) =
b:lmbuffer a (immutable_preorder a) (immutable_preorder a) len{witnessed b (cpred s)}
unfold let libuffer_or_null (a:Type0) (len:nat) (r:HS.rid) (s:Seq.seq a) =
b:lmbuffer_or_null a (immutable_preorder a) (immutable_preorder a) len r{(not (g_is_null b)) ==>
witnessed b (cpred s)}
let igcmalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mgcmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
(*
* Unlike other allocation functions in this module,
* this function (and other flavors of alloc_and_blit) don't provide the witnessed contents
* as the refinement of the return type
* This is because the contents depend on the input memory (== the contents of src)
*)
let igcmalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mgcmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
inline_for_extraction
let igcmalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= igcmalloc r init len
let imalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
r: FStar.Monotonic.HyperHeap.rid ->
src: LowStar.Monotonic.Buffer.mbuffer a rrel1 rel1 ->
id_src: FStar.UInt32.t ->
len: FStar.UInt32.t
-> FStar.HyperStack.ST.ST
(b:
LowStar.Monotonic.Buffer.lmbuffer a
(LowStar.ImmutableBuffer.immutable_preorder a)
(LowStar.ImmutableBuffer.immutable_preorder a)
(FStar.UInt32.v len)
{LowStar.Monotonic.Buffer.frameOf b == r /\ LowStar.Monotonic.Buffer.freeable b}) | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.lmbuffer",
"LowStar.ImmutableBuffer.immutable_preorder",
"FStar.UInt32.v",
"Prims.l_and",
"Prims.eq2",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.freeable",
"Prims.unit",
"LowStar.Monotonic.Buffer.witness_p",
"LowStar.ImmutableBuffer.seq_eq",
"FStar.Ghost.hide",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.slice",
"LowStar.Monotonic.Buffer.as_seq",
"Prims.op_Addition",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"LowStar.Monotonic.Buffer.mmalloc_and_blit",
"LowStar.Monotonic.Buffer.malloc_pre",
"LowStar.Monotonic.Buffer.live",
"Prims.op_LessThanOrEqual",
"LowStar.Monotonic.Buffer.alloc_post_mem_common",
"LowStar.ImmutableBuffer.value_is"
] | [] | false | true | false | false | false | let imalloc_and_blit
(#a: Type0)
(r: HS.rid)
(#rrel1 #rel1: srel a)
(src: mbuffer a rrel1 rel1)
(id_src len: U32.t)
: HST.ST
(b:
lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len)
{frameOf b == r /\ freeable b})
(requires fun h0 -> malloc_pre r len /\ live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures
fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\ b `value_is` (G.hide s)) =
| let b = mmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.inhabited_immutable_buffer_is_distinct_from_buffer | val inhabited_immutable_buffer_is_distinct_from_buffer
(#a: Type0)
(x: a)
(ib: ibuffer a)
(b: LowStar.Buffer.buffer a)
: Lemma (~(ib === b)) | val inhabited_immutable_buffer_is_distinct_from_buffer
(#a: Type0)
(x: a)
(ib: ibuffer a)
(b: LowStar.Buffer.buffer a)
: Lemma (~(ib === b)) | let inhabited_immutable_buffer_is_distinct_from_buffer (#a:Type0) (x:a) (ib:ibuffer a) (b:LowStar.Buffer.buffer a)
: Lemma (~ (ib === b))
= let aux () : Lemma (requires (ib === b)) (ensures False)
= //use injectivity to prove that all sequences of type a are equal
mbuffer_injectivity_in_first_preorder ();
assert (immutable_preorder a == LowStar.Buffer.trivial_preorder a);
assert (forall (s1 s2:Seq.seq a). (immutable_preorder a) s1 s2 == (LowStar.Buffer.trivial_preorder a) s1 s2);
assert (forall (s1 s2:Seq.seq a). (immutable_preorder a) s1 s2 == Seq.equal s1 s2);
assert (forall (s1 s2:Seq.seq a). (LowStar.Buffer.trivial_preorder a) s1 s2 == True);
assert (forall (s1 s2:Seq.seq a). Seq.equal s1 s2);
//now derive the contradiction
let s1 = Seq.create 0 x in
let s2 = Seq.create 1 x in
Seq.lemma_eq_elim s1 s2;
assert (s1 == s2); assert (Seq.length s1 == Seq.length s2)
in
(Classical.move_requires aux) () | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 243,
"start_col": 0,
"start_line": 226
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a)
unfold let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
unfold let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a)
inline_for_extraction
type ipointer (a:Type0) = b:ibuffer a{length b == 1}
inline_for_extraction
type ipointer_or_null (a:Type0) = b:ibuffer a{if g_is_null b then True else length b == 1}
inline_for_extraction let isub (#a:Type0) = msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
inline_for_extraction let ioffset (#a:Type0) = moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
(*
* It's a bit sub-optimal that we have both cpred and seq_eq
* Ideally it should only be the erased version seq_eq
*
* However, Lib.Buffer in hacl is already using cpred, so keeping it for now
* But it should be cleaned up when that dependency is gone
*)
let cpred (#a:Type0) (s:Seq.seq a) :spred a = fun s1 -> Seq.equal s s1
let seq_eq (s:Ghost.erased (Seq.seq 'a)) : spred 'a =
fun s' -> s' `Seq.equal` Ghost.reveal s
let value_is #a (b:ibuffer a) (s:Ghost.erased (Seq.seq a)) =
witnessed b (seq_eq s)
let sub_ptr_value_is (#a:_) (b0 b1:ibuffer a) (h:HS.mem) (i len:U32.t) (v:Seq.seq a)
: Lemma
(requires
U32.v i + U32.v len <= length b1 /\
b0 == mgsub (immutable_preorder a) b1 i len /\
value_is b1 v /\
Seq.length v == length b1)
(ensures
value_is b0 (Seq.slice v (U32.v i) (U32.v i + U32.v len)))
= let sub_v = Seq.slice v (U32.v i) (U32.v i + U32.v len) in
witnessed_functorial b1 b0 i len (seq_eq (Ghost.hide v)) (seq_eq (Ghost.hide sub_v))
unfold let libuffer (a:Type0) (len:nat) (s:Seq.seq a) =
b:lmbuffer a (immutable_preorder a) (immutable_preorder a) len{witnessed b (cpred s)}
unfold let libuffer_or_null (a:Type0) (len:nat) (r:HS.rid) (s:Seq.seq a) =
b:lmbuffer_or_null a (immutable_preorder a) (immutable_preorder a) len r{(not (g_is_null b)) ==>
witnessed b (cpred s)}
let igcmalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mgcmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
(*
* Unlike other allocation functions in this module,
* this function (and other flavors of alloc_and_blit) don't provide the witnessed contents
* as the refinement of the return type
* This is because the contents depend on the input memory (== the contents of src)
*)
let igcmalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mgcmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
inline_for_extraction
let igcmalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= igcmalloc r init len
let imalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
let imalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r /\ freeable b})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
inline_for_extraction
let imalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){(not (g_is_null b)) ==> freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= imalloc r init len
let ialloca (#a:Type0) (init:a) (len:U32.t)
:HST.StackInline (libuffer a (U32.v len) (Seq.create (U32.v len) init))
(requires (fun _ -> alloca_pre len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init) /\
frameOf b == HS.get_tip h0))
= let b = malloca init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
let ialloca_and_blit (#a:Type0)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.StackInline (lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len))
(requires fun h0 ->
alloca_pre len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
frameOf b == HS.get_tip h0 /\
b `value_is` G.hide s)
= let b = malloca_and_blit src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
let ialloca_of_list (#a:Type0) (init: list a)
:HST.StackInline (libuffer a (normalize_term (List.Tot.length init)) (Seq.seq_of_list init))
(requires (fun _ -> alloca_of_list_pre init))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.seq_of_list init) /\
frameOf b == HS.get_tip h0))
= let b = malloca_of_list init in
witness_p b (cpred (Seq.seq_of_list init));
b
let igcmalloc_of_list (#a:Type0) (r:HS.rid) (init:list a)
:HST.ST (b:libuffer a (normalize_term (List.Tot.length init)) (Seq.seq_of_list init){frameOf b == r /\ recallable b})
(requires (fun _ -> gcmalloc_of_list_pre r init))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.seq_of_list init)))
= let b = mgcmalloc_of_list r init in
witness_p b (cpred (Seq.seq_of_list init));
b
inline_for_extraction
let igcmalloc_of_list_partial (#a:Type0) (r:HS.rid) (init:list a)
:HST.ST (b:libuffer_or_null a (normalize_term (List.Tot.length init)) r (Seq.seq_of_list init){recallable b})
(requires (fun _ -> gcmalloc_of_list_pre r init))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.seq_of_list init)))
= igcmalloc_of_list r init
let witness_contents (#a:Type0) (b:ibuffer a) (s:Seq.seq a)
:HST.ST unit (requires (fun h0 -> Seq.equal (as_seq h0 b) s))
(ensures (fun h0 _ h1 -> h0 == h1 /\ witnessed b (cpred s)))
= witness_p b (cpred s)
let recall_contents (#a:Type0) (b:ibuffer a) (s:Seq.seq a)
:HST.ST unit (requires (fun h0 -> (recallable b \/ live h0 b) /\ witnessed b (cpred s)))
(ensures (fun h0 _ h1 -> h0 == h1 /\ live h0 b /\ as_seq h0 b == s))
= recall_p b (cpred s)
let witness_value (#a:Type0) (b:ibuffer a)
:HST.ST unit (requires (fun h0 -> True))
(ensures (fun h0 _ h1 -> h0 == h1 /\ b `value_is` (Ghost.hide (as_seq h1 b))))
= let h = HST.get () in
let s = Ghost.hide (as_seq h b) in
witness_p b (seq_eq s)
let recall_value (#a:Type0) (b:ibuffer a) (s:Ghost.erased (Seq.seq a))
:HST.ST unit (requires (fun h0 -> (recallable b \/ live h0 b) /\ b `value_is` s))
(ensures (fun h0 _ h1 -> h0 == h1 /\ live h1 b /\ as_seq h1 b == Ghost.reveal s))
= recall_p b (seq_eq s)
(*
* Immutable buffers are distinct from (trivial) buffers
*
* The proof basically proves a contradiction assuming that the buffers are not distinct
* Using injectivity of the base preorders, we get that trivial preorder is same as immutable preorder
* After which it is easy to derive the contradiction, provided client has provided a witness for inhabitance | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x: a -> ib: LowStar.ImmutableBuffer.ibuffer a -> b: LowStar.Buffer.buffer a
-> FStar.Pervasives.Lemma (ensures ~(ib === b)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.ImmutableBuffer.ibuffer",
"LowStar.Buffer.buffer",
"FStar.Classical.move_requires",
"Prims.unit",
"Prims.op_Equals_Equals_Equals",
"Prims.l_False",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Prims._assert",
"Prims.eq2",
"Prims.nat",
"FStar.Seq.Base.length",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Seq.Base.create",
"Prims.l_Forall",
"FStar.Seq.Base.equal",
"LowStar.Buffer.trivial_preorder",
"Prims.l_True",
"LowStar.ImmutableBuffer.immutable_preorder",
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer_injectivity_in_first_preorder",
"Prims.l_not"
] | [] | false | false | true | false | false | let inhabited_immutable_buffer_is_distinct_from_buffer
(#a: Type0)
(x: a)
(ib: ibuffer a)
(b: LowStar.Buffer.buffer a)
: Lemma (~(ib === b)) =
| let aux () : Lemma (requires (ib === b)) (ensures False) =
mbuffer_injectivity_in_first_preorder ();
assert (immutable_preorder a == LowStar.Buffer.trivial_preorder a);
assert (forall (s1: Seq.seq a) (s2: Seq.seq a).
(immutable_preorder a) s1 s2 == (LowStar.Buffer.trivial_preorder a) s1 s2);
assert (forall (s1: Seq.seq a) (s2: Seq.seq a). (immutable_preorder a) s1 s2 == Seq.equal s1 s2);
assert (forall (s1: Seq.seq a) (s2: Seq.seq a). (LowStar.Buffer.trivial_preorder a) s1 s2 == True);
assert (forall (s1: Seq.seq a) (s2: Seq.seq a). Seq.equal s1 s2);
let s1 = Seq.create 0 x in
let s2 = Seq.create 1 x in
Seq.lemma_eq_elim s1 s2;
assert (s1 == s2);
assert (Seq.length s1 == Seq.length s2)
in
(Classical.move_requires aux) () | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.witness_contents | val witness_contents (#a: Type0) (b: ibuffer a) (s: Seq.seq a)
: HST.ST unit
(requires (fun h0 -> Seq.equal (as_seq h0 b) s))
(ensures (fun h0 _ h1 -> h0 == h1 /\ witnessed b (cpred s))) | val witness_contents (#a: Type0) (b: ibuffer a) (s: Seq.seq a)
: HST.ST unit
(requires (fun h0 -> Seq.equal (as_seq h0 b) s))
(ensures (fun h0 _ h1 -> h0 == h1 /\ witnessed b (cpred s))) | let witness_contents (#a:Type0) (b:ibuffer a) (s:Seq.seq a)
:HST.ST unit (requires (fun h0 -> Seq.equal (as_seq h0 b) s))
(ensures (fun h0 _ h1 -> h0 == h1 /\ witnessed b (cpred s)))
= witness_p b (cpred s) | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 25,
"end_line": 200,
"start_col": 0,
"start_line": 197
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a)
unfold let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
unfold let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a)
inline_for_extraction
type ipointer (a:Type0) = b:ibuffer a{length b == 1}
inline_for_extraction
type ipointer_or_null (a:Type0) = b:ibuffer a{if g_is_null b then True else length b == 1}
inline_for_extraction let isub (#a:Type0) = msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
inline_for_extraction let ioffset (#a:Type0) = moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
(*
* It's a bit sub-optimal that we have both cpred and seq_eq
* Ideally it should only be the erased version seq_eq
*
* However, Lib.Buffer in hacl is already using cpred, so keeping it for now
* But it should be cleaned up when that dependency is gone
*)
let cpred (#a:Type0) (s:Seq.seq a) :spred a = fun s1 -> Seq.equal s s1
let seq_eq (s:Ghost.erased (Seq.seq 'a)) : spred 'a =
fun s' -> s' `Seq.equal` Ghost.reveal s
let value_is #a (b:ibuffer a) (s:Ghost.erased (Seq.seq a)) =
witnessed b (seq_eq s)
let sub_ptr_value_is (#a:_) (b0 b1:ibuffer a) (h:HS.mem) (i len:U32.t) (v:Seq.seq a)
: Lemma
(requires
U32.v i + U32.v len <= length b1 /\
b0 == mgsub (immutable_preorder a) b1 i len /\
value_is b1 v /\
Seq.length v == length b1)
(ensures
value_is b0 (Seq.slice v (U32.v i) (U32.v i + U32.v len)))
= let sub_v = Seq.slice v (U32.v i) (U32.v i + U32.v len) in
witnessed_functorial b1 b0 i len (seq_eq (Ghost.hide v)) (seq_eq (Ghost.hide sub_v))
unfold let libuffer (a:Type0) (len:nat) (s:Seq.seq a) =
b:lmbuffer a (immutable_preorder a) (immutable_preorder a) len{witnessed b (cpred s)}
unfold let libuffer_or_null (a:Type0) (len:nat) (r:HS.rid) (s:Seq.seq a) =
b:lmbuffer_or_null a (immutable_preorder a) (immutable_preorder a) len r{(not (g_is_null b)) ==>
witnessed b (cpred s)}
let igcmalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mgcmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
(*
* Unlike other allocation functions in this module,
* this function (and other flavors of alloc_and_blit) don't provide the witnessed contents
* as the refinement of the return type
* This is because the contents depend on the input memory (== the contents of src)
*)
let igcmalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mgcmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
inline_for_extraction
let igcmalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= igcmalloc r init len
let imalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
let imalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r /\ freeable b})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
inline_for_extraction
let imalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){(not (g_is_null b)) ==> freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= imalloc r init len
let ialloca (#a:Type0) (init:a) (len:U32.t)
:HST.StackInline (libuffer a (U32.v len) (Seq.create (U32.v len) init))
(requires (fun _ -> alloca_pre len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init) /\
frameOf b == HS.get_tip h0))
= let b = malloca init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
let ialloca_and_blit (#a:Type0)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.StackInline (lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len))
(requires fun h0 ->
alloca_pre len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
frameOf b == HS.get_tip h0 /\
b `value_is` G.hide s)
= let b = malloca_and_blit src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
let ialloca_of_list (#a:Type0) (init: list a)
:HST.StackInline (libuffer a (normalize_term (List.Tot.length init)) (Seq.seq_of_list init))
(requires (fun _ -> alloca_of_list_pre init))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.seq_of_list init) /\
frameOf b == HS.get_tip h0))
= let b = malloca_of_list init in
witness_p b (cpred (Seq.seq_of_list init));
b
let igcmalloc_of_list (#a:Type0) (r:HS.rid) (init:list a)
:HST.ST (b:libuffer a (normalize_term (List.Tot.length init)) (Seq.seq_of_list init){frameOf b == r /\ recallable b})
(requires (fun _ -> gcmalloc_of_list_pre r init))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.seq_of_list init)))
= let b = mgcmalloc_of_list r init in
witness_p b (cpred (Seq.seq_of_list init));
b
inline_for_extraction
let igcmalloc_of_list_partial (#a:Type0) (r:HS.rid) (init:list a)
:HST.ST (b:libuffer_or_null a (normalize_term (List.Tot.length init)) r (Seq.seq_of_list init){recallable b})
(requires (fun _ -> gcmalloc_of_list_pre r init))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.seq_of_list init)))
= igcmalloc_of_list r init | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b: LowStar.ImmutableBuffer.ibuffer a -> s: FStar.Seq.Base.seq a -> FStar.HyperStack.ST.ST Prims.unit | FStar.HyperStack.ST.ST | [] | [] | [
"LowStar.ImmutableBuffer.ibuffer",
"FStar.Seq.Base.seq",
"LowStar.Monotonic.Buffer.witness_p",
"LowStar.ImmutableBuffer.immutable_preorder",
"LowStar.ImmutableBuffer.cpred",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"FStar.Seq.Base.equal",
"LowStar.Monotonic.Buffer.as_seq",
"Prims.l_and",
"Prims.eq2",
"LowStar.Monotonic.Buffer.witnessed"
] | [] | false | true | false | false | false | let witness_contents (#a: Type0) (b: ibuffer a) (s: Seq.seq a)
: HST.ST unit
(requires (fun h0 -> Seq.equal (as_seq h0 b) s))
(ensures (fun h0 _ h1 -> h0 == h1 /\ witnessed b (cpred s))) =
| witness_p b (cpred s) | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.recall_contents | val recall_contents (#a: Type0) (b: ibuffer a) (s: Seq.seq a)
: HST.ST unit
(requires (fun h0 -> (recallable b \/ live h0 b) /\ witnessed b (cpred s)))
(ensures (fun h0 _ h1 -> h0 == h1 /\ live h0 b /\ as_seq h0 b == s)) | val recall_contents (#a: Type0) (b: ibuffer a) (s: Seq.seq a)
: HST.ST unit
(requires (fun h0 -> (recallable b \/ live h0 b) /\ witnessed b (cpred s)))
(ensures (fun h0 _ h1 -> h0 == h1 /\ live h0 b /\ as_seq h0 b == s)) | let recall_contents (#a:Type0) (b:ibuffer a) (s:Seq.seq a)
:HST.ST unit (requires (fun h0 -> (recallable b \/ live h0 b) /\ witnessed b (cpred s)))
(ensures (fun h0 _ h1 -> h0 == h1 /\ live h0 b /\ as_seq h0 b == s))
= recall_p b (cpred s) | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 24,
"end_line": 205,
"start_col": 0,
"start_line": 202
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a)
unfold let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
unfold let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a)
inline_for_extraction
type ipointer (a:Type0) = b:ibuffer a{length b == 1}
inline_for_extraction
type ipointer_or_null (a:Type0) = b:ibuffer a{if g_is_null b then True else length b == 1}
inline_for_extraction let isub (#a:Type0) = msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
inline_for_extraction let ioffset (#a:Type0) = moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
(*
* It's a bit sub-optimal that we have both cpred and seq_eq
* Ideally it should only be the erased version seq_eq
*
* However, Lib.Buffer in hacl is already using cpred, so keeping it for now
* But it should be cleaned up when that dependency is gone
*)
let cpred (#a:Type0) (s:Seq.seq a) :spred a = fun s1 -> Seq.equal s s1
let seq_eq (s:Ghost.erased (Seq.seq 'a)) : spred 'a =
fun s' -> s' `Seq.equal` Ghost.reveal s
let value_is #a (b:ibuffer a) (s:Ghost.erased (Seq.seq a)) =
witnessed b (seq_eq s)
let sub_ptr_value_is (#a:_) (b0 b1:ibuffer a) (h:HS.mem) (i len:U32.t) (v:Seq.seq a)
: Lemma
(requires
U32.v i + U32.v len <= length b1 /\
b0 == mgsub (immutable_preorder a) b1 i len /\
value_is b1 v /\
Seq.length v == length b1)
(ensures
value_is b0 (Seq.slice v (U32.v i) (U32.v i + U32.v len)))
= let sub_v = Seq.slice v (U32.v i) (U32.v i + U32.v len) in
witnessed_functorial b1 b0 i len (seq_eq (Ghost.hide v)) (seq_eq (Ghost.hide sub_v))
unfold let libuffer (a:Type0) (len:nat) (s:Seq.seq a) =
b:lmbuffer a (immutable_preorder a) (immutable_preorder a) len{witnessed b (cpred s)}
unfold let libuffer_or_null (a:Type0) (len:nat) (r:HS.rid) (s:Seq.seq a) =
b:lmbuffer_or_null a (immutable_preorder a) (immutable_preorder a) len r{(not (g_is_null b)) ==>
witnessed b (cpred s)}
let igcmalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mgcmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
(*
* Unlike other allocation functions in this module,
* this function (and other flavors of alloc_and_blit) don't provide the witnessed contents
* as the refinement of the return type
* This is because the contents depend on the input memory (== the contents of src)
*)
let igcmalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mgcmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
inline_for_extraction
let igcmalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= igcmalloc r init len
let imalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
let imalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r /\ freeable b})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
inline_for_extraction
let imalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){(not (g_is_null b)) ==> freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= imalloc r init len
let ialloca (#a:Type0) (init:a) (len:U32.t)
:HST.StackInline (libuffer a (U32.v len) (Seq.create (U32.v len) init))
(requires (fun _ -> alloca_pre len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init) /\
frameOf b == HS.get_tip h0))
= let b = malloca init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
let ialloca_and_blit (#a:Type0)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.StackInline (lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len))
(requires fun h0 ->
alloca_pre len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
frameOf b == HS.get_tip h0 /\
b `value_is` G.hide s)
= let b = malloca_and_blit src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
let ialloca_of_list (#a:Type0) (init: list a)
:HST.StackInline (libuffer a (normalize_term (List.Tot.length init)) (Seq.seq_of_list init))
(requires (fun _ -> alloca_of_list_pre init))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.seq_of_list init) /\
frameOf b == HS.get_tip h0))
= let b = malloca_of_list init in
witness_p b (cpred (Seq.seq_of_list init));
b
let igcmalloc_of_list (#a:Type0) (r:HS.rid) (init:list a)
:HST.ST (b:libuffer a (normalize_term (List.Tot.length init)) (Seq.seq_of_list init){frameOf b == r /\ recallable b})
(requires (fun _ -> gcmalloc_of_list_pre r init))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.seq_of_list init)))
= let b = mgcmalloc_of_list r init in
witness_p b (cpred (Seq.seq_of_list init));
b
inline_for_extraction
let igcmalloc_of_list_partial (#a:Type0) (r:HS.rid) (init:list a)
:HST.ST (b:libuffer_or_null a (normalize_term (List.Tot.length init)) r (Seq.seq_of_list init){recallable b})
(requires (fun _ -> gcmalloc_of_list_pre r init))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.seq_of_list init)))
= igcmalloc_of_list r init
let witness_contents (#a:Type0) (b:ibuffer a) (s:Seq.seq a)
:HST.ST unit (requires (fun h0 -> Seq.equal (as_seq h0 b) s))
(ensures (fun h0 _ h1 -> h0 == h1 /\ witnessed b (cpred s)))
= witness_p b (cpred s) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b: LowStar.ImmutableBuffer.ibuffer a -> s: FStar.Seq.Base.seq a -> FStar.HyperStack.ST.ST Prims.unit | FStar.HyperStack.ST.ST | [] | [] | [
"LowStar.ImmutableBuffer.ibuffer",
"FStar.Seq.Base.seq",
"LowStar.Monotonic.Buffer.recall_p",
"LowStar.ImmutableBuffer.immutable_preorder",
"LowStar.ImmutableBuffer.cpred",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Prims.l_or",
"LowStar.Monotonic.Buffer.recallable",
"LowStar.Monotonic.Buffer.live",
"LowStar.Monotonic.Buffer.witnessed",
"Prims.eq2",
"LowStar.Monotonic.Buffer.as_seq"
] | [] | false | true | false | false | false | let recall_contents (#a: Type0) (b: ibuffer a) (s: Seq.seq a)
: HST.ST unit
(requires (fun h0 -> (recallable b \/ live h0 b) /\ witnessed b (cpred s)))
(ensures (fun h0 _ h1 -> h0 == h1 /\ live h0 b /\ as_seq h0 b == s)) =
| recall_p b (cpred s) | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.igcmalloc_of_list | val igcmalloc_of_list (#a: Type0) (r: HS.rid) (init: list a)
: HST.ST
(b:
libuffer a (normalize_term (List.Tot.length init)) (Seq.seq_of_list init)
{frameOf b == r /\ recallable b})
(requires (fun _ -> gcmalloc_of_list_pre r init))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.seq_of_list init))) | val igcmalloc_of_list (#a: Type0) (r: HS.rid) (init: list a)
: HST.ST
(b:
libuffer a (normalize_term (List.Tot.length init)) (Seq.seq_of_list init)
{frameOf b == r /\ recallable b})
(requires (fun _ -> gcmalloc_of_list_pre r init))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.seq_of_list init))) | let igcmalloc_of_list (#a:Type0) (r:HS.rid) (init:list a)
:HST.ST (b:libuffer a (normalize_term (List.Tot.length init)) (Seq.seq_of_list init){frameOf b == r /\ recallable b})
(requires (fun _ -> gcmalloc_of_list_pre r init))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.seq_of_list init)))
= let b = mgcmalloc_of_list r init in
witness_p b (cpred (Seq.seq_of_list init));
b | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 188,
"start_col": 0,
"start_line": 182
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a)
unfold let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
unfold let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a)
inline_for_extraction
type ipointer (a:Type0) = b:ibuffer a{length b == 1}
inline_for_extraction
type ipointer_or_null (a:Type0) = b:ibuffer a{if g_is_null b then True else length b == 1}
inline_for_extraction let isub (#a:Type0) = msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
inline_for_extraction let ioffset (#a:Type0) = moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
(*
* It's a bit sub-optimal that we have both cpred and seq_eq
* Ideally it should only be the erased version seq_eq
*
* However, Lib.Buffer in hacl is already using cpred, so keeping it for now
* But it should be cleaned up when that dependency is gone
*)
let cpred (#a:Type0) (s:Seq.seq a) :spred a = fun s1 -> Seq.equal s s1
let seq_eq (s:Ghost.erased (Seq.seq 'a)) : spred 'a =
fun s' -> s' `Seq.equal` Ghost.reveal s
let value_is #a (b:ibuffer a) (s:Ghost.erased (Seq.seq a)) =
witnessed b (seq_eq s)
let sub_ptr_value_is (#a:_) (b0 b1:ibuffer a) (h:HS.mem) (i len:U32.t) (v:Seq.seq a)
: Lemma
(requires
U32.v i + U32.v len <= length b1 /\
b0 == mgsub (immutable_preorder a) b1 i len /\
value_is b1 v /\
Seq.length v == length b1)
(ensures
value_is b0 (Seq.slice v (U32.v i) (U32.v i + U32.v len)))
= let sub_v = Seq.slice v (U32.v i) (U32.v i + U32.v len) in
witnessed_functorial b1 b0 i len (seq_eq (Ghost.hide v)) (seq_eq (Ghost.hide sub_v))
unfold let libuffer (a:Type0) (len:nat) (s:Seq.seq a) =
b:lmbuffer a (immutable_preorder a) (immutable_preorder a) len{witnessed b (cpred s)}
unfold let libuffer_or_null (a:Type0) (len:nat) (r:HS.rid) (s:Seq.seq a) =
b:lmbuffer_or_null a (immutable_preorder a) (immutable_preorder a) len r{(not (g_is_null b)) ==>
witnessed b (cpred s)}
let igcmalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mgcmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
(*
* Unlike other allocation functions in this module,
* this function (and other flavors of alloc_and_blit) don't provide the witnessed contents
* as the refinement of the return type
* This is because the contents depend on the input memory (== the contents of src)
*)
let igcmalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mgcmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
inline_for_extraction
let igcmalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= igcmalloc r init len
let imalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
let imalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r /\ freeable b})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
inline_for_extraction
let imalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){(not (g_is_null b)) ==> freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= imalloc r init len
let ialloca (#a:Type0) (init:a) (len:U32.t)
:HST.StackInline (libuffer a (U32.v len) (Seq.create (U32.v len) init))
(requires (fun _ -> alloca_pre len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init) /\
frameOf b == HS.get_tip h0))
= let b = malloca init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
let ialloca_and_blit (#a:Type0)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.StackInline (lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len))
(requires fun h0 ->
alloca_pre len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
frameOf b == HS.get_tip h0 /\
b `value_is` G.hide s)
= let b = malloca_and_blit src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
let ialloca_of_list (#a:Type0) (init: list a)
:HST.StackInline (libuffer a (normalize_term (List.Tot.length init)) (Seq.seq_of_list init))
(requires (fun _ -> alloca_of_list_pre init))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.seq_of_list init) /\
frameOf b == HS.get_tip h0))
= let b = malloca_of_list init in
witness_p b (cpred (Seq.seq_of_list init));
b | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: FStar.Monotonic.HyperHeap.rid -> init: Prims.list a
-> FStar.HyperStack.ST.ST
(b:
LowStar.ImmutableBuffer.libuffer a
(FStar.Pervasives.normalize_term (FStar.List.Tot.Base.length init))
(FStar.Seq.Base.seq_of_list init)
{LowStar.Monotonic.Buffer.frameOf b == r /\ LowStar.Monotonic.Buffer.recallable b}) | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Monotonic.HyperHeap.rid",
"Prims.list",
"LowStar.ImmutableBuffer.libuffer",
"FStar.Pervasives.normalize_term",
"Prims.nat",
"FStar.List.Tot.Base.length",
"FStar.Seq.Base.seq_of_list",
"Prims.l_and",
"Prims.eq2",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.ImmutableBuffer.immutable_preorder",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"LowStar.Monotonic.Buffer.witness_p",
"LowStar.ImmutableBuffer.cpred",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Monotonic.Buffer.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"LowStar.Monotonic.Buffer.mgcmalloc_of_list",
"LowStar.Monotonic.Buffer.lmbuffer",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.gcmalloc_of_list_pre",
"LowStar.Monotonic.Buffer.alloc_post_mem_common"
] | [] | false | true | false | false | false | let igcmalloc_of_list (#a: Type0) (r: HS.rid) (init: list a)
: HST.ST
(b:
libuffer a (normalize_term (List.Tot.length init)) (Seq.seq_of_list init)
{frameOf b == r /\ recallable b})
(requires (fun _ -> gcmalloc_of_list_pre r init))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.seq_of_list init))) =
| let b = mgcmalloc_of_list r init in
witness_p b (cpred (Seq.seq_of_list init));
b | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.imalloc_partial | val imalloc_partial (#a: Type0) (r: HS.rid) (init: a) (len: U32.t)
: HST.ST
(b:
libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init)
{(not (g_is_null b)) ==> freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init))) | val imalloc_partial (#a: Type0) (r: HS.rid) (init: a) (len: U32.t)
: HST.ST
(b:
libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init)
{(not (g_is_null b)) ==> freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init))) | let imalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){(not (g_is_null b)) ==> freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= imalloc r init len | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 22,
"end_line": 146,
"start_col": 0,
"start_line": 142
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a)
unfold let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
unfold let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a)
inline_for_extraction
type ipointer (a:Type0) = b:ibuffer a{length b == 1}
inline_for_extraction
type ipointer_or_null (a:Type0) = b:ibuffer a{if g_is_null b then True else length b == 1}
inline_for_extraction let isub (#a:Type0) = msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
inline_for_extraction let ioffset (#a:Type0) = moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
(*
* It's a bit sub-optimal that we have both cpred and seq_eq
* Ideally it should only be the erased version seq_eq
*
* However, Lib.Buffer in hacl is already using cpred, so keeping it for now
* But it should be cleaned up when that dependency is gone
*)
let cpred (#a:Type0) (s:Seq.seq a) :spred a = fun s1 -> Seq.equal s s1
let seq_eq (s:Ghost.erased (Seq.seq 'a)) : spred 'a =
fun s' -> s' `Seq.equal` Ghost.reveal s
let value_is #a (b:ibuffer a) (s:Ghost.erased (Seq.seq a)) =
witnessed b (seq_eq s)
let sub_ptr_value_is (#a:_) (b0 b1:ibuffer a) (h:HS.mem) (i len:U32.t) (v:Seq.seq a)
: Lemma
(requires
U32.v i + U32.v len <= length b1 /\
b0 == mgsub (immutable_preorder a) b1 i len /\
value_is b1 v /\
Seq.length v == length b1)
(ensures
value_is b0 (Seq.slice v (U32.v i) (U32.v i + U32.v len)))
= let sub_v = Seq.slice v (U32.v i) (U32.v i + U32.v len) in
witnessed_functorial b1 b0 i len (seq_eq (Ghost.hide v)) (seq_eq (Ghost.hide sub_v))
unfold let libuffer (a:Type0) (len:nat) (s:Seq.seq a) =
b:lmbuffer a (immutable_preorder a) (immutable_preorder a) len{witnessed b (cpred s)}
unfold let libuffer_or_null (a:Type0) (len:nat) (r:HS.rid) (s:Seq.seq a) =
b:lmbuffer_or_null a (immutable_preorder a) (immutable_preorder a) len r{(not (g_is_null b)) ==>
witnessed b (cpred s)}
let igcmalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mgcmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
(*
* Unlike other allocation functions in this module,
* this function (and other flavors of alloc_and_blit) don't provide the witnessed contents
* as the refinement of the return type
* This is because the contents depend on the input memory (== the contents of src)
*)
let igcmalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mgcmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
inline_for_extraction
let igcmalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= igcmalloc r init len
let imalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
let imalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r /\ freeable b})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: FStar.Monotonic.HyperHeap.rid -> init: a -> len: FStar.UInt32.t
-> FStar.HyperStack.ST.ST
(b:
LowStar.ImmutableBuffer.libuffer_or_null a
(FStar.UInt32.v len)
r
(FStar.Seq.Base.create (FStar.UInt32.v len) init)
{ Prims.op_Negation (LowStar.Monotonic.Buffer.g_is_null b) ==>
LowStar.Monotonic.Buffer.freeable b }) | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Monotonic.HyperHeap.rid",
"FStar.UInt32.t",
"LowStar.ImmutableBuffer.imalloc",
"LowStar.ImmutableBuffer.libuffer",
"FStar.UInt32.v",
"FStar.Seq.Base.create",
"Prims.l_and",
"Prims.eq2",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.ImmutableBuffer.immutable_preorder",
"LowStar.Monotonic.Buffer.freeable",
"LowStar.ImmutableBuffer.libuffer_or_null",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.malloc_pre",
"LowStar.Monotonic.Buffer.alloc_partial_post_mem_common"
] | [] | false | true | false | false | false | let imalloc_partial (#a: Type0) (r: HS.rid) (init: a) (len: U32.t)
: HST.ST
(b:
libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init)
{(not (g_is_null b)) ==> freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init))) =
| imalloc r init len | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.witness_value | val witness_value (#a: Type0) (b: ibuffer a)
: HST.ST unit
(requires (fun h0 -> True))
(ensures (fun h0 _ h1 -> h0 == h1 /\ b `value_is` (Ghost.hide (as_seq h1 b)))) | val witness_value (#a: Type0) (b: ibuffer a)
: HST.ST unit
(requires (fun h0 -> True))
(ensures (fun h0 _ h1 -> h0 == h1 /\ b `value_is` (Ghost.hide (as_seq h1 b)))) | let witness_value (#a:Type0) (b:ibuffer a)
:HST.ST unit (requires (fun h0 -> True))
(ensures (fun h0 _ h1 -> h0 == h1 /\ b `value_is` (Ghost.hide (as_seq h1 b))))
= let h = HST.get () in
let s = Ghost.hide (as_seq h b) in
witness_p b (seq_eq s) | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 26,
"end_line": 212,
"start_col": 0,
"start_line": 207
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a)
unfold let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
unfold let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a)
inline_for_extraction
type ipointer (a:Type0) = b:ibuffer a{length b == 1}
inline_for_extraction
type ipointer_or_null (a:Type0) = b:ibuffer a{if g_is_null b then True else length b == 1}
inline_for_extraction let isub (#a:Type0) = msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
inline_for_extraction let ioffset (#a:Type0) = moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
(*
* It's a bit sub-optimal that we have both cpred and seq_eq
* Ideally it should only be the erased version seq_eq
*
* However, Lib.Buffer in hacl is already using cpred, so keeping it for now
* But it should be cleaned up when that dependency is gone
*)
let cpred (#a:Type0) (s:Seq.seq a) :spred a = fun s1 -> Seq.equal s s1
let seq_eq (s:Ghost.erased (Seq.seq 'a)) : spred 'a =
fun s' -> s' `Seq.equal` Ghost.reveal s
let value_is #a (b:ibuffer a) (s:Ghost.erased (Seq.seq a)) =
witnessed b (seq_eq s)
let sub_ptr_value_is (#a:_) (b0 b1:ibuffer a) (h:HS.mem) (i len:U32.t) (v:Seq.seq a)
: Lemma
(requires
U32.v i + U32.v len <= length b1 /\
b0 == mgsub (immutable_preorder a) b1 i len /\
value_is b1 v /\
Seq.length v == length b1)
(ensures
value_is b0 (Seq.slice v (U32.v i) (U32.v i + U32.v len)))
= let sub_v = Seq.slice v (U32.v i) (U32.v i + U32.v len) in
witnessed_functorial b1 b0 i len (seq_eq (Ghost.hide v)) (seq_eq (Ghost.hide sub_v))
unfold let libuffer (a:Type0) (len:nat) (s:Seq.seq a) =
b:lmbuffer a (immutable_preorder a) (immutable_preorder a) len{witnessed b (cpred s)}
unfold let libuffer_or_null (a:Type0) (len:nat) (r:HS.rid) (s:Seq.seq a) =
b:lmbuffer_or_null a (immutable_preorder a) (immutable_preorder a) len r{(not (g_is_null b)) ==>
witnessed b (cpred s)}
let igcmalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mgcmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
(*
* Unlike other allocation functions in this module,
* this function (and other flavors of alloc_and_blit) don't provide the witnessed contents
* as the refinement of the return type
* This is because the contents depend on the input memory (== the contents of src)
*)
let igcmalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mgcmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
inline_for_extraction
let igcmalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= igcmalloc r init len
let imalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
let imalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r /\ freeable b})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
inline_for_extraction
let imalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){(not (g_is_null b)) ==> freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= imalloc r init len
let ialloca (#a:Type0) (init:a) (len:U32.t)
:HST.StackInline (libuffer a (U32.v len) (Seq.create (U32.v len) init))
(requires (fun _ -> alloca_pre len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init) /\
frameOf b == HS.get_tip h0))
= let b = malloca init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
let ialloca_and_blit (#a:Type0)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.StackInline (lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len))
(requires fun h0 ->
alloca_pre len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
frameOf b == HS.get_tip h0 /\
b `value_is` G.hide s)
= let b = malloca_and_blit src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
let ialloca_of_list (#a:Type0) (init: list a)
:HST.StackInline (libuffer a (normalize_term (List.Tot.length init)) (Seq.seq_of_list init))
(requires (fun _ -> alloca_of_list_pre init))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.seq_of_list init) /\
frameOf b == HS.get_tip h0))
= let b = malloca_of_list init in
witness_p b (cpred (Seq.seq_of_list init));
b
let igcmalloc_of_list (#a:Type0) (r:HS.rid) (init:list a)
:HST.ST (b:libuffer a (normalize_term (List.Tot.length init)) (Seq.seq_of_list init){frameOf b == r /\ recallable b})
(requires (fun _ -> gcmalloc_of_list_pre r init))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.seq_of_list init)))
= let b = mgcmalloc_of_list r init in
witness_p b (cpred (Seq.seq_of_list init));
b
inline_for_extraction
let igcmalloc_of_list_partial (#a:Type0) (r:HS.rid) (init:list a)
:HST.ST (b:libuffer_or_null a (normalize_term (List.Tot.length init)) r (Seq.seq_of_list init){recallable b})
(requires (fun _ -> gcmalloc_of_list_pre r init))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.seq_of_list init)))
= igcmalloc_of_list r init
let witness_contents (#a:Type0) (b:ibuffer a) (s:Seq.seq a)
:HST.ST unit (requires (fun h0 -> Seq.equal (as_seq h0 b) s))
(ensures (fun h0 _ h1 -> h0 == h1 /\ witnessed b (cpred s)))
= witness_p b (cpred s)
let recall_contents (#a:Type0) (b:ibuffer a) (s:Seq.seq a)
:HST.ST unit (requires (fun h0 -> (recallable b \/ live h0 b) /\ witnessed b (cpred s)))
(ensures (fun h0 _ h1 -> h0 == h1 /\ live h0 b /\ as_seq h0 b == s))
= recall_p b (cpred s) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b: LowStar.ImmutableBuffer.ibuffer a -> FStar.HyperStack.ST.ST Prims.unit | FStar.HyperStack.ST.ST | [] | [] | [
"LowStar.ImmutableBuffer.ibuffer",
"LowStar.Monotonic.Buffer.witness_p",
"LowStar.ImmutableBuffer.immutable_preorder",
"LowStar.ImmutableBuffer.seq_eq",
"Prims.unit",
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"FStar.Ghost.hide",
"LowStar.Monotonic.Buffer.as_seq",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Prims.l_True",
"Prims.l_and",
"Prims.eq2",
"LowStar.ImmutableBuffer.value_is"
] | [] | false | true | false | false | false | let witness_value (#a: Type0) (b: ibuffer a)
: HST.ST unit
(requires (fun h0 -> True))
(ensures (fun h0 _ h1 -> h0 == h1 /\ b `value_is` (Ghost.hide (as_seq h1 b)))) =
| let h = HST.get () in
let s = Ghost.hide (as_seq h b) in
witness_p b (seq_eq s) | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.igcmalloc_of_list_partial | val igcmalloc_of_list_partial (#a: Type0) (r: HS.rid) (init: list a)
: HST.ST
(b:
libuffer_or_null a (normalize_term (List.Tot.length init)) r (Seq.seq_of_list init)
{recallable b})
(requires (fun _ -> gcmalloc_of_list_pre r init))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.seq_of_list init))) | val igcmalloc_of_list_partial (#a: Type0) (r: HS.rid) (init: list a)
: HST.ST
(b:
libuffer_or_null a (normalize_term (List.Tot.length init)) r (Seq.seq_of_list init)
{recallable b})
(requires (fun _ -> gcmalloc_of_list_pre r init))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.seq_of_list init))) | let igcmalloc_of_list_partial (#a:Type0) (r:HS.rid) (init:list a)
:HST.ST (b:libuffer_or_null a (normalize_term (List.Tot.length init)) r (Seq.seq_of_list init){recallable b})
(requires (fun _ -> gcmalloc_of_list_pre r init))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.seq_of_list init)))
= igcmalloc_of_list r init | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 195,
"start_col": 0,
"start_line": 191
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a)
unfold let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
unfold let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a)
inline_for_extraction
type ipointer (a:Type0) = b:ibuffer a{length b == 1}
inline_for_extraction
type ipointer_or_null (a:Type0) = b:ibuffer a{if g_is_null b then True else length b == 1}
inline_for_extraction let isub (#a:Type0) = msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
inline_for_extraction let ioffset (#a:Type0) = moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
(*
* It's a bit sub-optimal that we have both cpred and seq_eq
* Ideally it should only be the erased version seq_eq
*
* However, Lib.Buffer in hacl is already using cpred, so keeping it for now
* But it should be cleaned up when that dependency is gone
*)
let cpred (#a:Type0) (s:Seq.seq a) :spred a = fun s1 -> Seq.equal s s1
let seq_eq (s:Ghost.erased (Seq.seq 'a)) : spred 'a =
fun s' -> s' `Seq.equal` Ghost.reveal s
let value_is #a (b:ibuffer a) (s:Ghost.erased (Seq.seq a)) =
witnessed b (seq_eq s)
let sub_ptr_value_is (#a:_) (b0 b1:ibuffer a) (h:HS.mem) (i len:U32.t) (v:Seq.seq a)
: Lemma
(requires
U32.v i + U32.v len <= length b1 /\
b0 == mgsub (immutable_preorder a) b1 i len /\
value_is b1 v /\
Seq.length v == length b1)
(ensures
value_is b0 (Seq.slice v (U32.v i) (U32.v i + U32.v len)))
= let sub_v = Seq.slice v (U32.v i) (U32.v i + U32.v len) in
witnessed_functorial b1 b0 i len (seq_eq (Ghost.hide v)) (seq_eq (Ghost.hide sub_v))
unfold let libuffer (a:Type0) (len:nat) (s:Seq.seq a) =
b:lmbuffer a (immutable_preorder a) (immutable_preorder a) len{witnessed b (cpred s)}
unfold let libuffer_or_null (a:Type0) (len:nat) (r:HS.rid) (s:Seq.seq a) =
b:lmbuffer_or_null a (immutable_preorder a) (immutable_preorder a) len r{(not (g_is_null b)) ==>
witnessed b (cpred s)}
let igcmalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mgcmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
(*
* Unlike other allocation functions in this module,
* this function (and other flavors of alloc_and_blit) don't provide the witnessed contents
* as the refinement of the return type
* This is because the contents depend on the input memory (== the contents of src)
*)
let igcmalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mgcmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
inline_for_extraction
let igcmalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= igcmalloc r init len
let imalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
let imalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r /\ freeable b})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
inline_for_extraction
let imalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){(not (g_is_null b)) ==> freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= imalloc r init len
let ialloca (#a:Type0) (init:a) (len:U32.t)
:HST.StackInline (libuffer a (U32.v len) (Seq.create (U32.v len) init))
(requires (fun _ -> alloca_pre len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init) /\
frameOf b == HS.get_tip h0))
= let b = malloca init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
let ialloca_and_blit (#a:Type0)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.StackInline (lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len))
(requires fun h0 ->
alloca_pre len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
frameOf b == HS.get_tip h0 /\
b `value_is` G.hide s)
= let b = malloca_and_blit src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
let ialloca_of_list (#a:Type0) (init: list a)
:HST.StackInline (libuffer a (normalize_term (List.Tot.length init)) (Seq.seq_of_list init))
(requires (fun _ -> alloca_of_list_pre init))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.seq_of_list init) /\
frameOf b == HS.get_tip h0))
= let b = malloca_of_list init in
witness_p b (cpred (Seq.seq_of_list init));
b
let igcmalloc_of_list (#a:Type0) (r:HS.rid) (init:list a)
:HST.ST (b:libuffer a (normalize_term (List.Tot.length init)) (Seq.seq_of_list init){frameOf b == r /\ recallable b})
(requires (fun _ -> gcmalloc_of_list_pre r init))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.seq_of_list init)))
= let b = mgcmalloc_of_list r init in
witness_p b (cpred (Seq.seq_of_list init));
b | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: FStar.Monotonic.HyperHeap.rid -> init: Prims.list a
-> FStar.HyperStack.ST.ST
(b:
LowStar.ImmutableBuffer.libuffer_or_null a
(FStar.Pervasives.normalize_term (FStar.List.Tot.Base.length init))
r
(FStar.Seq.Base.seq_of_list init) {LowStar.Monotonic.Buffer.recallable b}) | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Monotonic.HyperHeap.rid",
"Prims.list",
"LowStar.ImmutableBuffer.igcmalloc_of_list",
"LowStar.ImmutableBuffer.libuffer",
"FStar.Pervasives.normalize_term",
"Prims.nat",
"FStar.List.Tot.Base.length",
"FStar.Seq.Base.seq_of_list",
"Prims.l_and",
"Prims.eq2",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.ImmutableBuffer.immutable_preorder",
"LowStar.Monotonic.Buffer.recallable",
"LowStar.ImmutableBuffer.libuffer_or_null",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.gcmalloc_of_list_pre",
"LowStar.Monotonic.Buffer.alloc_partial_post_mem_common"
] | [] | false | true | false | false | false | let igcmalloc_of_list_partial (#a: Type0) (r: HS.rid) (init: list a)
: HST.ST
(b:
libuffer_or_null a (normalize_term (List.Tot.length init)) r (Seq.seq_of_list init)
{recallable b})
(requires (fun _ -> gcmalloc_of_list_pre r init))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.seq_of_list init))) =
| igcmalloc_of_list r init | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.ialloca_and_blit | val ialloca_and_blit
(#a: Type0)
(#rrel1 #rel1: srel a)
(src: mbuffer a rrel1 rel1)
(id_src len: U32.t)
: HST.StackInline (lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len))
(requires fun h0 -> alloca_pre len /\ live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures
fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\ frameOf b == HS.get_tip h0 /\ b `value_is` (G.hide s)) | val ialloca_and_blit
(#a: Type0)
(#rrel1 #rel1: srel a)
(src: mbuffer a rrel1 rel1)
(id_src len: U32.t)
: HST.StackInline (lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len))
(requires fun h0 -> alloca_pre len /\ live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures
fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\ frameOf b == HS.get_tip h0 /\ b `value_is` (G.hide s)) | let ialloca_and_blit (#a:Type0)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.StackInline (lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len))
(requires fun h0 ->
alloca_pre len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
frameOf b == HS.get_tip h0 /\
b `value_is` G.hide s)
= let b = malloca_and_blit src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 171,
"start_col": 0,
"start_line": 157
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a)
unfold let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
unfold let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a)
inline_for_extraction
type ipointer (a:Type0) = b:ibuffer a{length b == 1}
inline_for_extraction
type ipointer_or_null (a:Type0) = b:ibuffer a{if g_is_null b then True else length b == 1}
inline_for_extraction let isub (#a:Type0) = msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
inline_for_extraction let ioffset (#a:Type0) = moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
(*
* It's a bit sub-optimal that we have both cpred and seq_eq
* Ideally it should only be the erased version seq_eq
*
* However, Lib.Buffer in hacl is already using cpred, so keeping it for now
* But it should be cleaned up when that dependency is gone
*)
let cpred (#a:Type0) (s:Seq.seq a) :spred a = fun s1 -> Seq.equal s s1
let seq_eq (s:Ghost.erased (Seq.seq 'a)) : spred 'a =
fun s' -> s' `Seq.equal` Ghost.reveal s
let value_is #a (b:ibuffer a) (s:Ghost.erased (Seq.seq a)) =
witnessed b (seq_eq s)
let sub_ptr_value_is (#a:_) (b0 b1:ibuffer a) (h:HS.mem) (i len:U32.t) (v:Seq.seq a)
: Lemma
(requires
U32.v i + U32.v len <= length b1 /\
b0 == mgsub (immutable_preorder a) b1 i len /\
value_is b1 v /\
Seq.length v == length b1)
(ensures
value_is b0 (Seq.slice v (U32.v i) (U32.v i + U32.v len)))
= let sub_v = Seq.slice v (U32.v i) (U32.v i + U32.v len) in
witnessed_functorial b1 b0 i len (seq_eq (Ghost.hide v)) (seq_eq (Ghost.hide sub_v))
unfold let libuffer (a:Type0) (len:nat) (s:Seq.seq a) =
b:lmbuffer a (immutable_preorder a) (immutable_preorder a) len{witnessed b (cpred s)}
unfold let libuffer_or_null (a:Type0) (len:nat) (r:HS.rid) (s:Seq.seq a) =
b:lmbuffer_or_null a (immutable_preorder a) (immutable_preorder a) len r{(not (g_is_null b)) ==>
witnessed b (cpred s)}
let igcmalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mgcmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
(*
* Unlike other allocation functions in this module,
* this function (and other flavors of alloc_and_blit) don't provide the witnessed contents
* as the refinement of the return type
* This is because the contents depend on the input memory (== the contents of src)
*)
let igcmalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mgcmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
inline_for_extraction
let igcmalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= igcmalloc r init len
let imalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
let imalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r /\ freeable b})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
inline_for_extraction
let imalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){(not (g_is_null b)) ==> freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= imalloc r init len
let ialloca (#a:Type0) (init:a) (len:U32.t)
:HST.StackInline (libuffer a (U32.v len) (Seq.create (U32.v len) init))
(requires (fun _ -> alloca_pre len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init) /\
frameOf b == HS.get_tip h0))
= let b = malloca init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | src: LowStar.Monotonic.Buffer.mbuffer a rrel1 rel1 -> id_src: FStar.UInt32.t -> len: FStar.UInt32.t
-> FStar.HyperStack.ST.StackInline
(LowStar.Monotonic.Buffer.lmbuffer a
(LowStar.ImmutableBuffer.immutable_preorder a)
(LowStar.ImmutableBuffer.immutable_preorder a)
(FStar.UInt32.v len)) | FStar.HyperStack.ST.StackInline | [] | [] | [
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.lmbuffer",
"LowStar.ImmutableBuffer.immutable_preorder",
"FStar.UInt32.v",
"Prims.unit",
"LowStar.Monotonic.Buffer.witness_p",
"LowStar.ImmutableBuffer.seq_eq",
"FStar.Ghost.hide",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.slice",
"LowStar.Monotonic.Buffer.as_seq",
"Prims.op_Addition",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"LowStar.Monotonic.Buffer.malloca_and_blit",
"LowStar.Monotonic.Buffer.alloca_pre",
"LowStar.Monotonic.Buffer.live",
"Prims.op_LessThanOrEqual",
"LowStar.Monotonic.Buffer.alloc_post_mem_common",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"FStar.Monotonic.HyperStack.get_tip",
"LowStar.ImmutableBuffer.value_is"
] | [] | false | true | false | false | false | let ialloca_and_blit
(#a: Type0)
(#rrel1 #rel1: srel a)
(src: mbuffer a rrel1 rel1)
(id_src len: U32.t)
: HST.StackInline (lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len))
(requires fun h0 -> alloca_pre len /\ live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures
fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\ frameOf b == HS.get_tip h0 /\ b `value_is` (G.hide s)) =
| let b = malloca_and_blit src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_load_skey_post | val rsapss_load_skey_post:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8)
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0 | val rsapss_load_skey_post:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8)
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0 | let rsapss_load_skey_post #t modBits eBits dBits nb eb db skey =
let bits = bits t in
let skey_s = S.rsapss_load_skey modBits eBits dBits nb eb db in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
rsapss_skey_pre modBits eBits dBits skey /\
Some? skey_s /\ (let pkey_s = S.Mk_rsapss_skey?.pkey (Some?.v skey_s) in
bn_v n == S.Mk_rsapss_pkey?.n pkey_s /\
bn_v e == S.Mk_rsapss_pkey?.e pkey_s /\
bn_v d == S.Mk_rsapss_skey?.d (Some?.v skey_s)) | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 49,
"end_line": 834,
"start_col": 0,
"start_line": 818
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)
val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
let rsapss_verify_pre a sLen msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a
val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post #t a modBits eBits pkey sLen sgnt msgLen msg verify =
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify_ a modBits pkeys sLen sgnt msgLen msg)
val rsapss_verify_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post1 #t a modBits eBits pkey sLen k sgnt msgLen msg verify =
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify a modBits pkeys sLen k sgnt msgLen msg)
val rsapss_sign_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_bn #t modBits eBits dBits skey m =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
let s = map (logand eq_m) s in
BB.unsafe_bool_of_limb eq_m, s
val rsapss_sign_msg_to_bn:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (lbignum t (blocks modBits (bits t)))
(requires rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> bn_v res < pow2 (modBits - 1))
let rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be #t emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
m
val rsapss_sign_compute_sgnt:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_compute_sgnt #t modBits eBits dBits skey m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
let eq_b, s = rsapss_sign_bn #t modBits eBits dBits skey m in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let sgnt = bn_to_bytes_be k s in
eq_b, sgnt
val rsapss_sign_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
rsapss_skey_pre modBits eBits dBits skey /\
rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> True)
let rsapss_sign_ #t a modBits eBits dBits skey sLen salt msgLen msg =
let m = rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg in
rsapss_sign_compute_sgnt #t modBits eBits dBits skey m
val rsapss_sign_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey)
(ensures
(let eq_m, s = rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg in
rsapss_sign_post a modBits eBits dBits skey sLen salt msgLen msg eq_m s))
let rsapss_sign_lemma #t a modBits eBits dBits skey sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
assert (bn_v m < bn_v n);
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
bn_eq_mask_lemma m m';
let s' = map (logand eq_m) s in
bn_mask_lemma s eq_m;
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
Math.Lemmas.pow2_le_compat (8 * k) modBits;
assert (bn_v s' < pow2 (8 * k));
let sgnt = bn_to_bytes_be k s' in
bn_to_bytes_be_lemma k s'
val rsapss_sign:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> sgnt:lseq uint8 (blocks modBits 8)
-> Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires rsapss_skey_pre modBits eBits dBits skey)
(ensures fun (b, sgnt) ->
rsapss_sign_post1 a modBits eBits dBits skey sLen salt msgLen msg b sgnt)
let rsapss_sign #t a modBits eBits dBits skey sLen salt msgLen msg sgnt =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
sLen + hLen + 2 <= blocks (modBits - 1) 8 in
if b then begin
rsapss_sign_lemma a modBits eBits dBits skey sLen salt msgLen msg;
rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg end
else
false, sgnt
val rsapss_verify_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> m_def:lbignum t (blocks modBits (bits t))
-> s:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_bn #t modBits eBits pkey m_def s =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
if bn_lt_pow2 modBits m then (true, m)
else false, m end
else false, m_def
val rsapss_verify_bn_to_msg:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> m:lbignum t (blocks modBits (bits t)) ->
Pure bool
(requires rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_bn_to_msg #t a modBits sLen msgLen msg m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let m1 = sub m 0 (blocks emLen numb) in
let em = bn_to_bytes_be emLen m1 in
S.pss_verify a sLen msgLen msg emBits em
val rsapss_verify_compute_msg:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sgnt:lseq uint8 (blocks modBits 8) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_compute_msg #t modBits eBits pkey sgnt =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
let m_def = create nLen (uint #t 0) in
rsapss_verify_bn #t modBits eBits pkey m_def s
val rsapss_verify_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires
rsapss_pkey_pre modBits eBits pkey /\
rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_ #t a modBits eBits pkey sLen sgnt msgLen msg =
let (b, m) = rsapss_verify_compute_msg #t modBits eBits pkey sgnt in
if b then
rsapss_verify_bn_to_msg a modBits sLen msgLen msg m
else
false
val rsapss_verify_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey)
(ensures
rsapss_verify_post a modBits eBits pkey sLen sgnt msgLen msg
(rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg))
let rsapss_verify_lemma #t a modBits eBits pkey sLen sgnt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
bn_from_bytes_be_lemma #t k sgnt;
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
let res =
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
bn_lt_pow2_lemma modBits m;
assert (bn_lt_pow2 modBits m == (bn_v m < pow2 (emLen * 8)));
let res =
if bn_lt_pow2 modBits m then begin
let m1 = sub m 0 (blocks emLen numb) in
bn_eval_sub modBits m;
assert (bn_v m1 == bn_v m);
let em = bn_to_bytes_be emLen m1 in
bn_to_bytes_be_lemma emLen m1;
S.pss_verify a sLen msgLen msg emBits em end
else false in
() end in
()
val rsapss_verify:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun r -> rsapss_verify_post1 a modBits eBits pkey sLen k sgnt msgLen msg r)
let rsapss_verify #t a modBits eBits pkey sLen k sgnt msgLen msg =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
//assert (max_size_t < Hash.max_input_length a);
assert (hLen + 8 < max_size_t);
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
k = blocks modBits 8 in
if b then begin
rsapss_verify_lemma a modBits eBits pkey sLen sgnt msgLen msg;
rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg end
else
false
val bn_check_num_bits: #t:limb_t -> bs:size_pos -> b:lbignum t (blocks bs (bits t)) ->
res:limb t{v res == (if bn_v b < pow2 bs then v (ones t SEC) else v (zeros t SEC))}
let bn_check_num_bits #t bs b =
let bLen = blocks bs (bits t) in
assert (bs <= bits t * bLen);
let m : limb t = if bs = bits t * bLen then ones t SEC else bn_lt_pow2_mask b bs in
(if bs = bits t * bLen then begin
bn_eval_bound b bLen;
Math.Lemmas.pow2_le_compat (bits t * bLen) bs end
else
bn_lt_pow2_mask_lemma b bs);
assert (v m == (if bn_v b < pow2 bs then v (ones t SEC) else v (zeros t SEC)));
m
val rsapss_check_modulus: #t:limb_t -> modBits:size_pos -> n:lbignum t (blocks modBits (bits t)) ->
res:limb t{v res == (if (bn_v n % 2 = 1 && pow2 (modBits - 1) < bn_v n && bn_v n < pow2 modBits) then v (ones t SEC) else v (zeros t SEC))}
let rsapss_check_modulus #t modBits n =
let bit0 = bn_is_odd n in
bn_is_odd_lemma n;
assert (v bit0 == bn_v n % 2);
let m0 = uint #t 0 -. bit0 in
let m1 = bn_gt_pow2_mask n (modBits - 1) in
bn_gt_pow2_mask_lemma n (modBits - 1);
let m2 = bn_check_num_bits modBits n in
let m = m0 &. (m1 &. m2) in
logand_lemma m0 (m1 &. m2);
logand_lemma m1 m2;
m
val rsapss_check_exponent: #t:limb_t -> eBits:size_pos -> e:lbignum t (blocks eBits (bits t)) ->
res:limb t{v res == (if (0 < bn_v e && bn_v e < pow2 eBits) then v (ones t SEC) else v (zeros t SEC))}
let rsapss_check_exponent #t eBits e =
let m0 = bn_is_zero_mask e in
bn_is_zero_mask_lemma e;
let m1 = bn_check_num_bits eBits e in
let m = (lognot m0) &. m1 in
lognot_lemma m0;
logand_lemma (lognot m0) m1;
m
val rsapss_load_pkey_post:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_load_pkey_post #t modBits eBits nb eb pkey =
let bits = bits t in
let pkey_s = S.rsapss_load_pkey modBits eBits nb eb in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let e = sub pkey (nLen + nLen) eLen in
rsapss_pkey_pre modBits eBits pkey /\
Some? pkey_s /\
bn_v n == S.Mk_rsapss_pkey?.n (Some?.v pkey_s) /\
bn_v e == S.Mk_rsapss_pkey?.e (Some?.v pkey_s)
val rsapss_load_skey_post:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8)
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0 | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat ->
dBits: Lib.IntTypes.size_nat{Hacl.Spec.RSAPSS.skey_len_pre t modBits eBits dBits} ->
nb: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks modBits 8) ->
eb: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks eBits 8) ->
db: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks dBits 8) ->
skey:
Hacl.Spec.Bignum.Definitions.lbignum t
(2 * Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks eBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks dBits (Lib.IntTypes.bits t))
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.RSAPSS.skey_len_pre",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Hacl.Spec.Bignum.Definitions.blocks",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Lib.IntTypes.bits",
"Prims.l_and",
"Hacl.Spec.RSAPSS.rsapss_skey_pre",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"Spec.RSAPSS.rsapss_skey",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_Subtraction",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Spec.RSAPSS.__proj__Mk_rsapss_pkey__item__n",
"Spec.RSAPSS.__proj__Mk_rsapss_pkey__item__e",
"Spec.RSAPSS.__proj__Mk_rsapss_skey__item__d",
"FStar.Pervasives.Native.__proj__Some__item__v",
"Spec.RSAPSS.rsapss_pkey",
"Spec.RSAPSS.__proj__Mk_rsapss_skey__item__pkey",
"Hacl.Spec.Bignum.Definitions.limb",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.op_Multiply",
"Prims.l_Forall",
"Prims.nat",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.Sequence.sub",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"FStar.Pervasives.Native.option",
"Spec.RSAPSS.rsapss_load_skey"
] | [] | false | false | false | false | true | let rsapss_load_skey_post #t modBits eBits dBits nb eb db skey =
| let bits = bits t in
let skey_s = S.rsapss_load_skey modBits eBits dBits nb eb db in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
rsapss_skey_pre modBits eBits dBits skey /\ Some? skey_s /\
(let pkey_s = S.Mk_rsapss_skey?.pkey (Some?.v skey_s) in
bn_v n == S.Mk_rsapss_pkey?.n pkey_s /\ bn_v e == S.Mk_rsapss_pkey?.e pkey_s /\
bn_v d == S.Mk_rsapss_skey?.d (Some?.v skey_s)) | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.buffer_immutable_buffer_disjoint | val buffer_immutable_buffer_disjoint
(#t #ti: Type)
(b: LowStar.Buffer.buffer t)
(bi: ibuffer ti)
(h: HS.mem)
: Lemma (requires (live h b /\ live h bi)) (ensures (disjoint b bi)) | val buffer_immutable_buffer_disjoint
(#t #ti: Type)
(b: LowStar.Buffer.buffer t)
(bi: ibuffer ti)
(h: HS.mem)
: Lemma (requires (live h b /\ live h bi)) (ensures (disjoint b bi)) | let buffer_immutable_buffer_disjoint
(#t: Type) (#ti: Type)
(b: LowStar.Buffer.buffer t)
(bi: ibuffer ti)
(h: HS.mem)
: Lemma
(requires (
live h b /\ live h bi
))
(ensures (
disjoint b bi
))
= if length b = 0
then empty_disjoint b bi
else if length bi = 0
then empty_disjoint bi b
else begin
let s = as_seq h b in
assert (~ (LowStar.Buffer.trivial_preorder _ Seq.empty s <==> immutable_preorder _ Seq.empty s));
live_same_addresses_equal_types_and_preorders b bi h
end | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 265,
"start_col": 0,
"start_line": 245
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a)
unfold let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
unfold let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a)
inline_for_extraction
type ipointer (a:Type0) = b:ibuffer a{length b == 1}
inline_for_extraction
type ipointer_or_null (a:Type0) = b:ibuffer a{if g_is_null b then True else length b == 1}
inline_for_extraction let isub (#a:Type0) = msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
inline_for_extraction let ioffset (#a:Type0) = moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
(*
* It's a bit sub-optimal that we have both cpred and seq_eq
* Ideally it should only be the erased version seq_eq
*
* However, Lib.Buffer in hacl is already using cpred, so keeping it for now
* But it should be cleaned up when that dependency is gone
*)
let cpred (#a:Type0) (s:Seq.seq a) :spred a = fun s1 -> Seq.equal s s1
let seq_eq (s:Ghost.erased (Seq.seq 'a)) : spred 'a =
fun s' -> s' `Seq.equal` Ghost.reveal s
let value_is #a (b:ibuffer a) (s:Ghost.erased (Seq.seq a)) =
witnessed b (seq_eq s)
let sub_ptr_value_is (#a:_) (b0 b1:ibuffer a) (h:HS.mem) (i len:U32.t) (v:Seq.seq a)
: Lemma
(requires
U32.v i + U32.v len <= length b1 /\
b0 == mgsub (immutable_preorder a) b1 i len /\
value_is b1 v /\
Seq.length v == length b1)
(ensures
value_is b0 (Seq.slice v (U32.v i) (U32.v i + U32.v len)))
= let sub_v = Seq.slice v (U32.v i) (U32.v i + U32.v len) in
witnessed_functorial b1 b0 i len (seq_eq (Ghost.hide v)) (seq_eq (Ghost.hide sub_v))
unfold let libuffer (a:Type0) (len:nat) (s:Seq.seq a) =
b:lmbuffer a (immutable_preorder a) (immutable_preorder a) len{witnessed b (cpred s)}
unfold let libuffer_or_null (a:Type0) (len:nat) (r:HS.rid) (s:Seq.seq a) =
b:lmbuffer_or_null a (immutable_preorder a) (immutable_preorder a) len r{(not (g_is_null b)) ==>
witnessed b (cpred s)}
let igcmalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mgcmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
(*
* Unlike other allocation functions in this module,
* this function (and other flavors of alloc_and_blit) don't provide the witnessed contents
* as the refinement of the return type
* This is because the contents depend on the input memory (== the contents of src)
*)
let igcmalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mgcmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
inline_for_extraction
let igcmalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= igcmalloc r init len
let imalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
let imalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r /\ freeable b})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
inline_for_extraction
let imalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){(not (g_is_null b)) ==> freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= imalloc r init len
let ialloca (#a:Type0) (init:a) (len:U32.t)
:HST.StackInline (libuffer a (U32.v len) (Seq.create (U32.v len) init))
(requires (fun _ -> alloca_pre len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init) /\
frameOf b == HS.get_tip h0))
= let b = malloca init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
let ialloca_and_blit (#a:Type0)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.StackInline (lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len))
(requires fun h0 ->
alloca_pre len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
frameOf b == HS.get_tip h0 /\
b `value_is` G.hide s)
= let b = malloca_and_blit src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
let ialloca_of_list (#a:Type0) (init: list a)
:HST.StackInline (libuffer a (normalize_term (List.Tot.length init)) (Seq.seq_of_list init))
(requires (fun _ -> alloca_of_list_pre init))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.seq_of_list init) /\
frameOf b == HS.get_tip h0))
= let b = malloca_of_list init in
witness_p b (cpred (Seq.seq_of_list init));
b
let igcmalloc_of_list (#a:Type0) (r:HS.rid) (init:list a)
:HST.ST (b:libuffer a (normalize_term (List.Tot.length init)) (Seq.seq_of_list init){frameOf b == r /\ recallable b})
(requires (fun _ -> gcmalloc_of_list_pre r init))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.seq_of_list init)))
= let b = mgcmalloc_of_list r init in
witness_p b (cpred (Seq.seq_of_list init));
b
inline_for_extraction
let igcmalloc_of_list_partial (#a:Type0) (r:HS.rid) (init:list a)
:HST.ST (b:libuffer_or_null a (normalize_term (List.Tot.length init)) r (Seq.seq_of_list init){recallable b})
(requires (fun _ -> gcmalloc_of_list_pre r init))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.seq_of_list init)))
= igcmalloc_of_list r init
let witness_contents (#a:Type0) (b:ibuffer a) (s:Seq.seq a)
:HST.ST unit (requires (fun h0 -> Seq.equal (as_seq h0 b) s))
(ensures (fun h0 _ h1 -> h0 == h1 /\ witnessed b (cpred s)))
= witness_p b (cpred s)
let recall_contents (#a:Type0) (b:ibuffer a) (s:Seq.seq a)
:HST.ST unit (requires (fun h0 -> (recallable b \/ live h0 b) /\ witnessed b (cpred s)))
(ensures (fun h0 _ h1 -> h0 == h1 /\ live h0 b /\ as_seq h0 b == s))
= recall_p b (cpred s)
let witness_value (#a:Type0) (b:ibuffer a)
:HST.ST unit (requires (fun h0 -> True))
(ensures (fun h0 _ h1 -> h0 == h1 /\ b `value_is` (Ghost.hide (as_seq h1 b))))
= let h = HST.get () in
let s = Ghost.hide (as_seq h b) in
witness_p b (seq_eq s)
let recall_value (#a:Type0) (b:ibuffer a) (s:Ghost.erased (Seq.seq a))
:HST.ST unit (requires (fun h0 -> (recallable b \/ live h0 b) /\ b `value_is` s))
(ensures (fun h0 _ h1 -> h0 == h1 /\ live h1 b /\ as_seq h1 b == Ghost.reveal s))
= recall_p b (seq_eq s)
(*
* Immutable buffers are distinct from (trivial) buffers
*
* The proof basically proves a contradiction assuming that the buffers are not distinct
* Using injectivity of the base preorders, we get that trivial preorder is same as immutable preorder
* After which it is easy to derive the contradiction, provided client has provided a witness for inhabitance
*)
let inhabited_immutable_buffer_is_distinct_from_buffer (#a:Type0) (x:a) (ib:ibuffer a) (b:LowStar.Buffer.buffer a)
: Lemma (~ (ib === b))
= let aux () : Lemma (requires (ib === b)) (ensures False)
= //use injectivity to prove that all sequences of type a are equal
mbuffer_injectivity_in_first_preorder ();
assert (immutable_preorder a == LowStar.Buffer.trivial_preorder a);
assert (forall (s1 s2:Seq.seq a). (immutable_preorder a) s1 s2 == (LowStar.Buffer.trivial_preorder a) s1 s2);
assert (forall (s1 s2:Seq.seq a). (immutable_preorder a) s1 s2 == Seq.equal s1 s2);
assert (forall (s1 s2:Seq.seq a). (LowStar.Buffer.trivial_preorder a) s1 s2 == True);
assert (forall (s1 s2:Seq.seq a). Seq.equal s1 s2);
//now derive the contradiction
let s1 = Seq.create 0 x in
let s2 = Seq.create 1 x in
Seq.lemma_eq_elim s1 s2;
assert (s1 == s2); assert (Seq.length s1 == Seq.length s2)
in
(Classical.move_requires aux) () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: LowStar.Buffer.buffer t ->
bi: LowStar.ImmutableBuffer.ibuffer ti ->
h: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires LowStar.Monotonic.Buffer.live h b /\ LowStar.Monotonic.Buffer.live h bi)
(ensures LowStar.Monotonic.Buffer.disjoint b bi) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowStar.Buffer.buffer",
"LowStar.ImmutableBuffer.ibuffer",
"FStar.Monotonic.HyperStack.mem",
"Prims.op_Equality",
"Prims.int",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"LowStar.Monotonic.Buffer.empty_disjoint",
"LowStar.ImmutableBuffer.immutable_preorder",
"Prims.bool",
"LowStar.Monotonic.Buffer.live_same_addresses_equal_types_and_preorders",
"Prims.unit",
"Prims._assert",
"Prims.l_not",
"Prims.l_iff",
"FStar.Seq.Base.empty",
"FStar.Seq.Base.seq",
"LowStar.Monotonic.Buffer.as_seq",
"Prims.l_and",
"LowStar.Monotonic.Buffer.live",
"Prims.squash",
"LowStar.Monotonic.Buffer.disjoint",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let buffer_immutable_buffer_disjoint
(#t #ti: Type)
(b: LowStar.Buffer.buffer t)
(bi: ibuffer ti)
(h: HS.mem)
: Lemma (requires (live h b /\ live h bi)) (ensures (disjoint b bi)) =
| if length b = 0
then empty_disjoint b bi
else
if length bi = 0
then empty_disjoint bi b
else
let s = as_seq h b in
assert (~(LowStar.Buffer.trivial_preorder _ Seq.empty s <==> immutable_preorder _ Seq.empty s));
live_same_addresses_equal_types_and_preorders b bi h | false |
LowStar.ImmutableBuffer.fst | LowStar.ImmutableBuffer.recall_value | val recall_value (#a: Type0) (b: ibuffer a) (s: Ghost.erased (Seq.seq a))
: HST.ST unit
(requires (fun h0 -> (recallable b \/ live h0 b) /\ b `value_is` s))
(ensures (fun h0 _ h1 -> h0 == h1 /\ live h1 b /\ as_seq h1 b == Ghost.reveal s)) | val recall_value (#a: Type0) (b: ibuffer a) (s: Ghost.erased (Seq.seq a))
: HST.ST unit
(requires (fun h0 -> (recallable b \/ live h0 b) /\ b `value_is` s))
(ensures (fun h0 _ h1 -> h0 == h1 /\ live h1 b /\ as_seq h1 b == Ghost.reveal s)) | let recall_value (#a:Type0) (b:ibuffer a) (s:Ghost.erased (Seq.seq a))
:HST.ST unit (requires (fun h0 -> (recallable b \/ live h0 b) /\ b `value_is` s))
(ensures (fun h0 _ h1 -> h0 == h1 /\ live h1 b /\ as_seq h1 b == Ghost.reveal s))
= recall_p b (seq_eq s) | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 25,
"end_line": 217,
"start_col": 0,
"start_line": 214
} | (*
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.
*)
module LowStar.ImmutableBuffer
include LowStar.Monotonic.Buffer
module P = FStar.Preorder
module G = FStar.Ghost
module U32 = FStar.UInt32
module Seq = FStar.Seq
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2
type ibuffer (a:Type0) = mbuffer a (immutable_preorder a) (immutable_preorder a)
unfold let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a)
unfold let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
unfold let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a)
inline_for_extraction
type ipointer (a:Type0) = b:ibuffer a{length b == 1}
inline_for_extraction
type ipointer_or_null (a:Type0) = b:ibuffer a{if g_is_null b then True else length b == 1}
inline_for_extraction let isub (#a:Type0) = msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
inline_for_extraction let ioffset (#a:Type0) = moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a)
(*
* It's a bit sub-optimal that we have both cpred and seq_eq
* Ideally it should only be the erased version seq_eq
*
* However, Lib.Buffer in hacl is already using cpred, so keeping it for now
* But it should be cleaned up when that dependency is gone
*)
let cpred (#a:Type0) (s:Seq.seq a) :spred a = fun s1 -> Seq.equal s s1
let seq_eq (s:Ghost.erased (Seq.seq 'a)) : spred 'a =
fun s' -> s' `Seq.equal` Ghost.reveal s
let value_is #a (b:ibuffer a) (s:Ghost.erased (Seq.seq a)) =
witnessed b (seq_eq s)
let sub_ptr_value_is (#a:_) (b0 b1:ibuffer a) (h:HS.mem) (i len:U32.t) (v:Seq.seq a)
: Lemma
(requires
U32.v i + U32.v len <= length b1 /\
b0 == mgsub (immutable_preorder a) b1 i len /\
value_is b1 v /\
Seq.length v == length b1)
(ensures
value_is b0 (Seq.slice v (U32.v i) (U32.v i + U32.v len)))
= let sub_v = Seq.slice v (U32.v i) (U32.v i + U32.v len) in
witnessed_functorial b1 b0 i len (seq_eq (Ghost.hide v)) (seq_eq (Ghost.hide sub_v))
unfold let libuffer (a:Type0) (len:nat) (s:Seq.seq a) =
b:lmbuffer a (immutable_preorder a) (immutable_preorder a) len{witnessed b (cpred s)}
unfold let libuffer_or_null (a:Type0) (len:nat) (r:HS.rid) (s:Seq.seq a) =
b:lmbuffer_or_null a (immutable_preorder a) (immutable_preorder a) len r{(not (g_is_null b)) ==>
witnessed b (cpred s)}
let igcmalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mgcmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
(*
* Unlike other allocation functions in this module,
* this function (and other flavors of alloc_and_blit) don't provide the witnessed contents
* as the refinement of the return type
* This is because the contents depend on the input memory (== the contents of src)
*)
let igcmalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mgcmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
inline_for_extraction
let igcmalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){recallable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= igcmalloc r init len
let imalloc (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer a (U32.v len) (Seq.create (U32.v len) init){frameOf b == r /\ freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= let b = mmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
let imalloc_and_blit (#a:Type0) (r:HS.rid)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.ST (b:lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len){frameOf b == r /\ freeable b})
(requires fun h0 ->
malloc_pre r len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
b `value_is` G.hide s)
= let b = mmalloc_and_blit r src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
inline_for_extraction
let imalloc_partial (#a:Type0) (r:HS.rid) (init:a) (len:U32.t)
:HST.ST (b:libuffer_or_null a (U32.v len) r (Seq.create (U32.v len) init){(not (g_is_null b)) ==> freeable b})
(requires (fun _ -> malloc_pre r len))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.create (U32.v len) init)))
= imalloc r init len
let ialloca (#a:Type0) (init:a) (len:U32.t)
:HST.StackInline (libuffer a (U32.v len) (Seq.create (U32.v len) init))
(requires (fun _ -> alloca_pre len))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init) /\
frameOf b == HS.get_tip h0))
= let b = malloca init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b
let ialloca_and_blit (#a:Type0)
(#rrel1 #rel1:srel a) (src:mbuffer a rrel1 rel1) (id_src:U32.t) (len:U32.t)
: HST.StackInline (lmbuffer a (immutable_preorder a) (immutable_preorder a) (U32.v len))
(requires fun h0 ->
alloca_pre len /\
live h0 src /\ U32.v id_src + U32.v len <= length src)
(ensures fun h0 b h1 ->
let s = Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len) in
alloc_post_mem_common b h0 h1 s /\
frameOf b == HS.get_tip h0 /\
b `value_is` G.hide s)
= let b = malloca_and_blit src id_src len in
let h0 = HST.get () in
witness_p b (seq_eq (G.hide (Seq.slice (as_seq h0 src) (U32.v id_src) (U32.v id_src + U32.v len))));
b
let ialloca_of_list (#a:Type0) (init: list a)
:HST.StackInline (libuffer a (normalize_term (List.Tot.length init)) (Seq.seq_of_list init))
(requires (fun _ -> alloca_of_list_pre init))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.seq_of_list init) /\
frameOf b == HS.get_tip h0))
= let b = malloca_of_list init in
witness_p b (cpred (Seq.seq_of_list init));
b
let igcmalloc_of_list (#a:Type0) (r:HS.rid) (init:list a)
:HST.ST (b:libuffer a (normalize_term (List.Tot.length init)) (Seq.seq_of_list init){frameOf b == r /\ recallable b})
(requires (fun _ -> gcmalloc_of_list_pre r init))
(ensures (fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.seq_of_list init)))
= let b = mgcmalloc_of_list r init in
witness_p b (cpred (Seq.seq_of_list init));
b
inline_for_extraction
let igcmalloc_of_list_partial (#a:Type0) (r:HS.rid) (init:list a)
:HST.ST (b:libuffer_or_null a (normalize_term (List.Tot.length init)) r (Seq.seq_of_list init){recallable b})
(requires (fun _ -> gcmalloc_of_list_pre r init))
(ensures (fun h0 b h1 -> alloc_partial_post_mem_common b h0 h1 (Seq.seq_of_list init)))
= igcmalloc_of_list r init
let witness_contents (#a:Type0) (b:ibuffer a) (s:Seq.seq a)
:HST.ST unit (requires (fun h0 -> Seq.equal (as_seq h0 b) s))
(ensures (fun h0 _ h1 -> h0 == h1 /\ witnessed b (cpred s)))
= witness_p b (cpred s)
let recall_contents (#a:Type0) (b:ibuffer a) (s:Seq.seq a)
:HST.ST unit (requires (fun h0 -> (recallable b \/ live h0 b) /\ witnessed b (cpred s)))
(ensures (fun h0 _ h1 -> h0 == h1 /\ live h0 b /\ as_seq h0 b == s))
= recall_p b (cpred s)
let witness_value (#a:Type0) (b:ibuffer a)
:HST.ST unit (requires (fun h0 -> True))
(ensures (fun h0 _ h1 -> h0 == h1 /\ b `value_is` (Ghost.hide (as_seq h1 b))))
= let h = HST.get () in
let s = Ghost.hide (as_seq h b) in
witness_p b (seq_eq s) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowStar.ImmutableBuffer.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b: LowStar.ImmutableBuffer.ibuffer a -> s: FStar.Ghost.erased (FStar.Seq.Base.seq a)
-> FStar.HyperStack.ST.ST Prims.unit | FStar.HyperStack.ST.ST | [] | [] | [
"LowStar.ImmutableBuffer.ibuffer",
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"LowStar.Monotonic.Buffer.recall_p",
"LowStar.ImmutableBuffer.immutable_preorder",
"LowStar.ImmutableBuffer.seq_eq",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Prims.l_or",
"LowStar.Monotonic.Buffer.recallable",
"LowStar.Monotonic.Buffer.live",
"LowStar.ImmutableBuffer.value_is",
"Prims.eq2",
"LowStar.Monotonic.Buffer.as_seq",
"FStar.Ghost.reveal"
] | [] | false | true | false | false | false | let recall_value (#a: Type0) (b: ibuffer a) (s: Ghost.erased (Seq.seq a))
: HST.ST unit
(requires (fun h0 -> (recallable b \/ live h0 b) /\ b `value_is` s))
(ensures (fun h0 _ h1 -> h0 == h1 /\ live h1 b /\ as_seq h1 b == Ghost.reveal s)) =
| recall_p b (seq_eq s) | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_load_pkey_lemma | val rsapss_load_pkey_lemma:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8) ->
Lemma
(let b, pkey = rsapss_load_pkey #t modBits eBits nb eb in
let pkey_s = S.rsapss_load_pkey modBits eBits nb eb in
(if b then rsapss_load_pkey_post modBits eBits nb eb pkey else None? pkey_s)) | val rsapss_load_pkey_lemma:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8) ->
Lemma
(let b, pkey = rsapss_load_pkey #t modBits eBits nb eb in
let pkey_s = S.rsapss_load_pkey modBits eBits nb eb in
(if b then rsapss_load_pkey_post modBits eBits nb eb pkey else None? pkey_s)) | let rsapss_load_pkey_lemma #t modBits eBits nb eb =
let bits = bits t in
let nbLen = blocks modBits 8 in
let ebLen = blocks eBits 8 in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_from_bytes_be #t nbLen nb in
bn_from_bytes_be_lemma #t nbLen nb;
let r2 = SM.bn_precomp_r2_mod_n (modBits - 1) n in
let e = bn_from_bytes_be #t ebLen eb in
bn_from_bytes_be_lemma #t ebLen eb;
let pkey = (n @| r2) @| e in
eq_intro (sub pkey 0 nLen) n;
eq_intro (sub pkey nLen nLen) r2;
eq_intro (sub pkey (nLen + nLen) eLen) e;
let m0 = rsapss_check_modulus modBits n in
let m1 = rsapss_check_exponent eBits e in
let m = m0 &. m1 in
logand_lemma m0 m1 | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 20,
"end_line": 891,
"start_col": 0,
"start_line": 868
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)
val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
let rsapss_verify_pre a sLen msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a
val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post #t a modBits eBits pkey sLen sgnt msgLen msg verify =
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify_ a modBits pkeys sLen sgnt msgLen msg)
val rsapss_verify_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post1 #t a modBits eBits pkey sLen k sgnt msgLen msg verify =
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify a modBits pkeys sLen k sgnt msgLen msg)
val rsapss_sign_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_bn #t modBits eBits dBits skey m =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
let s = map (logand eq_m) s in
BB.unsafe_bool_of_limb eq_m, s
val rsapss_sign_msg_to_bn:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (lbignum t (blocks modBits (bits t)))
(requires rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> bn_v res < pow2 (modBits - 1))
let rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be #t emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
m
val rsapss_sign_compute_sgnt:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_compute_sgnt #t modBits eBits dBits skey m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
let eq_b, s = rsapss_sign_bn #t modBits eBits dBits skey m in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let sgnt = bn_to_bytes_be k s in
eq_b, sgnt
val rsapss_sign_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
rsapss_skey_pre modBits eBits dBits skey /\
rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> True)
let rsapss_sign_ #t a modBits eBits dBits skey sLen salt msgLen msg =
let m = rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg in
rsapss_sign_compute_sgnt #t modBits eBits dBits skey m
val rsapss_sign_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey)
(ensures
(let eq_m, s = rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg in
rsapss_sign_post a modBits eBits dBits skey sLen salt msgLen msg eq_m s))
let rsapss_sign_lemma #t a modBits eBits dBits skey sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
assert (bn_v m < bn_v n);
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
bn_eq_mask_lemma m m';
let s' = map (logand eq_m) s in
bn_mask_lemma s eq_m;
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
Math.Lemmas.pow2_le_compat (8 * k) modBits;
assert (bn_v s' < pow2 (8 * k));
let sgnt = bn_to_bytes_be k s' in
bn_to_bytes_be_lemma k s'
val rsapss_sign:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> sgnt:lseq uint8 (blocks modBits 8)
-> Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires rsapss_skey_pre modBits eBits dBits skey)
(ensures fun (b, sgnt) ->
rsapss_sign_post1 a modBits eBits dBits skey sLen salt msgLen msg b sgnt)
let rsapss_sign #t a modBits eBits dBits skey sLen salt msgLen msg sgnt =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
sLen + hLen + 2 <= blocks (modBits - 1) 8 in
if b then begin
rsapss_sign_lemma a modBits eBits dBits skey sLen salt msgLen msg;
rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg end
else
false, sgnt
val rsapss_verify_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> m_def:lbignum t (blocks modBits (bits t))
-> s:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_bn #t modBits eBits pkey m_def s =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
if bn_lt_pow2 modBits m then (true, m)
else false, m end
else false, m_def
val rsapss_verify_bn_to_msg:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> m:lbignum t (blocks modBits (bits t)) ->
Pure bool
(requires rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_bn_to_msg #t a modBits sLen msgLen msg m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let m1 = sub m 0 (blocks emLen numb) in
let em = bn_to_bytes_be emLen m1 in
S.pss_verify a sLen msgLen msg emBits em
val rsapss_verify_compute_msg:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sgnt:lseq uint8 (blocks modBits 8) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_compute_msg #t modBits eBits pkey sgnt =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
let m_def = create nLen (uint #t 0) in
rsapss_verify_bn #t modBits eBits pkey m_def s
val rsapss_verify_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires
rsapss_pkey_pre modBits eBits pkey /\
rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_ #t a modBits eBits pkey sLen sgnt msgLen msg =
let (b, m) = rsapss_verify_compute_msg #t modBits eBits pkey sgnt in
if b then
rsapss_verify_bn_to_msg a modBits sLen msgLen msg m
else
false
val rsapss_verify_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey)
(ensures
rsapss_verify_post a modBits eBits pkey sLen sgnt msgLen msg
(rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg))
let rsapss_verify_lemma #t a modBits eBits pkey sLen sgnt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
bn_from_bytes_be_lemma #t k sgnt;
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
let res =
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
bn_lt_pow2_lemma modBits m;
assert (bn_lt_pow2 modBits m == (bn_v m < pow2 (emLen * 8)));
let res =
if bn_lt_pow2 modBits m then begin
let m1 = sub m 0 (blocks emLen numb) in
bn_eval_sub modBits m;
assert (bn_v m1 == bn_v m);
let em = bn_to_bytes_be emLen m1 in
bn_to_bytes_be_lemma emLen m1;
S.pss_verify a sLen msgLen msg emBits em end
else false in
() end in
()
val rsapss_verify:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun r -> rsapss_verify_post1 a modBits eBits pkey sLen k sgnt msgLen msg r)
let rsapss_verify #t a modBits eBits pkey sLen k sgnt msgLen msg =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
//assert (max_size_t < Hash.max_input_length a);
assert (hLen + 8 < max_size_t);
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
k = blocks modBits 8 in
if b then begin
rsapss_verify_lemma a modBits eBits pkey sLen sgnt msgLen msg;
rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg end
else
false
val bn_check_num_bits: #t:limb_t -> bs:size_pos -> b:lbignum t (blocks bs (bits t)) ->
res:limb t{v res == (if bn_v b < pow2 bs then v (ones t SEC) else v (zeros t SEC))}
let bn_check_num_bits #t bs b =
let bLen = blocks bs (bits t) in
assert (bs <= bits t * bLen);
let m : limb t = if bs = bits t * bLen then ones t SEC else bn_lt_pow2_mask b bs in
(if bs = bits t * bLen then begin
bn_eval_bound b bLen;
Math.Lemmas.pow2_le_compat (bits t * bLen) bs end
else
bn_lt_pow2_mask_lemma b bs);
assert (v m == (if bn_v b < pow2 bs then v (ones t SEC) else v (zeros t SEC)));
m
val rsapss_check_modulus: #t:limb_t -> modBits:size_pos -> n:lbignum t (blocks modBits (bits t)) ->
res:limb t{v res == (if (bn_v n % 2 = 1 && pow2 (modBits - 1) < bn_v n && bn_v n < pow2 modBits) then v (ones t SEC) else v (zeros t SEC))}
let rsapss_check_modulus #t modBits n =
let bit0 = bn_is_odd n in
bn_is_odd_lemma n;
assert (v bit0 == bn_v n % 2);
let m0 = uint #t 0 -. bit0 in
let m1 = bn_gt_pow2_mask n (modBits - 1) in
bn_gt_pow2_mask_lemma n (modBits - 1);
let m2 = bn_check_num_bits modBits n in
let m = m0 &. (m1 &. m2) in
logand_lemma m0 (m1 &. m2);
logand_lemma m1 m2;
m
val rsapss_check_exponent: #t:limb_t -> eBits:size_pos -> e:lbignum t (blocks eBits (bits t)) ->
res:limb t{v res == (if (0 < bn_v e && bn_v e < pow2 eBits) then v (ones t SEC) else v (zeros t SEC))}
let rsapss_check_exponent #t eBits e =
let m0 = bn_is_zero_mask e in
bn_is_zero_mask_lemma e;
let m1 = bn_check_num_bits eBits e in
let m = (lognot m0) &. m1 in
lognot_lemma m0;
logand_lemma (lognot m0) m1;
m
val rsapss_load_pkey_post:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_load_pkey_post #t modBits eBits nb eb pkey =
let bits = bits t in
let pkey_s = S.rsapss_load_pkey modBits eBits nb eb in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let e = sub pkey (nLen + nLen) eLen in
rsapss_pkey_pre modBits eBits pkey /\
Some? pkey_s /\
bn_v n == S.Mk_rsapss_pkey?.n (Some?.v pkey_s) /\
bn_v e == S.Mk_rsapss_pkey?.e (Some?.v pkey_s)
val rsapss_load_skey_post:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8)
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_load_skey_post #t modBits eBits dBits nb eb db skey =
let bits = bits t in
let skey_s = S.rsapss_load_skey modBits eBits dBits nb eb db in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
rsapss_skey_pre modBits eBits dBits skey /\
Some? skey_s /\ (let pkey_s = S.Mk_rsapss_skey?.pkey (Some?.v skey_s) in
bn_v n == S.Mk_rsapss_pkey?.n pkey_s /\
bn_v e == S.Mk_rsapss_pkey?.e pkey_s /\
bn_v d == S.Mk_rsapss_skey?.d (Some?.v skey_s))
val rsapss_load_pkey:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8) ->
tuple2 bool (lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)))
let rsapss_load_pkey #t modBits eBits nb eb =
let n = bn_from_bytes_be (blocks modBits 8) nb in
let r2 = SM.bn_precomp_r2_mod_n (modBits - 1) n in
let e = bn_from_bytes_be (blocks eBits 8) eb in
let pkey = (n @| r2) @| e in
let m0 = rsapss_check_modulus modBits n in
let m1 = rsapss_check_exponent eBits e in
let m = m0 &. m1 in
BB.unsafe_bool_of_limb m, pkey
val rsapss_load_pkey_lemma:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8) ->
Lemma
(let b, pkey = rsapss_load_pkey #t modBits eBits nb eb in
let pkey_s = S.rsapss_load_pkey modBits eBits nb eb in
(if b then rsapss_load_pkey_post modBits eBits nb eb pkey else None? pkey_s)) | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat{Hacl.Spec.RSAPSS.pkey_len_pre t modBits eBits} ->
nb: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks modBits 8) ->
eb: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks eBits 8)
-> FStar.Pervasives.Lemma
(ensures
(let _ = Hacl.Spec.RSAPSS.rsapss_load_pkey modBits eBits nb eb in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ b pkey = _ in
let pkey_s = Spec.RSAPSS.rsapss_load_pkey modBits eBits nb eb in
(match b with
| true -> Hacl.Spec.RSAPSS.rsapss_load_pkey_post modBits eBits nb eb pkey
| _ -> None? pkey_s)
<:
Type0)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.RSAPSS.pkey_len_pre",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.logand_lemma",
"Lib.IntTypes.SEC",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Amp_Dot",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.eq2",
"Prims.int",
"Lib.IntTypes.range",
"Lib.IntTypes.v",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Lib.IntTypes.bits",
"Prims.pow2",
"Lib.IntTypes.ones",
"Prims.bool",
"Lib.IntTypes.zeros",
"Hacl.Spec.RSAPSS.rsapss_check_exponent",
"Prims.op_Equality",
"Prims.op_Modulus",
"Prims.op_Subtraction",
"Hacl.Spec.RSAPSS.rsapss_check_modulus",
"Prims.unit",
"Lib.Sequence.eq_intro",
"Lib.Sequence.sub",
"Prims.op_Addition",
"Lib.IntTypes.numbytes",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.append",
"Lib.Sequence.op_At_Bar",
"Hacl.Spec.Bignum.bn_from_bytes_be_lemma",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.bn_from_bytes_be",
"Hacl.Spec.Bignum.Montgomery.bn_precomp_r2_mod_n",
"Prims.pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Multiply"
] | [] | true | false | true | false | false | let rsapss_load_pkey_lemma #t modBits eBits nb eb =
| let bits = bits t in
let nbLen = blocks modBits 8 in
let ebLen = blocks eBits 8 in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_from_bytes_be #t nbLen nb in
bn_from_bytes_be_lemma #t nbLen nb;
let r2 = SM.bn_precomp_r2_mod_n (modBits - 1) n in
let e = bn_from_bytes_be #t ebLen eb in
bn_from_bytes_be_lemma #t ebLen eb;
let pkey = (n @| r2) @| e in
eq_intro (sub pkey 0 nLen) n;
eq_intro (sub pkey nLen nLen) r2;
eq_intro (sub pkey (nLen + nLen) eLen) e;
let m0 = rsapss_check_modulus modBits n in
let m1 = rsapss_check_exponent eBits e in
let m = m0 &. m1 in
logand_lemma m0 m1 | false |
Steel.ST.MonotonicReference.fst | Steel.ST.MonotonicReference.recall | val recall (#inames: _)
(#a:Type u#0)
(#q:perm)
(#p:Preorder.preorder a)
(fact:property a)
(r:erased (ref a p))
(v:erased a)
(w:witnessed r fact)
: STAtomicU unit inames
(pts_to r q v)
(fun _ -> pts_to r q v)
(requires True)
(ensures fun _ -> fact v) | val recall (#inames: _)
(#a:Type u#0)
(#q:perm)
(#p:Preorder.preorder a)
(fact:property a)
(r:erased (ref a p))
(v:erased a)
(w:witnessed r fact)
: STAtomicU unit inames
(pts_to r q v)
(fun _ -> pts_to r q v)
(requires True)
(ensures fun _ -> fact v) | let recall (#inames: _)
(#a:Type u#0)
(#q:perm)
(#p:Preorder.preorder a)
(fact:property a)
(r:erased (ref a p))
(v:erased a)
(w:witnessed r fact)
= coerce_atomic (fun _ -> MR.recall #inames #a #q #p fact r v w) | {
"file_name": "lib/steel/Steel.ST.MonotonicReference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 66,
"end_line": 89,
"start_col": 0,
"start_line": 81
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.ST.MonotonicReference
open FStar.Ghost
open Steel.ST.Util
open Steel.ST.Coercions
module Preorder = FStar.Preorder
module MR = Steel.MonotonicReference
let ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0
= MR.ref a p
let pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
([@@@smt_fallback]f:perm)
([@@@smt_fallback]v:a)
: vprop
= MR.pts_to #a #p r f v
let alloc (#a:Type) (p:Preorder.preorder a) (v:a)
: STT (ref a p) emp (fun r -> pts_to r full_perm v)
= let x = coerce_steel (fun _ -> MR.alloc p v) in
return x
let write (#a:Type) (#p:Preorder.preorder a) (#v:erased a)
(r:ref a p) (x:a)
: ST unit
(pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires p v x)
(ensures fun _ -> True)
= coerce_steel (fun _ -> MR.write r x)
let witnessed (#a:Type u#0)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:property a)
: Type0
= MR.witnessed r fact
let witness' (#inames: _)
(#a:Type)
(#q:perm)
(#p:Preorder.preorder a)
(r:erased (ref a p))
(fact:stable_property p)
(v:erased a)
(pf:squash (fact v))
(_:unit)
: Steel.Effect.Atomic.SteelAtomicUT (witnessed r fact) inames
(pts_to r q v)
(fun _ -> pts_to r q v)
= MR.witness #inames #a #q #p r fact v pf
let witness (#inames: _)
(#a:Type)
(#q:perm)
(#p:Preorder.preorder a)
(r:erased (ref a p))
(fact:stable_property p)
(v:erased a)
(pf:squash (fact v))
= coerce_atomic (witness' r fact v pf) | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Coercions.fsti.checked",
"Steel.MonotonicReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.MonotonicReference.fst"
} | [
{
"abbrev": true,
"full_module": "Steel.MonotonicReference",
"short_module": "MR"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Coercions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
fact: Steel.ST.MonotonicReference.property a ->
r: FStar.Ghost.erased (Steel.ST.MonotonicReference.ref a p) ->
v: FStar.Ghost.erased a ->
w: Steel.ST.MonotonicReference.witnessed (FStar.Ghost.reveal r) fact
-> Steel.ST.Effect.Atomic.STAtomicU Prims.unit | Steel.ST.Effect.Atomic.STAtomicU | [] | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"FStar.Preorder.preorder",
"Steel.ST.MonotonicReference.property",
"FStar.Ghost.erased",
"Steel.ST.MonotonicReference.ref",
"Steel.ST.MonotonicReference.witnessed",
"FStar.Ghost.reveal",
"Steel.ST.Coercions.coerce_atomic",
"Prims.unit",
"Steel.Effect.Common.Unobservable",
"Steel.Effect.Common.VUnit",
"Steel.Effect.Common.to_vprop'",
"Steel.MonotonicReference.pts_to_sl",
"Steel.MonotonicReference.ref",
"Steel.Effect.Common.vprop",
"Prims.l_True",
"Steel.MonotonicReference.recall"
] | [] | false | true | false | false | false | let recall
(#inames: _)
(#a: Type u#0)
(#q: perm)
(#p: Preorder.preorder a)
(fact: property a)
(r: erased (ref a p))
(v: erased a)
(w: witnessed r fact)
=
| coerce_atomic (fun _ -> MR.recall #inames #a #q #p fact r v w) | false |
Steel.ST.MonotonicReference.fst | Steel.ST.MonotonicReference.witness | val witness (#inames: _)
(#a:Type)
(#q:perm)
(#p:Preorder.preorder a)
(r:erased (ref a p))
(fact:stable_property p)
(v:erased a)
(_:squash (fact v))
: STAtomicUT (witnessed r fact) inames
(pts_to r q v)
(fun _ -> pts_to r q v) | val witness (#inames: _)
(#a:Type)
(#q:perm)
(#p:Preorder.preorder a)
(r:erased (ref a p))
(fact:stable_property p)
(v:erased a)
(_:squash (fact v))
: STAtomicUT (witnessed r fact) inames
(pts_to r q v)
(fun _ -> pts_to r q v) | let witness (#inames: _)
(#a:Type)
(#q:perm)
(#p:Preorder.preorder a)
(r:erased (ref a p))
(fact:stable_property p)
(v:erased a)
(pf:squash (fact v))
= coerce_atomic (witness' r fact v pf) | {
"file_name": "lib/steel/Steel.ST.MonotonicReference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 40,
"end_line": 79,
"start_col": 0,
"start_line": 71
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.ST.MonotonicReference
open FStar.Ghost
open Steel.ST.Util
open Steel.ST.Coercions
module Preorder = FStar.Preorder
module MR = Steel.MonotonicReference
let ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0
= MR.ref a p
let pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
([@@@smt_fallback]f:perm)
([@@@smt_fallback]v:a)
: vprop
= MR.pts_to #a #p r f v
let alloc (#a:Type) (p:Preorder.preorder a) (v:a)
: STT (ref a p) emp (fun r -> pts_to r full_perm v)
= let x = coerce_steel (fun _ -> MR.alloc p v) in
return x
let write (#a:Type) (#p:Preorder.preorder a) (#v:erased a)
(r:ref a p) (x:a)
: ST unit
(pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires p v x)
(ensures fun _ -> True)
= coerce_steel (fun _ -> MR.write r x)
let witnessed (#a:Type u#0)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:property a)
: Type0
= MR.witnessed r fact
let witness' (#inames: _)
(#a:Type)
(#q:perm)
(#p:Preorder.preorder a)
(r:erased (ref a p))
(fact:stable_property p)
(v:erased a)
(pf:squash (fact v))
(_:unit)
: Steel.Effect.Atomic.SteelAtomicUT (witnessed r fact) inames
(pts_to r q v)
(fun _ -> pts_to r q v)
= MR.witness #inames #a #q #p r fact v pf | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Coercions.fsti.checked",
"Steel.MonotonicReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.MonotonicReference.fst"
} | [
{
"abbrev": true,
"full_module": "Steel.MonotonicReference",
"short_module": "MR"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Coercions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
r: FStar.Ghost.erased (Steel.ST.MonotonicReference.ref a p) ->
fact: Steel.ST.MonotonicReference.stable_property p ->
v: FStar.Ghost.erased a ->
pf: Prims.squash (fact (FStar.Ghost.reveal v))
-> Steel.ST.Effect.Atomic.STAtomicUT
(Steel.ST.MonotonicReference.witnessed (FStar.Ghost.reveal r) fact) | Steel.ST.Effect.Atomic.STAtomicUT | [] | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"FStar.Preorder.preorder",
"FStar.Ghost.erased",
"Steel.ST.MonotonicReference.ref",
"Steel.ST.MonotonicReference.stable_property",
"Prims.squash",
"FStar.Ghost.reveal",
"Steel.ST.Coercions.coerce_atomic",
"Steel.ST.MonotonicReference.witnessed",
"Steel.Effect.Common.Unobservable",
"Steel.ST.MonotonicReference.pts_to",
"Steel.Effect.Common.vprop",
"Prims.l_True",
"Steel.ST.MonotonicReference.witness'"
] | [] | false | true | false | false | false | let witness
(#inames: _)
(#a: Type)
(#q: perm)
(#p: Preorder.preorder a)
(r: erased (ref a p))
(fact: stable_property p)
(v: erased a)
(pf: squash (fact v))
=
| coerce_atomic (witness' r fact v pf) | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_sign_bn | val rsapss_sign_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True) | val rsapss_sign_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True) | let rsapss_sign_bn #t modBits eBits dBits skey m =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
let s = map (logand eq_m) s in
BB.unsafe_bool_of_limb eq_m, s | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 32,
"end_line": 324,
"start_col": 0,
"start_line": 306
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)
val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
let rsapss_verify_pre a sLen msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a
val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post #t a modBits eBits pkey sLen sgnt msgLen msg verify =
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify_ a modBits pkeys sLen sgnt msgLen msg)
val rsapss_verify_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post1 #t a modBits eBits pkey sLen k sgnt msgLen msg verify =
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify a modBits pkeys sLen k sgnt msgLen msg)
val rsapss_sign_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True) | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat ->
dBits: Lib.IntTypes.size_nat{Hacl.Spec.RSAPSS.skey_len_pre t modBits eBits dBits} ->
skey:
Hacl.Spec.Bignum.Definitions.lbignum t
(2 * Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks eBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks dBits (Lib.IntTypes.bits t)) ->
m:
Hacl.Spec.Bignum.Definitions.lbignum t
(Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t))
-> Prims.Pure
(Prims.bool *
Hacl.Spec.Bignum.Definitions.lbignum t
(Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t))) | Prims.Pure | [] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.RSAPSS.skey_len_pre",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.bits",
"FStar.Pervasives.Native.Mktuple2",
"Prims.bool",
"Hacl.Spec.Bignum.Base.unsafe_bool_of_limb",
"Lib.Sequence.lseq",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.eq2",
"Lib.Sequence.index",
"Lib.IntTypes.logand",
"Lib.IntTypes.SEC",
"Lib.Sequence.map",
"Hacl.Spec.Bignum.bn_eq_mask",
"Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_vartime_precompr2",
"Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_consttime_precompr2",
"Prims.unit",
"Hacl.Spec.Bignum.Montgomery.bn_precomp_r2_mod_n_lemma",
"Prims.op_Subtraction",
"FStar.Math.Lemmas.pow2_le_compat",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"Prims.pow2",
"Prims.op_Multiply",
"Prims.l_and",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.sub",
"Prims.int",
"FStar.Pervasives.Native.tuple2"
] | [] | false | false | false | false | false | let rsapss_sign_bn #t modBits eBits dBits skey m =
| let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
let s = map (logand eq_m) s in
BB.unsafe_bool_of_limb eq_m, s | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_verify_lemma | val rsapss_verify_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey)
(ensures
rsapss_verify_post a modBits eBits pkey sLen sgnt msgLen msg
(rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg)) | val rsapss_verify_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey)
(ensures
rsapss_verify_post a modBits eBits pkey sLen sgnt msgLen msg
(rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg)) | let rsapss_verify_lemma #t a modBits eBits pkey sLen sgnt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
bn_from_bytes_be_lemma #t k sgnt;
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
let res =
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
bn_lt_pow2_lemma modBits m;
assert (bn_lt_pow2 modBits m == (bn_v m < pow2 (emLen * 8)));
let res =
if bn_lt_pow2 modBits m then begin
let m1 = sub m 0 (blocks emLen numb) in
bn_eval_sub modBits m;
assert (bn_v m1 == bn_v m);
let em = bn_to_bytes_be emLen m1 in
bn_to_bytes_be_lemma emLen m1;
S.pss_verify a sLen msgLen msg emBits em end
else false in
() end in
() | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 697,
"start_col": 0,
"start_line": 650
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)
val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
let rsapss_verify_pre a sLen msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a
val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post #t a modBits eBits pkey sLen sgnt msgLen msg verify =
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify_ a modBits pkeys sLen sgnt msgLen msg)
val rsapss_verify_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post1 #t a modBits eBits pkey sLen k sgnt msgLen msg verify =
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify a modBits pkeys sLen k sgnt msgLen msg)
val rsapss_sign_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_bn #t modBits eBits dBits skey m =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
let s = map (logand eq_m) s in
BB.unsafe_bool_of_limb eq_m, s
val rsapss_sign_msg_to_bn:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (lbignum t (blocks modBits (bits t)))
(requires rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> bn_v res < pow2 (modBits - 1))
let rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be #t emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
m
val rsapss_sign_compute_sgnt:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_compute_sgnt #t modBits eBits dBits skey m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
let eq_b, s = rsapss_sign_bn #t modBits eBits dBits skey m in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let sgnt = bn_to_bytes_be k s in
eq_b, sgnt
val rsapss_sign_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
rsapss_skey_pre modBits eBits dBits skey /\
rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> True)
let rsapss_sign_ #t a modBits eBits dBits skey sLen salt msgLen msg =
let m = rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg in
rsapss_sign_compute_sgnt #t modBits eBits dBits skey m
val rsapss_sign_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey)
(ensures
(let eq_m, s = rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg in
rsapss_sign_post a modBits eBits dBits skey sLen salt msgLen msg eq_m s))
let rsapss_sign_lemma #t a modBits eBits dBits skey sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
assert (bn_v m < bn_v n);
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
bn_eq_mask_lemma m m';
let s' = map (logand eq_m) s in
bn_mask_lemma s eq_m;
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
Math.Lemmas.pow2_le_compat (8 * k) modBits;
assert (bn_v s' < pow2 (8 * k));
let sgnt = bn_to_bytes_be k s' in
bn_to_bytes_be_lemma k s'
val rsapss_sign:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> sgnt:lseq uint8 (blocks modBits 8)
-> Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires rsapss_skey_pre modBits eBits dBits skey)
(ensures fun (b, sgnt) ->
rsapss_sign_post1 a modBits eBits dBits skey sLen salt msgLen msg b sgnt)
let rsapss_sign #t a modBits eBits dBits skey sLen salt msgLen msg sgnt =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
sLen + hLen + 2 <= blocks (modBits - 1) 8 in
if b then begin
rsapss_sign_lemma a modBits eBits dBits skey sLen salt msgLen msg;
rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg end
else
false, sgnt
val rsapss_verify_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> m_def:lbignum t (blocks modBits (bits t))
-> s:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_bn #t modBits eBits pkey m_def s =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
if bn_lt_pow2 modBits m then (true, m)
else false, m end
else false, m_def
val rsapss_verify_bn_to_msg:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> m:lbignum t (blocks modBits (bits t)) ->
Pure bool
(requires rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_bn_to_msg #t a modBits sLen msgLen msg m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let m1 = sub m 0 (blocks emLen numb) in
let em = bn_to_bytes_be emLen m1 in
S.pss_verify a sLen msgLen msg emBits em
val rsapss_verify_compute_msg:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sgnt:lseq uint8 (blocks modBits 8) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_compute_msg #t modBits eBits pkey sgnt =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
let m_def = create nLen (uint #t 0) in
rsapss_verify_bn #t modBits eBits pkey m_def s
val rsapss_verify_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires
rsapss_pkey_pre modBits eBits pkey /\
rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_ #t a modBits eBits pkey sLen sgnt msgLen msg =
let (b, m) = rsapss_verify_compute_msg #t modBits eBits pkey sgnt in
if b then
rsapss_verify_bn_to_msg a modBits sLen msgLen msg m
else
false
val rsapss_verify_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey)
(ensures
rsapss_verify_post a modBits eBits pkey sLen sgnt msgLen msg
(rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg)) | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat{Hacl.Spec.RSAPSS.pkey_len_pre t modBits eBits} ->
pkey:
Hacl.Spec.Bignum.Definitions.lbignum t
(2 * Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks eBits (Lib.IntTypes.bits t)) ->
sLen: Lib.IntTypes.size_nat ->
sgnt: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks modBits 8) ->
msgLen: Prims.nat ->
msg: Lib.Sequence.seq Lib.IntTypes.uint8 {Lib.Sequence.length msg == msgLen}
-> FStar.Pervasives.Lemma
(requires
Hacl.Spec.RSAPSS.rsapss_verify_pre a sLen msgLen msg /\
Hacl.Spec.RSAPSS.rsapss_pkey_pre modBits eBits pkey)
(ensures
Hacl.Spec.RSAPSS.rsapss_verify_post a
modBits
eBits
pkey
sLen
sgnt
msgLen
msg
(Hacl.Spec.RSAPSS.rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Lib.IntTypes.size_nat",
"Hacl.Spec.RSAPSS.pkey_len_pre",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.bits",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Prims.nat",
"Lib.Sequence.seq",
"Prims.eq2",
"Lib.Sequence.length",
"Prims.unit",
"Hacl.Spec.Bignum.Base.unsafe_bool_of_limb",
"Prims.bool",
"Hacl.Spec.RSAPSS.bn_lt_pow2",
"Spec.RSAPSS.pss_verify",
"Hacl.Spec.Bignum.bn_to_bytes_be_lemma",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Hacl.Spec.Bignum.bn_to_bytes_be",
"Prims._assert",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Hacl.Spec.RSAPSS.bn_eval_sub",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.l_and",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.l_Forall",
"Prims.op_LessThan",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.Sequence.sub",
"Prims.pow2",
"Hacl.Spec.RSAPSS.bn_lt_pow2_lemma",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.max_size_t",
"Lib.IntTypes.size_pos",
"Hacl.Spec.RSAPSS.blocks_numb_lemma",
"Hacl.Spec.RSAPSS.blocks_bits_lemma",
"Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_vartime_precompr2",
"Hacl.Spec.Bignum.Montgomery.bn_precomp_r2_mod_n_lemma",
"Prims.op_Subtraction",
"FStar.Math.Lemmas.pow2_le_compat",
"Hacl.Spec.Bignum.bn_lt_mask_lemma",
"Lib.IntTypes.numbytes",
"Hacl.Spec.Bignum.bn_lt_mask",
"Hacl.Spec.Bignum.bn_from_bytes_be_lemma",
"Hacl.Spec.Bignum.bn_from_bytes_be",
"Prims.pos",
"Prims.op_Multiply",
"Prims.int"
] | [] | false | false | true | false | false | let rsapss_verify_lemma #t a modBits eBits pkey sLen sgnt msgLen msg =
| let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
bn_from_bytes_be_lemma #t k sgnt;
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
let res =
if BB.unsafe_bool_of_limb mask
then
(Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
bn_lt_pow2_lemma modBits m;
assert (bn_lt_pow2 modBits m == (bn_v m < pow2 (emLen * 8)));
let res =
if bn_lt_pow2 modBits m
then
let m1 = sub m 0 (blocks emLen numb) in
bn_eval_sub modBits m;
assert (bn_v m1 == bn_v m);
let em = bn_to_bytes_be emLen m1 in
bn_to_bytes_be_lemma emLen m1;
S.pss_verify a sLen msgLen msg emBits em
else false
in
())
in
() | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_load_skey_lemma | val rsapss_load_skey_lemma:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8) ->
Lemma
(let b, skey = rsapss_load_skey #t modBits eBits dBits nb eb db in
let skey_s = S.rsapss_load_skey modBits eBits dBits nb eb db in
(if b then rsapss_load_skey_post modBits eBits dBits nb eb db skey else None? skey_s)) | val rsapss_load_skey_lemma:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8) ->
Lemma
(let b, skey = rsapss_load_skey #t modBits eBits dBits nb eb db in
let skey_s = S.rsapss_load_skey modBits eBits dBits nb eb db in
(if b then rsapss_load_skey_post modBits eBits dBits nb eb db skey else None? skey_s)) | let rsapss_load_skey_lemma #t modBits eBits dBits nb eb db =
let bits = bits t in
let nbLen = blocks modBits 8 in
let ebLen = blocks eBits 8 in
let dbLen = blocks dBits 8 in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let b, pkey = rsapss_load_pkey #t modBits eBits nb eb in
rsapss_load_pkey_lemma #t modBits eBits nb eb;
let d = bn_from_bytes_be #t (blocks dBits 8) db in
bn_from_bytes_be_lemma #t (blocks dBits 8) db;
let skey = pkey @| d in
eq_intro (sub skey 0 (nLen + nLen + eLen)) pkey;
eq_intro (sub skey (nLen + nLen + eLen) dLen) d | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 49,
"end_line": 945,
"start_col": 0,
"start_line": 927
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)
val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
let rsapss_verify_pre a sLen msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a
val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post #t a modBits eBits pkey sLen sgnt msgLen msg verify =
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify_ a modBits pkeys sLen sgnt msgLen msg)
val rsapss_verify_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post1 #t a modBits eBits pkey sLen k sgnt msgLen msg verify =
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify a modBits pkeys sLen k sgnt msgLen msg)
val rsapss_sign_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_bn #t modBits eBits dBits skey m =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
let s = map (logand eq_m) s in
BB.unsafe_bool_of_limb eq_m, s
val rsapss_sign_msg_to_bn:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (lbignum t (blocks modBits (bits t)))
(requires rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> bn_v res < pow2 (modBits - 1))
let rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be #t emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
m
val rsapss_sign_compute_sgnt:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_compute_sgnt #t modBits eBits dBits skey m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
let eq_b, s = rsapss_sign_bn #t modBits eBits dBits skey m in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let sgnt = bn_to_bytes_be k s in
eq_b, sgnt
val rsapss_sign_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
rsapss_skey_pre modBits eBits dBits skey /\
rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> True)
let rsapss_sign_ #t a modBits eBits dBits skey sLen salt msgLen msg =
let m = rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg in
rsapss_sign_compute_sgnt #t modBits eBits dBits skey m
val rsapss_sign_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey)
(ensures
(let eq_m, s = rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg in
rsapss_sign_post a modBits eBits dBits skey sLen salt msgLen msg eq_m s))
let rsapss_sign_lemma #t a modBits eBits dBits skey sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
assert (bn_v m < bn_v n);
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
bn_eq_mask_lemma m m';
let s' = map (logand eq_m) s in
bn_mask_lemma s eq_m;
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
Math.Lemmas.pow2_le_compat (8 * k) modBits;
assert (bn_v s' < pow2 (8 * k));
let sgnt = bn_to_bytes_be k s' in
bn_to_bytes_be_lemma k s'
val rsapss_sign:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> sgnt:lseq uint8 (blocks modBits 8)
-> Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires rsapss_skey_pre modBits eBits dBits skey)
(ensures fun (b, sgnt) ->
rsapss_sign_post1 a modBits eBits dBits skey sLen salt msgLen msg b sgnt)
let rsapss_sign #t a modBits eBits dBits skey sLen salt msgLen msg sgnt =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
sLen + hLen + 2 <= blocks (modBits - 1) 8 in
if b then begin
rsapss_sign_lemma a modBits eBits dBits skey sLen salt msgLen msg;
rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg end
else
false, sgnt
val rsapss_verify_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> m_def:lbignum t (blocks modBits (bits t))
-> s:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_bn #t modBits eBits pkey m_def s =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
if bn_lt_pow2 modBits m then (true, m)
else false, m end
else false, m_def
val rsapss_verify_bn_to_msg:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> m:lbignum t (blocks modBits (bits t)) ->
Pure bool
(requires rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_bn_to_msg #t a modBits sLen msgLen msg m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let m1 = sub m 0 (blocks emLen numb) in
let em = bn_to_bytes_be emLen m1 in
S.pss_verify a sLen msgLen msg emBits em
val rsapss_verify_compute_msg:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sgnt:lseq uint8 (blocks modBits 8) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun res -> True)
let rsapss_verify_compute_msg #t modBits eBits pkey sgnt =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
let m_def = create nLen (uint #t 0) in
rsapss_verify_bn #t modBits eBits pkey m_def s
val rsapss_verify_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires
rsapss_pkey_pre modBits eBits pkey /\
rsapss_verify_pre a sLen msgLen msg)
(ensures fun r -> True)
let rsapss_verify_ #t a modBits eBits pkey sLen sgnt msgLen msg =
let (b, m) = rsapss_verify_compute_msg #t modBits eBits pkey sgnt in
if b then
rsapss_verify_bn_to_msg a modBits sLen msgLen msg m
else
false
val rsapss_verify_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey)
(ensures
rsapss_verify_post a modBits eBits pkey sLen sgnt msgLen msg
(rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg))
let rsapss_verify_lemma #t a modBits eBits pkey sLen sgnt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let s = bn_from_bytes_be k sgnt in
bn_from_bytes_be_lemma #t k sgnt;
let mask = bn_lt_mask s n in
bn_lt_mask_lemma s n;
let res =
if BB.unsafe_bool_of_limb mask then begin
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let m = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
bn_lt_pow2_lemma modBits m;
assert (bn_lt_pow2 modBits m == (bn_v m < pow2 (emLen * 8)));
let res =
if bn_lt_pow2 modBits m then begin
let m1 = sub m 0 (blocks emLen numb) in
bn_eval_sub modBits m;
assert (bn_v m1 == bn_v m);
let em = bn_to_bytes_be emLen m1 in
bn_to_bytes_be_lemma emLen m1;
S.pss_verify a sLen msgLen msg emBits em end
else false in
() end in
()
val rsapss_verify:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure bool
(requires rsapss_pkey_pre modBits eBits pkey)
(ensures fun r -> rsapss_verify_post1 a modBits eBits pkey sLen k sgnt msgLen msg r)
let rsapss_verify #t a modBits eBits pkey sLen k sgnt msgLen msg =
let hLen = Hash.hash_length a in
Math.Lemmas.pow2_lt_compat 61 32;
Math.Lemmas.pow2_lt_compat 125 32;
//assert (max_size_t < Hash.max_input_length a);
assert (hLen + 8 < max_size_t);
let b =
sLen <= v (0xfffffffful) - hLen - 8 &&
msgLen `less_than_max_input_length` a &&
k = blocks modBits 8 in
if b then begin
rsapss_verify_lemma a modBits eBits pkey sLen sgnt msgLen msg;
rsapss_verify_ a modBits eBits pkey sLen sgnt msgLen msg end
else
false
val bn_check_num_bits: #t:limb_t -> bs:size_pos -> b:lbignum t (blocks bs (bits t)) ->
res:limb t{v res == (if bn_v b < pow2 bs then v (ones t SEC) else v (zeros t SEC))}
let bn_check_num_bits #t bs b =
let bLen = blocks bs (bits t) in
assert (bs <= bits t * bLen);
let m : limb t = if bs = bits t * bLen then ones t SEC else bn_lt_pow2_mask b bs in
(if bs = bits t * bLen then begin
bn_eval_bound b bLen;
Math.Lemmas.pow2_le_compat (bits t * bLen) bs end
else
bn_lt_pow2_mask_lemma b bs);
assert (v m == (if bn_v b < pow2 bs then v (ones t SEC) else v (zeros t SEC)));
m
val rsapss_check_modulus: #t:limb_t -> modBits:size_pos -> n:lbignum t (blocks modBits (bits t)) ->
res:limb t{v res == (if (bn_v n % 2 = 1 && pow2 (modBits - 1) < bn_v n && bn_v n < pow2 modBits) then v (ones t SEC) else v (zeros t SEC))}
let rsapss_check_modulus #t modBits n =
let bit0 = bn_is_odd n in
bn_is_odd_lemma n;
assert (v bit0 == bn_v n % 2);
let m0 = uint #t 0 -. bit0 in
let m1 = bn_gt_pow2_mask n (modBits - 1) in
bn_gt_pow2_mask_lemma n (modBits - 1);
let m2 = bn_check_num_bits modBits n in
let m = m0 &. (m1 &. m2) in
logand_lemma m0 (m1 &. m2);
logand_lemma m1 m2;
m
val rsapss_check_exponent: #t:limb_t -> eBits:size_pos -> e:lbignum t (blocks eBits (bits t)) ->
res:limb t{v res == (if (0 < bn_v e && bn_v e < pow2 eBits) then v (ones t SEC) else v (zeros t SEC))}
let rsapss_check_exponent #t eBits e =
let m0 = bn_is_zero_mask e in
bn_is_zero_mask_lemma e;
let m1 = bn_check_num_bits eBits e in
let m = (lognot m0) &. m1 in
lognot_lemma m0;
logand_lemma (lognot m0) m1;
m
val rsapss_load_pkey_post:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_load_pkey_post #t modBits eBits nb eb pkey =
let bits = bits t in
let pkey_s = S.rsapss_load_pkey modBits eBits nb eb in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let e = sub pkey (nLen + nLen) eLen in
rsapss_pkey_pre modBits eBits pkey /\
Some? pkey_s /\
bn_v n == S.Mk_rsapss_pkey?.n (Some?.v pkey_s) /\
bn_v e == S.Mk_rsapss_pkey?.e (Some?.v pkey_s)
val rsapss_load_skey_post:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8)
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_load_skey_post #t modBits eBits dBits nb eb db skey =
let bits = bits t in
let skey_s = S.rsapss_load_skey modBits eBits dBits nb eb db in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
rsapss_skey_pre modBits eBits dBits skey /\
Some? skey_s /\ (let pkey_s = S.Mk_rsapss_skey?.pkey (Some?.v skey_s) in
bn_v n == S.Mk_rsapss_pkey?.n pkey_s /\
bn_v e == S.Mk_rsapss_pkey?.e pkey_s /\
bn_v d == S.Mk_rsapss_skey?.d (Some?.v skey_s))
val rsapss_load_pkey:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8) ->
tuple2 bool (lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)))
let rsapss_load_pkey #t modBits eBits nb eb =
let n = bn_from_bytes_be (blocks modBits 8) nb in
let r2 = SM.bn_precomp_r2_mod_n (modBits - 1) n in
let e = bn_from_bytes_be (blocks eBits 8) eb in
let pkey = (n @| r2) @| e in
let m0 = rsapss_check_modulus modBits n in
let m1 = rsapss_check_exponent eBits e in
let m = m0 &. m1 in
BB.unsafe_bool_of_limb m, pkey
val rsapss_load_pkey_lemma:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8) ->
Lemma
(let b, pkey = rsapss_load_pkey #t modBits eBits nb eb in
let pkey_s = S.rsapss_load_pkey modBits eBits nb eb in
(if b then rsapss_load_pkey_post modBits eBits nb eb pkey else None? pkey_s))
let rsapss_load_pkey_lemma #t modBits eBits nb eb =
let bits = bits t in
let nbLen = blocks modBits 8 in
let ebLen = blocks eBits 8 in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_from_bytes_be #t nbLen nb in
bn_from_bytes_be_lemma #t nbLen nb;
let r2 = SM.bn_precomp_r2_mod_n (modBits - 1) n in
let e = bn_from_bytes_be #t ebLen eb in
bn_from_bytes_be_lemma #t ebLen eb;
let pkey = (n @| r2) @| e in
eq_intro (sub pkey 0 nLen) n;
eq_intro (sub pkey nLen nLen) r2;
eq_intro (sub pkey (nLen + nLen) eLen) e;
let m0 = rsapss_check_modulus modBits n in
let m1 = rsapss_check_exponent eBits e in
let m = m0 &. m1 in
logand_lemma m0 m1
val rsapss_load_skey:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8) ->
tuple2 bool (lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)))
let rsapss_load_skey #t modBits eBits dBits nb eb db =
let b, pkey = rsapss_load_pkey modBits eBits nb eb in
let d = bn_from_bytes_be #t (blocks dBits 8) db in
let skey = pkey @| d in
let m0 = rsapss_check_exponent dBits d in
let b1 = b && BB.unsafe_bool_of_limb m0 in
b1, skey
val rsapss_load_skey_lemma:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8) ->
Lemma
(let b, skey = rsapss_load_skey #t modBits eBits dBits nb eb db in
let skey_s = S.rsapss_load_skey modBits eBits dBits nb eb db in
(if b then rsapss_load_skey_post modBits eBits dBits nb eb db skey else None? skey_s)) | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat ->
dBits: Lib.IntTypes.size_nat{Hacl.Spec.RSAPSS.skey_len_pre t modBits eBits dBits} ->
nb: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks modBits 8) ->
eb: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks eBits 8) ->
db: Lib.Sequence.lseq Lib.IntTypes.uint8 (Hacl.Spec.Bignum.Definitions.blocks dBits 8)
-> FStar.Pervasives.Lemma
(ensures
(let _ = Hacl.Spec.RSAPSS.rsapss_load_skey modBits eBits dBits nb eb db in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ b skey = _ in
let skey_s = Spec.RSAPSS.rsapss_load_skey modBits eBits dBits nb eb db in
(match b with
| true -> Hacl.Spec.RSAPSS.rsapss_load_skey_post modBits eBits dBits nb eb db skey
| _ -> None? skey_s)
<:
Type0)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.RSAPSS.skey_len_pre",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Hacl.Spec.Bignum.Definitions.blocks",
"Prims.bool",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Lib.IntTypes.bits",
"Lib.Sequence.eq_intro",
"Hacl.Spec.Bignum.Definitions.limb",
"Lib.Sequence.sub",
"Lib.IntTypes.numbytes",
"Prims.unit",
"Prims.op_Multiply",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.append",
"Lib.Sequence.op_At_Bar",
"Hacl.Spec.Bignum.bn_from_bytes_be_lemma",
"Hacl.Spec.Bignum.bn_from_bytes_be",
"Hacl.Spec.RSAPSS.rsapss_load_pkey_lemma",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.RSAPSS.rsapss_load_pkey",
"Prims.pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.int"
] | [] | false | false | true | false | false | let rsapss_load_skey_lemma #t modBits eBits dBits nb eb db =
| let bits = bits t in
let nbLen = blocks modBits 8 in
let ebLen = blocks eBits 8 in
let dbLen = blocks dBits 8 in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let b, pkey = rsapss_load_pkey #t modBits eBits nb eb in
rsapss_load_pkey_lemma #t modBits eBits nb eb;
let d = bn_from_bytes_be #t (blocks dBits 8) db in
bn_from_bytes_be_lemma #t (blocks dBits 8) db;
let skey = pkey @| d in
eq_intro (sub skey 0 (nLen + nLen + eLen)) pkey;
eq_intro (sub skey (nLen + nLen + eLen) dLen) d | false |
Steel.ST.MonotonicReference.fst | Steel.ST.MonotonicReference.write | val write (#a:Type) (#p:Preorder.preorder a) (#v:erased a)
(r:ref a p) (x:a)
: ST unit
(pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires p v x)
(ensures fun _ -> True) | val write (#a:Type) (#p:Preorder.preorder a) (#v:erased a)
(r:ref a p) (x:a)
: ST unit
(pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires p v x)
(ensures fun _ -> True) | let write (#a:Type) (#p:Preorder.preorder a) (#v:erased a)
(r:ref a p) (x:a)
: ST unit
(pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires p v x)
(ensures fun _ -> True)
= coerce_steel (fun _ -> MR.write r x) | {
"file_name": "lib/steel/Steel.ST.MonotonicReference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 40,
"end_line": 48,
"start_col": 0,
"start_line": 41
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.ST.MonotonicReference
open FStar.Ghost
open Steel.ST.Util
open Steel.ST.Coercions
module Preorder = FStar.Preorder
module MR = Steel.MonotonicReference
let ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0
= MR.ref a p
let pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
([@@@smt_fallback]f:perm)
([@@@smt_fallback]v:a)
: vprop
= MR.pts_to #a #p r f v
let alloc (#a:Type) (p:Preorder.preorder a) (v:a)
: STT (ref a p) emp (fun r -> pts_to r full_perm v)
= let x = coerce_steel (fun _ -> MR.alloc p v) in
return x | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Coercions.fsti.checked",
"Steel.MonotonicReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.MonotonicReference.fst"
} | [
{
"abbrev": true,
"full_module": "Steel.MonotonicReference",
"short_module": "MR"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Coercions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.ST.MonotonicReference.ref a p -> x: a -> Steel.ST.Effect.ST Prims.unit | Steel.ST.Effect.ST | [] | [] | [
"FStar.Preorder.preorder",
"FStar.Ghost.erased",
"Steel.ST.MonotonicReference.ref",
"Steel.ST.Coercions.coerce_steel",
"Prims.unit",
"Steel.Effect.Common.VUnit",
"Steel.Effect.Common.to_vprop'",
"Steel.MonotonicReference.pts_to_sl",
"Steel.FractionalPermission.full_perm",
"FStar.Ghost.reveal",
"Steel.Effect.Common.vprop",
"Prims.l_and",
"Prims.l_True",
"Steel.MonotonicReference.write",
"Steel.ST.MonotonicReference.pts_to"
] | [] | false | true | false | false | false | let write (#a: Type) (#p: Preorder.preorder a) (#v: erased a) (r: ref a p) (x: a)
: ST unit
(pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires p v x)
(ensures fun _ -> True) =
| coerce_steel (fun _ -> MR.write r x) | false |
LowParse.Low.BitSum.fst | LowParse.Low.BitSum.validate_bitsum_cases_t | val validate_bitsum_cases_t
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(#from: nat)
(b: bitsum' cl from)
: Tot (Type u#(r + 1)) | val validate_bitsum_cases_t
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(#from: nat)
(b: bitsum' cl from)
: Tot (Type u#(r + 1)) | let validate_bitsum_cases_t
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(#from: nat)
(b: bitsum' cl from)
: Tot (Type u#(r+1))
= (u: (bitsum'_key_type b -> Tot (Type u#r))) ->
(f: ((x: bitsum'_key_type b) -> Tot (k: parser_kind & parser k (u x)))) ->
(v: ((x: bitsum'_key_type b) -> Tot (validator (dsnd (f x))))) ->
(x: parse_filter_refine (filter_bitsum' b)) ->
Tot (validator (dsnd (f (bitsum'_key_of_t b (synth_bitsum' b x))))) | {
"file_name": "src/lowparse/LowParse.Low.BitSum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 69,
"end_line": 47,
"start_col": 0,
"start_line": 36
} | module LowParse.Low.BitSum
include LowParse.Low.Combinators
include LowParse.Spec.BitSum
module U32 = FStar.UInt32
module HS = FStar.HyperStack
#push-options "--z3rlimit 16"
inline_for_extraction
let validate_bitsum'
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#k: parser_kind)
(#p: parser k t)
(v: validator p)
(r: leaf_reader p)
(phi: filter_bitsum'_t b)
: Tot (validator (parse_bitsum' b p))
= synth_bitsum'_injective b;
validate_synth
(validate_filter
v
r
(filter_bitsum' b)
(fun x -> phi x))
(synth_bitsum' b)
()
module HST = FStar.HyperStack.ST
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.BitSum.fst.checked",
"LowParse.Low.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.BitSum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.BitSum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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
}
] | {
"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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b: LowParse.Spec.BitSum.bitsum' cl from -> Type | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"Prims.eqtype",
"LowParse.BitFields.uint_t",
"Prims.nat",
"LowParse.Spec.BitSum.bitsum'",
"LowParse.Spec.BitSum.bitsum'_key_type",
"Prims.dtuple2",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.validator",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.BitSum.filter_bitsum'",
"LowParse.Spec.BitSum.bitsum'_key_of_t",
"LowParse.Spec.BitSum.synth_bitsum'"
] | [] | false | false | false | false | true | let validate_bitsum_cases_t
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(#from: nat)
(b: bitsum' cl from)
: Tot (Type u#(r + 1)) =
|
u: (bitsum'_key_type b -> Tot (Type u#r)) ->
f: (x: bitsum'_key_type b -> Tot (k: parser_kind & parser k (u x))) ->
v: (x: bitsum'_key_type b -> Tot (validator (dsnd (f x)))) ->
x: parse_filter_refine (filter_bitsum' b)
-> Tot (validator (dsnd (f (bitsum'_key_of_t b (synth_bitsum' b x))))) | false |
Vale.PPC64LE.Regs.fst | Vale.PPC64LE.Regs.equal | val equal (regs1:t) (regs2:t) : prop0 | val equal (regs1:t) (regs2:t) : prop0 | let equal regs1 regs2 = feq regs1 regs2 | {
"file_name": "vale/code/arch/ppc64le/Vale.PPC64LE.Regs.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 39,
"end_line": 5,
"start_col": 0,
"start_line": 5
} | module Vale.PPC64LE.Regs
open Vale.PPC64LE.Machine_s
open FStar.FunctionalExtensionality | {
"checked_file": "/",
"dependencies": [
"Vale.PPC64LE.Machine_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.PPC64LE.Regs.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | regs1: Vale.PPC64LE.Regs.t -> regs2: Vale.PPC64LE.Regs.t -> Vale.Def.Prop_s.prop0 | Prims.Tot | [
"total"
] | [] | [
"Vale.PPC64LE.Regs.t",
"FStar.FunctionalExtensionality.feq",
"Vale.PPC64LE.Machine_s.reg",
"Vale.PPC64LE.Machine_s.nat64",
"Vale.Def.Prop_s.prop0"
] | [] | false | false | false | true | false | let equal regs1 regs2 =
| feq regs1 regs2 | false |
Steel.ST.MonotonicReference.fst | Steel.ST.MonotonicReference.share | val share (#inames:_)
(#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f:perm)
(v:Ghost.erased a)
: STGhostT unit inames
(pts_to r f v)
(fun _ -> pts_to r (half_perm f) v `star` pts_to r (half_perm f) v) | val share (#inames:_)
(#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f:perm)
(v:Ghost.erased a)
: STGhostT unit inames
(pts_to r f v)
(fun _ -> pts_to r (half_perm f) v `star` pts_to r (half_perm f) v) | let share (#inames:_)
(#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f:perm)
(v:Ghost.erased a)
: STGhostT unit inames
(pts_to r f v)
(fun _ -> pts_to r (half_perm f) v `star` pts_to r (half_perm f) v)
= coerce_ghost (fun _ -> MR.share r f v) | {
"file_name": "lib/steel/Steel.ST.MonotonicReference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 42,
"end_line": 100,
"start_col": 0,
"start_line": 91
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.ST.MonotonicReference
open FStar.Ghost
open Steel.ST.Util
open Steel.ST.Coercions
module Preorder = FStar.Preorder
module MR = Steel.MonotonicReference
let ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0
= MR.ref a p
let pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
([@@@smt_fallback]f:perm)
([@@@smt_fallback]v:a)
: vprop
= MR.pts_to #a #p r f v
let alloc (#a:Type) (p:Preorder.preorder a) (v:a)
: STT (ref a p) emp (fun r -> pts_to r full_perm v)
= let x = coerce_steel (fun _ -> MR.alloc p v) in
return x
let write (#a:Type) (#p:Preorder.preorder a) (#v:erased a)
(r:ref a p) (x:a)
: ST unit
(pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires p v x)
(ensures fun _ -> True)
= coerce_steel (fun _ -> MR.write r x)
let witnessed (#a:Type u#0)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:property a)
: Type0
= MR.witnessed r fact
let witness' (#inames: _)
(#a:Type)
(#q:perm)
(#p:Preorder.preorder a)
(r:erased (ref a p))
(fact:stable_property p)
(v:erased a)
(pf:squash (fact v))
(_:unit)
: Steel.Effect.Atomic.SteelAtomicUT (witnessed r fact) inames
(pts_to r q v)
(fun _ -> pts_to r q v)
= MR.witness #inames #a #q #p r fact v pf
let witness (#inames: _)
(#a:Type)
(#q:perm)
(#p:Preorder.preorder a)
(r:erased (ref a p))
(fact:stable_property p)
(v:erased a)
(pf:squash (fact v))
= coerce_atomic (witness' r fact v pf)
let recall (#inames: _)
(#a:Type u#0)
(#q:perm)
(#p:Preorder.preorder a)
(fact:property a)
(r:erased (ref a p))
(v:erased a)
(w:witnessed r fact)
= coerce_atomic (fun _ -> MR.recall #inames #a #q #p fact r v w) | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Coercions.fsti.checked",
"Steel.MonotonicReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.MonotonicReference.fst"
} | [
{
"abbrev": true,
"full_module": "Steel.MonotonicReference",
"short_module": "MR"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Coercions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
r: Steel.ST.MonotonicReference.ref a p ->
f: Steel.FractionalPermission.perm ->
v: FStar.Ghost.erased a
-> Steel.ST.Effect.Ghost.STGhostT Prims.unit | Steel.ST.Effect.Ghost.STGhostT | [] | [] | [
"Steel.Memory.inames",
"FStar.Preorder.preorder",
"Steel.ST.MonotonicReference.ref",
"Steel.FractionalPermission.perm",
"FStar.Ghost.erased",
"Steel.ST.Coercions.coerce_ghost",
"Prims.unit",
"Steel.Effect.Common.VUnit",
"Steel.Effect.Common.to_vprop'",
"Steel.MonotonicReference.pts_to_sl",
"FStar.Ghost.reveal",
"Steel.Effect.Common.star",
"Steel.FractionalPermission.half_perm",
"Steel.Effect.Common.vprop",
"Prims.l_True",
"Steel.MonotonicReference.share",
"Steel.ST.MonotonicReference.pts_to"
] | [] | false | true | false | false | false | let share
(#inames: _)
(#a: Type)
(#p: Preorder.preorder a)
(r: ref a p)
(f: perm)
(v: Ghost.erased a)
: STGhostT unit
inames
(pts_to r f v)
(fun _ -> (pts_to r (half_perm f) v) `star` (pts_to r (half_perm f) v)) =
| coerce_ghost (fun _ -> MR.share r f v) | false |
Steel.ST.MonotonicReference.fst | Steel.ST.MonotonicReference.gather | val gather (#inames:_)
(#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f g:perm)
(v:Ghost.erased a)
: STGhostT unit inames
(pts_to r f v `star` pts_to r g v)
(fun _ -> pts_to r (sum_perm f g) v) | val gather (#inames:_)
(#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f g:perm)
(v:Ghost.erased a)
: STGhostT unit inames
(pts_to r f v `star` pts_to r g v)
(fun _ -> pts_to r (sum_perm f g) v) | let gather (#inames:_)
(#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f g:perm)
(v:Ghost.erased a)
: STGhostT unit inames
(pts_to r f v `star` pts_to r g v)
(fun _ -> pts_to r (sum_perm f g) v)
= coerce_ghost (fun _ -> MR.gather #inames #a #p r f g v) | {
"file_name": "lib/steel/Steel.ST.MonotonicReference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 59,
"end_line": 111,
"start_col": 0,
"start_line": 102
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.ST.MonotonicReference
open FStar.Ghost
open Steel.ST.Util
open Steel.ST.Coercions
module Preorder = FStar.Preorder
module MR = Steel.MonotonicReference
let ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0
= MR.ref a p
let pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
([@@@smt_fallback]f:perm)
([@@@smt_fallback]v:a)
: vprop
= MR.pts_to #a #p r f v
let alloc (#a:Type) (p:Preorder.preorder a) (v:a)
: STT (ref a p) emp (fun r -> pts_to r full_perm v)
= let x = coerce_steel (fun _ -> MR.alloc p v) in
return x
let write (#a:Type) (#p:Preorder.preorder a) (#v:erased a)
(r:ref a p) (x:a)
: ST unit
(pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires p v x)
(ensures fun _ -> True)
= coerce_steel (fun _ -> MR.write r x)
let witnessed (#a:Type u#0)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:property a)
: Type0
= MR.witnessed r fact
let witness' (#inames: _)
(#a:Type)
(#q:perm)
(#p:Preorder.preorder a)
(r:erased (ref a p))
(fact:stable_property p)
(v:erased a)
(pf:squash (fact v))
(_:unit)
: Steel.Effect.Atomic.SteelAtomicUT (witnessed r fact) inames
(pts_to r q v)
(fun _ -> pts_to r q v)
= MR.witness #inames #a #q #p r fact v pf
let witness (#inames: _)
(#a:Type)
(#q:perm)
(#p:Preorder.preorder a)
(r:erased (ref a p))
(fact:stable_property p)
(v:erased a)
(pf:squash (fact v))
= coerce_atomic (witness' r fact v pf)
let recall (#inames: _)
(#a:Type u#0)
(#q:perm)
(#p:Preorder.preorder a)
(fact:property a)
(r:erased (ref a p))
(v:erased a)
(w:witnessed r fact)
= coerce_atomic (fun _ -> MR.recall #inames #a #q #p fact r v w)
let share (#inames:_)
(#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f:perm)
(v:Ghost.erased a)
: STGhostT unit inames
(pts_to r f v)
(fun _ -> pts_to r (half_perm f) v `star` pts_to r (half_perm f) v)
= coerce_ghost (fun _ -> MR.share r f v) | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Coercions.fsti.checked",
"Steel.MonotonicReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.MonotonicReference.fst"
} | [
{
"abbrev": true,
"full_module": "Steel.MonotonicReference",
"short_module": "MR"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Coercions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
r: Steel.ST.MonotonicReference.ref a p ->
f: Steel.FractionalPermission.perm ->
g: Steel.FractionalPermission.perm ->
v: FStar.Ghost.erased a
-> Steel.ST.Effect.Ghost.STGhostT Prims.unit | Steel.ST.Effect.Ghost.STGhostT | [] | [] | [
"Steel.Memory.inames",
"FStar.Preorder.preorder",
"Steel.ST.MonotonicReference.ref",
"Steel.FractionalPermission.perm",
"FStar.Ghost.erased",
"Steel.ST.Coercions.coerce_ghost",
"Prims.unit",
"Steel.Effect.Common.star",
"Steel.Effect.Common.VUnit",
"Steel.Effect.Common.to_vprop'",
"Steel.MonotonicReference.pts_to_sl",
"FStar.Ghost.reveal",
"Steel.FractionalPermission.sum_perm",
"Steel.Effect.Common.vprop",
"Prims.l_True",
"Steel.MonotonicReference.gather",
"Steel.ST.MonotonicReference.pts_to"
] | [] | false | true | false | false | false | let gather
(#inames: _)
(#a: Type)
(#p: Preorder.preorder a)
(r: ref a p)
(f g: perm)
(v: Ghost.erased a)
: STGhostT unit
inames
((pts_to r f v) `star` (pts_to r g v))
(fun _ -> pts_to r (sum_perm f g) v) =
| coerce_ghost (fun _ -> MR.gather #inames #a #p r f g v) | false |
Hacl.Spec.RSAPSS.fst | Hacl.Spec.RSAPSS.rsapss_sign_lemma | val rsapss_sign_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey)
(ensures
(let eq_m, s = rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg in
rsapss_sign_post a modBits eBits dBits skey sLen salt msgLen msg eq_m s)) | val rsapss_sign_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey)
(ensures
(let eq_m, s = rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg in
rsapss_sign_post a modBits eBits dBits skey sLen salt msgLen msg eq_m s)) | let rsapss_sign_lemma #t a modBits eBits dBits skey sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
assert (bn_v m < bn_v n);
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
bn_eq_mask_lemma m m';
let s' = map (logand eq_m) s in
bn_mask_lemma s eq_m;
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
Math.Lemmas.pow2_le_compat (8 * k) modBits;
assert (bn_v s' < pow2 (8 * k));
let sgnt = bn_to_bytes_be k s' in
bn_to_bytes_be_lemma k s' | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 27,
"end_line": 482,
"start_col": 0,
"start_line": 433
} | module Hacl.Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum
open Hacl.Spec.Bignum.Exponentiation
module S = Spec.RSAPSS
module BB = Hacl.Spec.Bignum.Base
module SM = Hacl.Spec.Bignum.Montgomery
module BSeq = Lib.ByteSequence
module Hash = Spec.Agile.Hash
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks_bits_lemma: t:limb_t -> bs:size_pos ->
Lemma (blocks (blocks bs 8) (numbytes t) == blocks bs (bits t))
let blocks_bits_lemma t bs = ()
val blocks_numb_lemma: t:limb_t -> bs:size_pos ->
Lemma (numbytes t * blocks (blocks bs 8) (numbytes t) <= max_size_t)
let blocks_numb_lemma t bs = ()
val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool
let bn_lt_pow2 #t modBits m =
if (modBits - 1) % 8 <> 0 then true
else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1))
val bn_eval_lt_pow2_modBits:
#t:limb_t
-> modBits:size_pos{1 < modBits}
-> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_v m == (bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1))
let bn_eval_lt_pow2_modBits #t modBits m =
calc (==) {
bn_v m;
(==) { Math.Lemmas.euclidean_division_definition (bn_v m) (pow2 (modBits - 1)) }
bn_v m / pow2 (modBits - 1) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.euclidean_division_definition (bn_v m / pow2 (modBits - 1)) 2 }
(bn_v m / pow2 (modBits - 1) / 2 * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v m) (pow2 (modBits - 1)) 2; Math.Lemmas.pow2_plus (modBits - 1) 1}
(bn_v m / pow2 modBits * 2 + bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
(==) { Math.Lemmas.small_division_lemma_1 (bn_v m) (pow2 modBits) }
(bn_v m / pow2 (modBits - 1) % 2) * pow2 (modBits - 1) + bn_v m % pow2 (modBits - 1);
}
val bn_lt_pow2_lemma: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 modBits)
(ensures bn_lt_pow2 modBits m == (bn_v m < pow2 (8 * blocks (modBits - 1) 8)))
let bn_lt_pow2_lemma #t modBits m =
let k = blocks modBits 8 in
let emLen = blocks (modBits - 1) 8 in
let nLen = blocks k (numbytes t) in
assert (nLen == blocks modBits (bits t));
if (modBits - 1) % 8 <> 0 then Math.Lemmas.pow2_le_compat (8 * emLen) modBits
else begin
assert (k == emLen + 1);
bn_eval_unfold_i m nLen;
assert (8 * k == modBits + 7);
assert (8 * emLen == modBits - 1);
bn_eval_lt_pow2_modBits modBits m;
bn_get_ith_bit_lemma m (modBits - 1) end
val bn_eval_sub: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> Lemma
(requires bn_v m < pow2 (8 * blocks (modBits - 1) 8))
(ensures bn_v m == bn_v (sub m 0 (blocks (blocks (modBits - 1) 8) (numbytes t))))
let bn_eval_sub #t modBits m =
let emLen = blocks (modBits - 1) 8 in
let mLen = blocks emLen (numbytes t) in
let nLen = blocks modBits (bits t) in
assert (bn_v m < pow2 (8 * emLen));
let m1 = sub m 0 mLen in
bn_eval_split_i m mLen;
assert (bn_v m == bn_v m1 + pow2 (bits t * mLen) * bn_v (slice m mLen nLen));
bn_eval_bound m1 mLen;
assert (bn_v m1 < pow2 (bits t * mLen));
Math.Lemmas.pow2_le_compat (bits t * mLen) (8 * emLen)
let pkey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) =
let bits = bits t in
1 < modBits /\ 0 < eBits /\
2 * bits * blocks modBits bits <= max_size_t /\
bits * blocks eBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits <= max_size_t
let skey_len_pre (t:limb_t) (modBits:size_nat) (eBits:size_nat) (dBits:size_nat) =
let bits = bits t in
pkey_len_pre t modBits eBits /\
0 < dBits /\ bits * blocks dBits bits <= max_size_t /\
2 * blocks modBits bits + blocks eBits bits + blocks dBits bits <= max_size_t
val rsapss_pkey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t)) -> Type0
let rsapss_pkey_pre #t modBits eBits pkey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = sub pkey 0 nLen in
let r2 = sub pkey nLen nLen in
let e = sub pkey (nLen + nLen) eLen in
r2 == SM.bn_precomp_r2_mod_n (modBits - 1) n /\
bn_v n % 2 = 1 /\
pow2 (modBits - 1) < bn_v n /\ bn_v n < pow2 modBits /\
0 < bn_v e /\ bn_v e < pow2 eBits
val rsapss_skey_pre:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t)) -> Type0
let rsapss_skey_pre #t modBits eBits dBits skey =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let pkeyLen = nLen + nLen + eLen in
let pkey = sub skey 0 pkeyLen in
let d = sub skey pkeyLen dLen in
rsapss_pkey_pre modBits eBits pkey /\
0 < bn_v d /\ bn_v d < pow2 dBits
val rsapss_sign_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
inline_for_extraction noextract
let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length
let rsapss_sign_pre a modBits sLen salt msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 /\
msgLen `less_than_max_input_length` a
val rsapss_sign_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let eq_m_s, sgnt_s = S.rsapss_sign_ a modBits skeys sLen salt msgLen msg in
eq_m_s == eq_m /\ sgnt == sgnt_s)
val rsapss_sign_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> eq_m:bool
-> sgnt:lseq uint8 (blocks modBits 8) -> Type0
let rsapss_sign_post1 #t a modBits eBits dBits skey sLen salt msgLen msg eq_m sgnt =
rsapss_skey_pre modBits eBits dBits skey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = bn_v (sub skey 0 nLen) in
let e = bn_v (sub skey (nLen + nLen) eLen) in
let d = bn_v (sub skey (nLen + nLen + eLen) dLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
let skeys : S.rsapss_skey modBits = S.Mk_rsapss_skey pkeys d in
let sgnt_s = S.rsapss_sign a modBits skeys sLen salt msgLen msg in
if eq_m then Some? sgnt_s /\ sgnt == Some?.v sgnt_s else None? sgnt_s)
val rsapss_verify_pre:
a:Hash.hash_alg{S.hash_is_supported a}
-> sLen:size_nat //saltLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Type0
let rsapss_verify_pre a sLen msgLen msg =
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `less_than_max_input_length` a /\
msgLen `less_than_max_input_length` a
val rsapss_verify_post:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> sgnt:lseq uint8 (blocks modBits 8)
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post #t a modBits eBits pkey sLen sgnt msgLen msg verify =
rsapss_verify_pre a sLen msgLen msg /\
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify_ a modBits pkeys sLen sgnt msgLen msg)
val rsapss_verify_post1:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat{pkey_len_pre t modBits eBits}
-> pkey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t))
-> sLen:size_nat //saltLen
-> k:size_nat
-> sgnt:lseq uint8 k
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen}
-> verify:bool -> Type0
let rsapss_verify_post1 #t a modBits eBits pkey sLen k sgnt msgLen msg verify =
rsapss_pkey_pre modBits eBits pkey /\
(let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let n = bn_v (sub pkey 0 nLen) in
let e = bn_v (sub pkey (nLen + nLen) eLen) in
let pkeys : S.rsapss_pkey modBits = S.Mk_rsapss_pkey n e in
verify == S.rsapss_verify a modBits pkeys sLen k sgnt msgLen msg)
val rsapss_sign_bn:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lbignum t (blocks modBits (bits t))))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_bn #t modBits eBits dBits skey m =
let bits = bits t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
let s = map (logand eq_m) s in
BB.unsafe_bool_of_limb eq_m, s
val rsapss_sign_msg_to_bn:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat{1 < modBits}
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (lbignum t (blocks modBits (bits t)))
(requires rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> bn_v res < pow2 (modBits - 1))
let rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be #t emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
m
val rsapss_sign_compute_sgnt:
#t:limb_t
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> m:lbignum t (blocks modBits (bits t)) ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
(let nLen = blocks modBits (bits t) in
let n = sub skey 0 nLen in
rsapss_skey_pre modBits eBits dBits skey /\
bn_v m < bn_v n))
(ensures fun res -> True)
let rsapss_sign_compute_sgnt #t modBits eBits dBits skey m =
let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let k = blocks modBits 8 in
let eq_b, s = rsapss_sign_bn #t modBits eBits dBits skey m in
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
let sgnt = bn_to_bytes_be k s in
eq_b, sgnt
val rsapss_sign_:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} ->
Pure (tuple2 bool (lseq uint8 (blocks modBits 8)))
(requires
rsapss_skey_pre modBits eBits dBits skey /\
rsapss_sign_pre a modBits sLen salt msgLen msg)
(ensures fun res -> True)
let rsapss_sign_ #t a modBits eBits dBits skey sLen salt msgLen msg =
let m = rsapss_sign_msg_to_bn #t a modBits sLen salt msgLen msg in
rsapss_sign_compute_sgnt #t modBits eBits dBits skey m
val rsapss_sign_lemma:
#t:limb_t
-> a:Hash.hash_alg{S.hash_is_supported a}
-> modBits:size_nat
-> eBits:size_nat
-> dBits:size_nat{skey_len_pre t modBits eBits dBits}
-> skey:lbignum t (2 * blocks modBits (bits t) + blocks eBits (bits t) + blocks dBits (bits t))
-> sLen:size_nat
-> salt:lseq uint8 sLen
-> msgLen:nat
-> msg:seq uint8{length msg == msgLen} -> Lemma
(requires
rsapss_sign_pre a modBits sLen salt msgLen msg /\
rsapss_skey_pre modBits eBits dBits skey)
(ensures
(let eq_m, s = rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg in
rsapss_sign_post a modBits eBits dBits skey sLen salt msgLen msg eq_m s)) | {
"checked_file": "/",
"dependencies": [
"Spec.RSAPSS.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Exponentiation.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.UInt32.fsti.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.RSAPSS.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "SM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Spec.RSAPSS",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat ->
dBits: Lib.IntTypes.size_nat{Hacl.Spec.RSAPSS.skey_len_pre t modBits eBits dBits} ->
skey:
Hacl.Spec.Bignum.Definitions.lbignum t
(2 * Hacl.Spec.Bignum.Definitions.blocks modBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks eBits (Lib.IntTypes.bits t) +
Hacl.Spec.Bignum.Definitions.blocks dBits (Lib.IntTypes.bits t)) ->
sLen: Lib.IntTypes.size_nat ->
salt: Lib.Sequence.lseq Lib.IntTypes.uint8 sLen ->
msgLen: Prims.nat ->
msg: Lib.Sequence.seq Lib.IntTypes.uint8 {Lib.Sequence.length msg == msgLen}
-> FStar.Pervasives.Lemma
(requires
Hacl.Spec.RSAPSS.rsapss_sign_pre a modBits sLen salt msgLen msg /\
Hacl.Spec.RSAPSS.rsapss_skey_pre modBits eBits dBits skey)
(ensures
(let _ = Hacl.Spec.RSAPSS.rsapss_sign_ a modBits eBits dBits skey sLen salt msgLen msg in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ eq_m s = _ in
Hacl.Spec.RSAPSS.rsapss_sign_post a modBits eBits dBits skey sLen salt msgLen msg eq_m s
)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Lib.IntTypes.size_nat",
"Hacl.Spec.RSAPSS.skey_len_pre",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.bits",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Prims.nat",
"Lib.Sequence.seq",
"Prims.eq2",
"Lib.Sequence.length",
"Hacl.Spec.Bignum.bn_to_bytes_be_lemma",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Hacl.Spec.Bignum.bn_to_bytes_be",
"Prims.unit",
"Prims._assert",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.pow2",
"FStar.Math.Lemmas.pow2_le_compat",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.max_size_t",
"Lib.IntTypes.size_pos",
"Prims.l_or",
"Hacl.Spec.RSAPSS.blocks_numb_lemma",
"Hacl.Spec.RSAPSS.blocks_bits_lemma",
"Hacl.Spec.Bignum.Definitions.bn_mask_lemma",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.l_Forall",
"Prims.l_imp",
"Lib.Sequence.index",
"Lib.IntTypes.logand",
"Lib.Sequence.map",
"Hacl.Spec.Bignum.bn_eq_mask_lemma",
"Hacl.Spec.Bignum.bn_eq_mask",
"Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_vartime_precompr2",
"Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_consttime_precompr2",
"Hacl.Spec.Bignum.Montgomery.bn_precomp_r2_mod_n_lemma",
"Prims.op_Subtraction",
"Spec.RSAPSS.os2ip_lemma",
"Hacl.Spec.Bignum.bn_from_bytes_be_lemma",
"Lib.IntTypes.numbytes",
"Hacl.Spec.Bignum.Definitions.bn_eval_update_sub",
"Prims.l_and",
"Lib.Sequence.sub",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.update_sub",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Lib.Sequence.create",
"Lib.IntTypes.uint",
"Hacl.Spec.Bignum.bn_from_bytes_be",
"Spec.RSAPSS.blocks",
"Spec.RSAPSS.pss_encode",
"Prims.pos",
"Prims.op_Multiply",
"Prims.int",
"FStar.Seq.Base.slice"
] | [] | true | false | true | false | false | let rsapss_sign_lemma #t a modBits eBits dBits skey sLen salt msgLen msg =
| let bits = bits t in
let numb = numbytes t in
let nLen = blocks modBits bits in
let eLen = blocks eBits bits in
let dLen = blocks dBits bits in
let n = sub skey 0 nLen in
let r2 = sub skey nLen nLen in
let e = sub skey (nLen + nLen) eLen in
let d = sub skey (nLen + nLen + eLen) dLen in
let k = blocks modBits 8 in
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = S.pss_encode a sLen salt msgLen msg emBits in
blocks_bits_lemma t emBits;
blocks_numb_lemma t emBits;
assert (blocks emLen numb == blocks emBits bits);
assert (numb * blocks emLen numb <= max_size_t);
let emNat = bn_from_bytes_be emLen em in
let m = create nLen (uint #t 0) in
let m = update_sub m 0 (blocks emLen numb) emNat in
bn_eval_update_sub (blocks emLen numb) emNat nLen;
assert (bn_v m == bn_v emNat);
bn_from_bytes_be_lemma #t emLen em;
S.os2ip_lemma emBits em;
assert (bn_v m < bn_v n);
Math.Lemmas.pow2_le_compat (bits * nLen) modBits;
SM.bn_precomp_r2_mod_n_lemma (modBits - 1) n;
let s = bn_mod_exp_consttime_precompr2 nLen n r2 m dBits d in
let m' = bn_mod_exp_vartime_precompr2 nLen n r2 s eBits e in
let eq_m = bn_eq_mask m m' in
bn_eq_mask_lemma m m';
let s' = map (logand eq_m) s in
bn_mask_lemma s eq_m;
blocks_bits_lemma t modBits;
blocks_numb_lemma t modBits;
assert (blocks k numb == nLen);
assert (numb * blocks k numb <= max_size_t);
Math.Lemmas.pow2_le_compat (8 * k) modBits;
assert (bn_v s' < pow2 (8 * k));
let sgnt = bn_to_bytes_be k s' in
bn_to_bytes_be_lemma k s' | false |
Steel.ST.MonotonicReference.fst | Steel.ST.MonotonicReference.witness' | val witness':
#inames: _ ->
#a: Type ->
#q: perm ->
#p: Preorder.preorder a ->
r: erased (ref a p) ->
fact: stable_property p ->
v: erased a ->
pf: squash (fact v) ->
unit
-> Steel.Effect.Atomic.SteelAtomicUT (witnessed r fact)
inames
(pts_to r q v)
(fun _ -> pts_to r q v) | val witness':
#inames: _ ->
#a: Type ->
#q: perm ->
#p: Preorder.preorder a ->
r: erased (ref a p) ->
fact: stable_property p ->
v: erased a ->
pf: squash (fact v) ->
unit
-> Steel.Effect.Atomic.SteelAtomicUT (witnessed r fact)
inames
(pts_to r q v)
(fun _ -> pts_to r q v) | let witness' (#inames: _)
(#a:Type)
(#q:perm)
(#p:Preorder.preorder a)
(r:erased (ref a p))
(fact:stable_property p)
(v:erased a)
(pf:squash (fact v))
(_:unit)
: Steel.Effect.Atomic.SteelAtomicUT (witnessed r fact) inames
(pts_to r q v)
(fun _ -> pts_to r q v)
= MR.witness #inames #a #q #p r fact v pf | {
"file_name": "lib/steel/Steel.ST.MonotonicReference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 43,
"end_line": 69,
"start_col": 0,
"start_line": 57
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.ST.MonotonicReference
open FStar.Ghost
open Steel.ST.Util
open Steel.ST.Coercions
module Preorder = FStar.Preorder
module MR = Steel.MonotonicReference
let ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0
= MR.ref a p
let pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
([@@@smt_fallback]f:perm)
([@@@smt_fallback]v:a)
: vprop
= MR.pts_to #a #p r f v
let alloc (#a:Type) (p:Preorder.preorder a) (v:a)
: STT (ref a p) emp (fun r -> pts_to r full_perm v)
= let x = coerce_steel (fun _ -> MR.alloc p v) in
return x
let write (#a:Type) (#p:Preorder.preorder a) (#v:erased a)
(r:ref a p) (x:a)
: ST unit
(pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires p v x)
(ensures fun _ -> True)
= coerce_steel (fun _ -> MR.write r x)
let witnessed (#a:Type u#0)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:property a)
: Type0
= MR.witnessed r fact | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Coercions.fsti.checked",
"Steel.MonotonicReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.MonotonicReference.fst"
} | [
{
"abbrev": true,
"full_module": "Steel.MonotonicReference",
"short_module": "MR"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Coercions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
r: FStar.Ghost.erased (Steel.ST.MonotonicReference.ref a p) ->
fact: Steel.ST.MonotonicReference.stable_property p ->
v: FStar.Ghost.erased a ->
pf: Prims.squash (fact (FStar.Ghost.reveal v)) ->
_: Prims.unit
-> Steel.Effect.Atomic.SteelAtomicUT
(Steel.ST.MonotonicReference.witnessed (FStar.Ghost.reveal r) fact) | Steel.Effect.Atomic.SteelAtomicUT | [] | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"FStar.Preorder.preorder",
"FStar.Ghost.erased",
"Steel.ST.MonotonicReference.ref",
"Steel.ST.MonotonicReference.stable_property",
"Prims.squash",
"FStar.Ghost.reveal",
"Prims.unit",
"Steel.MonotonicReference.witness",
"Steel.MonotonicReference.witnessed",
"Steel.MonotonicReference.ref",
"Steel.ST.MonotonicReference.witnessed",
"Steel.ST.MonotonicReference.pts_to",
"Steel.Effect.Common.vprop"
] | [] | false | true | false | false | false | let witness'
(#inames: _)
(#a: Type)
(#q: perm)
(#p: Preorder.preorder a)
(r: erased (ref a p))
(fact: stable_property p)
(v: erased a)
(pf: squash (fact v))
(_: unit)
: Steel.Effect.Atomic.SteelAtomicUT (witnessed r fact)
inames
(pts_to r q v)
(fun _ -> pts_to r q v) =
| MR.witness #inames #a #q #p r fact v pf | false |
LowParse.Low.BitSum.fst | LowParse.Low.BitSum.validate_bitsum_cases_bitstop | val validate_bitsum_cases_bitstop (#tot: pos) (#t: eqtype) (cl: uint_t tot t)
: Tot (validate_bitsum_cases_t u#r #tot #t #cl #0 (BitStop ())) | val validate_bitsum_cases_bitstop (#tot: pos) (#t: eqtype) (cl: uint_t tot t)
: Tot (validate_bitsum_cases_t u#r #tot #t #cl #0 (BitStop ())) | let validate_bitsum_cases_bitstop
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
: Tot (validate_bitsum_cases_t u#r #tot #t #cl #0 (BitStop ()))
= fun u f v x #rrel #rel sl pos ->
v () sl pos | {
"file_name": "src/lowparse/LowParse.Low.BitSum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 13,
"end_line": 56,
"start_col": 0,
"start_line": 50
} | module LowParse.Low.BitSum
include LowParse.Low.Combinators
include LowParse.Spec.BitSum
module U32 = FStar.UInt32
module HS = FStar.HyperStack
#push-options "--z3rlimit 16"
inline_for_extraction
let validate_bitsum'
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#k: parser_kind)
(#p: parser k t)
(v: validator p)
(r: leaf_reader p)
(phi: filter_bitsum'_t b)
: Tot (validator (parse_bitsum' b p))
= synth_bitsum'_injective b;
validate_synth
(validate_filter
v
r
(filter_bitsum' b)
(fun x -> phi x))
(synth_bitsum' b)
()
module HST = FStar.HyperStack.ST
inline_for_extraction
noextract
let validate_bitsum_cases_t
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(#from: nat)
(b: bitsum' cl from)
: Tot (Type u#(r+1))
= (u: (bitsum'_key_type b -> Tot (Type u#r))) ->
(f: ((x: bitsum'_key_type b) -> Tot (k: parser_kind & parser k (u x)))) ->
(v: ((x: bitsum'_key_type b) -> Tot (validator (dsnd (f x))))) ->
(x: parse_filter_refine (filter_bitsum' b)) ->
Tot (validator (dsnd (f (bitsum'_key_of_t b (synth_bitsum' b x))))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.BitSum.fst.checked",
"LowParse.Low.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.BitSum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.BitSum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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
}
] | {
"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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | cl: LowParse.BitFields.uint_t tot t
-> LowParse.Low.BitSum.validate_bitsum_cases_t (LowParse.Spec.BitSum.BitStop ()) | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"Prims.eqtype",
"LowParse.BitFields.uint_t",
"LowParse.Spec.BitSum.bitsum'_key_type",
"LowParse.Spec.BitSum.BitStop",
"Prims.dtuple2",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.validator",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.BitSum.filter_bitsum'",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt64.t",
"LowParse.Low.BitSum.validate_bitsum_cases_t"
] | [] | false | false | false | false | false | let validate_bitsum_cases_bitstop (#tot: pos) (#t: eqtype) (cl: uint_t tot t)
: Tot (validate_bitsum_cases_t u#r #tot #t #cl #0 (BitStop ())) =
| fun u f v x #rrel #rel sl pos -> v () sl pos | false |
LowParse.Low.BitSum.fst | LowParse.Low.BitSum.validate_bitsum_cases_bitfield | val validate_bitsum_cases_bitfield
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(sz: nat{sz > 0 /\ sz <= bitsum'_size /\ bitsum'_size <= tot})
(rest: bitsum' cl (bitsum'_size - sz))
(phi: validate_bitsum_cases_t u#r rest)
: Tot (validate_bitsum_cases_t u#r (BitField sz rest)) | val validate_bitsum_cases_bitfield
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(sz: nat{sz > 0 /\ sz <= bitsum'_size /\ bitsum'_size <= tot})
(rest: bitsum' cl (bitsum'_size - sz))
(phi: validate_bitsum_cases_t u#r rest)
: Tot (validate_bitsum_cases_t u#r (BitField sz rest)) | let validate_bitsum_cases_bitfield
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(sz: nat { sz > 0 /\ sz <= bitsum'_size /\ bitsum'_size <= tot })
(rest: bitsum' cl (bitsum'_size - sz))
(phi: validate_bitsum_cases_t u#r rest)
: Tot (validate_bitsum_cases_t u#r (BitField sz rest))
= fun u f v x #rrel #rel sl pos ->
phi
(fun x -> u (coerce (bitsum'_key_type (BitField sz rest)) x))
(fun x -> f (coerce (bitsum'_key_type (BitField sz rest)) x))
(fun x -> v (coerce (bitsum'_key_type (BitField sz rest)) x))
x
sl
pos | {
"file_name": "src/lowparse/LowParse.Low.BitSum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 7,
"end_line": 75,
"start_col": 0,
"start_line": 59
} | module LowParse.Low.BitSum
include LowParse.Low.Combinators
include LowParse.Spec.BitSum
module U32 = FStar.UInt32
module HS = FStar.HyperStack
#push-options "--z3rlimit 16"
inline_for_extraction
let validate_bitsum'
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#k: parser_kind)
(#p: parser k t)
(v: validator p)
(r: leaf_reader p)
(phi: filter_bitsum'_t b)
: Tot (validator (parse_bitsum' b p))
= synth_bitsum'_injective b;
validate_synth
(validate_filter
v
r
(filter_bitsum' b)
(fun x -> phi x))
(synth_bitsum' b)
()
module HST = FStar.HyperStack.ST
inline_for_extraction
noextract
let validate_bitsum_cases_t
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(#from: nat)
(b: bitsum' cl from)
: Tot (Type u#(r+1))
= (u: (bitsum'_key_type b -> Tot (Type u#r))) ->
(f: ((x: bitsum'_key_type b) -> Tot (k: parser_kind & parser k (u x)))) ->
(v: ((x: bitsum'_key_type b) -> Tot (validator (dsnd (f x))))) ->
(x: parse_filter_refine (filter_bitsum' b)) ->
Tot (validator (dsnd (f (bitsum'_key_of_t b (synth_bitsum' b x)))))
inline_for_extraction
let validate_bitsum_cases_bitstop
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
: Tot (validate_bitsum_cases_t u#r #tot #t #cl #0 (BitStop ()))
= fun u f v x #rrel #rel sl pos ->
v () sl pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.BitSum.fst.checked",
"LowParse.Low.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.BitSum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.BitSum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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
}
] | {
"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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
cl: LowParse.BitFields.uint_t tot t ->
bitsum'_size: Prims.nat ->
sz: Prims.nat{sz > 0 /\ sz <= bitsum'_size /\ bitsum'_size <= tot} ->
rest: LowParse.Spec.BitSum.bitsum' cl (bitsum'_size - sz) ->
phi: LowParse.Low.BitSum.validate_bitsum_cases_t rest
-> LowParse.Low.BitSum.validate_bitsum_cases_t (LowParse.Spec.BitSum.BitField sz rest) | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"Prims.eqtype",
"LowParse.BitFields.uint_t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"LowParse.Spec.BitSum.bitsum'",
"Prims.op_Subtraction",
"LowParse.Low.BitSum.validate_bitsum_cases_t",
"LowParse.Spec.BitSum.bitsum'_key_type",
"LowParse.Spec.BitSum.BitField",
"Prims.dtuple2",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.validator",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.BitSum.filter_bitsum'",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt64.t",
"LowParse.Spec.BitSum.coerce"
] | [] | false | false | false | false | false | let validate_bitsum_cases_bitfield
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(sz: nat{sz > 0 /\ sz <= bitsum'_size /\ bitsum'_size <= tot})
(rest: bitsum' cl (bitsum'_size - sz))
(phi: validate_bitsum_cases_t u#r rest)
: Tot (validate_bitsum_cases_t u#r (BitField sz rest)) =
| fun u f v x #rrel #rel sl pos ->
phi (fun x -> u (coerce (bitsum'_key_type (BitField sz rest)) x))
(fun x -> f (coerce (bitsum'_key_type (BitField sz rest)) x))
(fun x -> v (coerce (bitsum'_key_type (BitField sz rest)) x))
x
sl
pos | false |
LowParse.Low.BitSum.fst | LowParse.Low.BitSum.validate_bitsum' | val validate_bitsum'
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#k: parser_kind)
(#p: parser k t)
(v: validator p)
(r: leaf_reader p)
(phi: filter_bitsum'_t b)
: Tot (validator (parse_bitsum' b p)) | val validate_bitsum'
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#k: parser_kind)
(#p: parser k t)
(v: validator p)
(r: leaf_reader p)
(phi: filter_bitsum'_t b)
: Tot (validator (parse_bitsum' b p)) | let validate_bitsum'
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#k: parser_kind)
(#p: parser k t)
(v: validator p)
(r: leaf_reader p)
(phi: filter_bitsum'_t b)
: Tot (validator (parse_bitsum' b p))
= synth_bitsum'_injective b;
validate_synth
(validate_filter
v
r
(filter_bitsum' b)
(fun x -> phi x))
(synth_bitsum' b)
() | {
"file_name": "src/lowparse/LowParse.Low.BitSum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 6,
"end_line": 30,
"start_col": 0,
"start_line": 11
} | module LowParse.Low.BitSum
include LowParse.Low.Combinators
include LowParse.Spec.BitSum
module U32 = FStar.UInt32
module HS = FStar.HyperStack
#push-options "--z3rlimit 16" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.BitSum.fst.checked",
"LowParse.Low.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.BitSum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.BitSum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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
}
] | {
"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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: LowParse.Spec.BitSum.bitsum' cl tot ->
v: LowParse.Low.Base.validator p ->
r: LowParse.Low.Base.leaf_reader p ->
phi: LowParse.Spec.BitSum.filter_bitsum'_t b
-> LowParse.Low.Base.validator (LowParse.Spec.BitSum.parse_bitsum' b p) | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"Prims.eqtype",
"LowParse.BitFields.uint_t",
"LowParse.Spec.BitSum.bitsum'",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.validator",
"LowParse.Low.Base.leaf_reader",
"LowParse.Spec.BitSum.filter_bitsum'_t",
"LowParse.Low.Combinators.validate_synth",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.BitSum.filter_bitsum'",
"LowParse.Spec.BitSum.bitsum'_type",
"LowParse.Spec.Combinators.parse_filter",
"LowParse.Low.Combinators.validate_filter",
"Prims.bool",
"Prims.eq2",
"LowParse.Spec.BitSum.synth_bitsum'",
"Prims.unit",
"LowParse.Spec.BitSum.synth_bitsum'_injective",
"LowParse.Spec.BitSum.parse_bitsum'"
] | [] | false | false | false | false | false | let validate_bitsum'
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#k: parser_kind)
(#p: parser k t)
(v: validator p)
(r: leaf_reader p)
(phi: filter_bitsum'_t b)
: Tot (validator (parse_bitsum' b p)) =
| synth_bitsum'_injective b;
validate_synth (validate_filter v r (filter_bitsum' b) (fun x -> phi x)) (synth_bitsum' b) () | false |
LowParse.Low.BitSum.fst | LowParse.Low.BitSum.validate_bitsum_cases_bitsum'_t | val validate_bitsum_cases_bitsum'_t
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat{key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot})
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(l2: list (key & bitfield cl key_size) {e == l1 `L.append` l2})
: Tot (Type u#(r + 1)) | val validate_bitsum_cases_bitsum'_t
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat{key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot})
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(l2: list (key & bitfield cl key_size) {e == l1 `L.append` l2})
: Tot (Type u#(r + 1)) | let validate_bitsum_cases_bitsum'_t
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(l2: list (key & bitfield cl key_size) { e == l1 `L.append` l2 } )
: Tot (Type u#(r+1))
= (u: (bitsum'_key_type (BitSum' key key_size e payload) -> Tot (Type u#r))) ->
(f: ((x: bitsum'_key_type (BitSum' key key_size e payload)) -> Tot (k: parser_kind & parser k (u x)))) ->
(v: ((x: bitsum'_key_type (BitSum' key key_size e payload)) -> Tot (validator (dsnd (f x))))) ->
(x: parse_filter_refine (filter_bitsum' (BitSum' key key_size e payload)) { ~ (list_mem (cl.get_bitfield x (bitsum'_size - key_size) bitsum'_size <: bitfield cl key_size) (list_map snd l1)) }) ->
(xr: t { xr == cl.bitfield_eq_lhs x (bitsum'_size - key_size) bitsum'_size }) ->
Tot (validator (dsnd (f (bitsum'_key_of_t (BitSum' key key_size e payload) (synth_bitsum' (BitSum' key key_size e payload) x))))) | {
"file_name": "src/lowparse/LowParse.Low.BitSum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 131,
"end_line": 123,
"start_col": 0,
"start_line": 106
} | module LowParse.Low.BitSum
include LowParse.Low.Combinators
include LowParse.Spec.BitSum
module U32 = FStar.UInt32
module HS = FStar.HyperStack
#push-options "--z3rlimit 16"
inline_for_extraction
let validate_bitsum'
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#k: parser_kind)
(#p: parser k t)
(v: validator p)
(r: leaf_reader p)
(phi: filter_bitsum'_t b)
: Tot (validator (parse_bitsum' b p))
= synth_bitsum'_injective b;
validate_synth
(validate_filter
v
r
(filter_bitsum' b)
(fun x -> phi x))
(synth_bitsum' b)
()
module HST = FStar.HyperStack.ST
inline_for_extraction
noextract
let validate_bitsum_cases_t
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(#from: nat)
(b: bitsum' cl from)
: Tot (Type u#(r+1))
= (u: (bitsum'_key_type b -> Tot (Type u#r))) ->
(f: ((x: bitsum'_key_type b) -> Tot (k: parser_kind & parser k (u x)))) ->
(v: ((x: bitsum'_key_type b) -> Tot (validator (dsnd (f x))))) ->
(x: parse_filter_refine (filter_bitsum' b)) ->
Tot (validator (dsnd (f (bitsum'_key_of_t b (synth_bitsum' b x)))))
inline_for_extraction
let validate_bitsum_cases_bitstop
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
: Tot (validate_bitsum_cases_t u#r #tot #t #cl #0 (BitStop ()))
= fun u f v x #rrel #rel sl pos ->
v () sl pos
inline_for_extraction
let validate_bitsum_cases_bitfield
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(sz: nat { sz > 0 /\ sz <= bitsum'_size /\ bitsum'_size <= tot })
(rest: bitsum' cl (bitsum'_size - sz))
(phi: validate_bitsum_cases_t u#r rest)
: Tot (validate_bitsum_cases_t u#r (BitField sz rest))
= fun u f v x #rrel #rel sl pos ->
phi
(fun x -> u (coerce (bitsum'_key_type (BitField sz rest)) x))
(fun x -> f (coerce (bitsum'_key_type (BitField sz rest)) x))
(fun x -> v (coerce (bitsum'_key_type (BitField sz rest)) x))
x
sl
pos
inline_for_extraction
let validate_bitsum_cases_bitsum_gen
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(key_of: ((x: enum_repr e) -> Tot (y: enum_key e { y == enum_key_of_repr e x })))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(destr_payload: ((k: enum_key e) -> Tot (validate_bitsum_cases_t u#r (payload k))))
: Tot (validate_bitsum_cases_t u#r (BitSum' key key_size e payload))
= fun u f v x_ #rrel #rel sl pos ->
[@inline_let]
let r = cl.get_bitfield x_ (bitsum'_size - key_size) bitsum'_size in
[@inline_let]
let k = key_of r in
destr_payload
k
(fun x -> u (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> f (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> v (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
x_ sl pos
module L = FStar.List.Tot
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.BitSum.fst.checked",
"LowParse.Low.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.BitSum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.BitSum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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
}
] | {
"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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
cl: LowParse.BitFields.uint_t tot t ->
bitsum'_size: Prims.nat ->
key: Prims.eqtype ->
key_size: Prims.nat{key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot} ->
e: LowParse.Spec.Enum.enum key (LowParse.BitFields.bitfield cl key_size) ->
payload:
(_: LowParse.Spec.Enum.enum_key e -> LowParse.Spec.BitSum.bitsum' cl (bitsum'_size - key_size)
) ->
l1: Prims.list (key * LowParse.BitFields.bitfield cl key_size) ->
l2: Prims.list (key * LowParse.BitFields.bitfield cl key_size) {e == l1 @ l2}
-> Type | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"Prims.eqtype",
"LowParse.BitFields.uint_t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"LowParse.Spec.Enum.enum",
"LowParse.BitFields.bitfield",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.BitSum.bitsum'",
"Prims.op_Subtraction",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.eq2",
"FStar.List.Tot.Base.append",
"LowParse.Spec.BitSum.bitsum'_key_type",
"LowParse.Spec.BitSum.BitSum'",
"Prims.dtuple2",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.validator",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.BitSum.filter_bitsum'",
"Prims.l_not",
"LowParse.Spec.Enum.list_mem",
"LowParse.BitFields.__proj__Mkuint_t__item__get_bitfield",
"LowParse.Spec.Enum.list_map",
"FStar.Pervasives.Native.snd",
"LowParse.BitFields.__proj__Mkuint_t__item__bitfield_eq_lhs",
"LowParse.Spec.BitSum.bitsum'_key_of_t",
"LowParse.Spec.BitSum.synth_bitsum'"
] | [] | false | false | false | false | true | let validate_bitsum_cases_bitsum'_t
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat{key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot})
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(l2: list (key & bitfield cl key_size) {e == l1 `L.append` l2})
: Tot (Type u#(r + 1)) =
|
u: (bitsum'_key_type (BitSum' key key_size e payload) -> Tot (Type u#r)) ->
f:
(x: bitsum'_key_type (BitSum' key key_size e payload) -> Tot (k: parser_kind & parser k (u x))
) ->
v: (x: bitsum'_key_type (BitSum' key key_size e payload) -> Tot (validator (dsnd (f x)))) ->
x:
parse_filter_refine (filter_bitsum' (BitSum' key key_size e payload))
{ ~(list_mem (cl.get_bitfield x (bitsum'_size - key_size) bitsum'_size
<:
bitfield cl key_size)
(list_map snd l1)) } ->
xr: t{xr == cl.bitfield_eq_lhs x (bitsum'_size - key_size) bitsum'_size}
-> Tot
(validator (dsnd (f (bitsum'_key_of_t (BitSum' key key_size e payload)
(synth_bitsum' (BitSum' key key_size e payload) x))))) | false |
LowParse.Low.BitSum.fst | LowParse.Low.BitSum.validate_bitsum_cases_bitsum'_intro | val validate_bitsum_cases_bitsum'_intro
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat{key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot})
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(phi: validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload [] e)
: Tot (validate_bitsum_cases_t u#r (BitSum' key key_size e payload)) | val validate_bitsum_cases_bitsum'_intro
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat{key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot})
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(phi: validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload [] e)
: Tot (validate_bitsum_cases_t u#r (BitSum' key key_size e payload)) | let validate_bitsum_cases_bitsum'_intro
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(phi: validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload [] e)
: Tot (validate_bitsum_cases_t u#r (BitSum' key key_size e payload))
= fun u f v x #rrel #rel sl pos ->
let xr = cl.bitfield_eq_lhs x (bitsum'_size - key_size) bitsum'_size in
phi u f v x xr sl pos | {
"file_name": "src/lowparse/LowParse.Low.BitSum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 25,
"end_line": 139,
"start_col": 0,
"start_line": 126
} | module LowParse.Low.BitSum
include LowParse.Low.Combinators
include LowParse.Spec.BitSum
module U32 = FStar.UInt32
module HS = FStar.HyperStack
#push-options "--z3rlimit 16"
inline_for_extraction
let validate_bitsum'
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#k: parser_kind)
(#p: parser k t)
(v: validator p)
(r: leaf_reader p)
(phi: filter_bitsum'_t b)
: Tot (validator (parse_bitsum' b p))
= synth_bitsum'_injective b;
validate_synth
(validate_filter
v
r
(filter_bitsum' b)
(fun x -> phi x))
(synth_bitsum' b)
()
module HST = FStar.HyperStack.ST
inline_for_extraction
noextract
let validate_bitsum_cases_t
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(#from: nat)
(b: bitsum' cl from)
: Tot (Type u#(r+1))
= (u: (bitsum'_key_type b -> Tot (Type u#r))) ->
(f: ((x: bitsum'_key_type b) -> Tot (k: parser_kind & parser k (u x)))) ->
(v: ((x: bitsum'_key_type b) -> Tot (validator (dsnd (f x))))) ->
(x: parse_filter_refine (filter_bitsum' b)) ->
Tot (validator (dsnd (f (bitsum'_key_of_t b (synth_bitsum' b x)))))
inline_for_extraction
let validate_bitsum_cases_bitstop
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
: Tot (validate_bitsum_cases_t u#r #tot #t #cl #0 (BitStop ()))
= fun u f v x #rrel #rel sl pos ->
v () sl pos
inline_for_extraction
let validate_bitsum_cases_bitfield
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(sz: nat { sz > 0 /\ sz <= bitsum'_size /\ bitsum'_size <= tot })
(rest: bitsum' cl (bitsum'_size - sz))
(phi: validate_bitsum_cases_t u#r rest)
: Tot (validate_bitsum_cases_t u#r (BitField sz rest))
= fun u f v x #rrel #rel sl pos ->
phi
(fun x -> u (coerce (bitsum'_key_type (BitField sz rest)) x))
(fun x -> f (coerce (bitsum'_key_type (BitField sz rest)) x))
(fun x -> v (coerce (bitsum'_key_type (BitField sz rest)) x))
x
sl
pos
inline_for_extraction
let validate_bitsum_cases_bitsum_gen
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(key_of: ((x: enum_repr e) -> Tot (y: enum_key e { y == enum_key_of_repr e x })))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(destr_payload: ((k: enum_key e) -> Tot (validate_bitsum_cases_t u#r (payload k))))
: Tot (validate_bitsum_cases_t u#r (BitSum' key key_size e payload))
= fun u f v x_ #rrel #rel sl pos ->
[@inline_let]
let r = cl.get_bitfield x_ (bitsum'_size - key_size) bitsum'_size in
[@inline_let]
let k = key_of r in
destr_payload
k
(fun x -> u (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> f (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> v (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
x_ sl pos
module L = FStar.List.Tot
inline_for_extraction
noextract
let validate_bitsum_cases_bitsum'_t
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(l2: list (key & bitfield cl key_size) { e == l1 `L.append` l2 } )
: Tot (Type u#(r+1))
= (u: (bitsum'_key_type (BitSum' key key_size e payload) -> Tot (Type u#r))) ->
(f: ((x: bitsum'_key_type (BitSum' key key_size e payload)) -> Tot (k: parser_kind & parser k (u x)))) ->
(v: ((x: bitsum'_key_type (BitSum' key key_size e payload)) -> Tot (validator (dsnd (f x))))) ->
(x: parse_filter_refine (filter_bitsum' (BitSum' key key_size e payload)) { ~ (list_mem (cl.get_bitfield x (bitsum'_size - key_size) bitsum'_size <: bitfield cl key_size) (list_map snd l1)) }) ->
(xr: t { xr == cl.bitfield_eq_lhs x (bitsum'_size - key_size) bitsum'_size }) ->
Tot (validator (dsnd (f (bitsum'_key_of_t (BitSum' key key_size e payload) (synth_bitsum' (BitSum' key key_size e payload) x))))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.BitSum.fst.checked",
"LowParse.Low.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.BitSum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.BitSum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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
}
] | {
"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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
cl: LowParse.BitFields.uint_t tot t ->
bitsum'_size: Prims.nat ->
key: Prims.eqtype ->
key_size: Prims.nat{key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot} ->
e: LowParse.Spec.Enum.enum key (LowParse.BitFields.bitfield cl key_size) ->
payload:
(_: LowParse.Spec.Enum.enum_key e -> LowParse.Spec.BitSum.bitsum' cl (bitsum'_size - key_size)
) ->
phi:
LowParse.Low.BitSum.validate_bitsum_cases_bitsum'_t cl
bitsum'_size
key
key_size
e
payload
[]
e
-> LowParse.Low.BitSum.validate_bitsum_cases_t (LowParse.Spec.BitSum.BitSum' key
key_size
e
payload) | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"Prims.eqtype",
"LowParse.BitFields.uint_t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"LowParse.Spec.Enum.enum",
"LowParse.BitFields.bitfield",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.BitSum.bitsum'",
"Prims.op_Subtraction",
"LowParse.Low.BitSum.validate_bitsum_cases_bitsum'_t",
"Prims.Nil",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.BitSum.bitsum'_key_type",
"LowParse.Spec.BitSum.BitSum'",
"Prims.dtuple2",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.validator",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.BitSum.filter_bitsum'",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt64.t",
"LowParse.BitFields.__proj__Mkuint_t__item__bitfield_eq_lhs",
"LowParse.Low.BitSum.validate_bitsum_cases_t"
] | [] | false | false | false | false | false | let validate_bitsum_cases_bitsum'_intro
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat{key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot})
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(phi: validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload [] e)
: Tot (validate_bitsum_cases_t u#r (BitSum' key key_size e payload)) =
| fun u f v x #rrel #rel sl pos ->
let xr = cl.bitfield_eq_lhs x (bitsum'_size - key_size) bitsum'_size in
phi u f v x xr sl pos | false |
LowParse.Low.BitSum.fst | LowParse.Low.BitSum.validate_bitsum_cases_bitsum'_nil | val validate_bitsum_cases_bitsum'_nil
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat{key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot})
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(h: squash (e == e `L.append` []))
: Tot (validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload e []) | val validate_bitsum_cases_bitsum'_nil
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat{key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot})
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(h: squash (e == e `L.append` []))
: Tot (validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload e []) | let validate_bitsum_cases_bitsum'_nil
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(h: squash (e == e `L.append` []))
: Tot (validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload e [])
= (fun u f v x xr #rrel #rel sl pos ->
assert False;
validator_error_generic (* dummy *)) | {
"file_name": "src/lowparse/LowParse.Low.BitSum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 40,
"end_line": 155,
"start_col": 0,
"start_line": 142
} | module LowParse.Low.BitSum
include LowParse.Low.Combinators
include LowParse.Spec.BitSum
module U32 = FStar.UInt32
module HS = FStar.HyperStack
#push-options "--z3rlimit 16"
inline_for_extraction
let validate_bitsum'
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#k: parser_kind)
(#p: parser k t)
(v: validator p)
(r: leaf_reader p)
(phi: filter_bitsum'_t b)
: Tot (validator (parse_bitsum' b p))
= synth_bitsum'_injective b;
validate_synth
(validate_filter
v
r
(filter_bitsum' b)
(fun x -> phi x))
(synth_bitsum' b)
()
module HST = FStar.HyperStack.ST
inline_for_extraction
noextract
let validate_bitsum_cases_t
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(#from: nat)
(b: bitsum' cl from)
: Tot (Type u#(r+1))
= (u: (bitsum'_key_type b -> Tot (Type u#r))) ->
(f: ((x: bitsum'_key_type b) -> Tot (k: parser_kind & parser k (u x)))) ->
(v: ((x: bitsum'_key_type b) -> Tot (validator (dsnd (f x))))) ->
(x: parse_filter_refine (filter_bitsum' b)) ->
Tot (validator (dsnd (f (bitsum'_key_of_t b (synth_bitsum' b x)))))
inline_for_extraction
let validate_bitsum_cases_bitstop
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
: Tot (validate_bitsum_cases_t u#r #tot #t #cl #0 (BitStop ()))
= fun u f v x #rrel #rel sl pos ->
v () sl pos
inline_for_extraction
let validate_bitsum_cases_bitfield
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(sz: nat { sz > 0 /\ sz <= bitsum'_size /\ bitsum'_size <= tot })
(rest: bitsum' cl (bitsum'_size - sz))
(phi: validate_bitsum_cases_t u#r rest)
: Tot (validate_bitsum_cases_t u#r (BitField sz rest))
= fun u f v x #rrel #rel sl pos ->
phi
(fun x -> u (coerce (bitsum'_key_type (BitField sz rest)) x))
(fun x -> f (coerce (bitsum'_key_type (BitField sz rest)) x))
(fun x -> v (coerce (bitsum'_key_type (BitField sz rest)) x))
x
sl
pos
inline_for_extraction
let validate_bitsum_cases_bitsum_gen
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(key_of: ((x: enum_repr e) -> Tot (y: enum_key e { y == enum_key_of_repr e x })))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(destr_payload: ((k: enum_key e) -> Tot (validate_bitsum_cases_t u#r (payload k))))
: Tot (validate_bitsum_cases_t u#r (BitSum' key key_size e payload))
= fun u f v x_ #rrel #rel sl pos ->
[@inline_let]
let r = cl.get_bitfield x_ (bitsum'_size - key_size) bitsum'_size in
[@inline_let]
let k = key_of r in
destr_payload
k
(fun x -> u (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> f (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> v (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
x_ sl pos
module L = FStar.List.Tot
inline_for_extraction
noextract
let validate_bitsum_cases_bitsum'_t
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(l2: list (key & bitfield cl key_size) { e == l1 `L.append` l2 } )
: Tot (Type u#(r+1))
= (u: (bitsum'_key_type (BitSum' key key_size e payload) -> Tot (Type u#r))) ->
(f: ((x: bitsum'_key_type (BitSum' key key_size e payload)) -> Tot (k: parser_kind & parser k (u x)))) ->
(v: ((x: bitsum'_key_type (BitSum' key key_size e payload)) -> Tot (validator (dsnd (f x))))) ->
(x: parse_filter_refine (filter_bitsum' (BitSum' key key_size e payload)) { ~ (list_mem (cl.get_bitfield x (bitsum'_size - key_size) bitsum'_size <: bitfield cl key_size) (list_map snd l1)) }) ->
(xr: t { xr == cl.bitfield_eq_lhs x (bitsum'_size - key_size) bitsum'_size }) ->
Tot (validator (dsnd (f (bitsum'_key_of_t (BitSum' key key_size e payload) (synth_bitsum' (BitSum' key key_size e payload) x)))))
inline_for_extraction
let validate_bitsum_cases_bitsum'_intro
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(phi: validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload [] e)
: Tot (validate_bitsum_cases_t u#r (BitSum' key key_size e payload))
= fun u f v x #rrel #rel sl pos ->
let xr = cl.bitfield_eq_lhs x (bitsum'_size - key_size) bitsum'_size in
phi u f v x xr sl pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.BitSum.fst.checked",
"LowParse.Low.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.BitSum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.BitSum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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
}
] | {
"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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
cl: LowParse.BitFields.uint_t tot t ->
bitsum'_size: Prims.nat ->
key: Prims.eqtype ->
key_size: Prims.nat{key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot} ->
e: LowParse.Spec.Enum.enum key (LowParse.BitFields.bitfield cl key_size) ->
payload:
(_: LowParse.Spec.Enum.enum_key e -> LowParse.Spec.BitSum.bitsum' cl (bitsum'_size - key_size)
) ->
h: Prims.squash (e == e @ [])
-> LowParse.Low.BitSum.validate_bitsum_cases_bitsum'_t cl bitsum'_size key key_size e payload e [] | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"Prims.eqtype",
"LowParse.BitFields.uint_t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"LowParse.Spec.Enum.enum",
"LowParse.BitFields.bitfield",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.BitSum.bitsum'",
"Prims.op_Subtraction",
"Prims.squash",
"Prims.eq2",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"FStar.List.Tot.Base.append",
"Prims.Nil",
"LowParse.Spec.BitSum.bitsum'_key_type",
"LowParse.Spec.BitSum.BitSum'",
"Prims.dtuple2",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.validator",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.BitSum.filter_bitsum'",
"Prims.l_not",
"LowParse.Spec.Enum.list_mem",
"LowParse.BitFields.__proj__Mkuint_t__item__get_bitfield",
"LowParse.Spec.Enum.list_map",
"FStar.Pervasives.Native.snd",
"LowParse.BitFields.__proj__Mkuint_t__item__bitfield_eq_lhs",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt64.t",
"LowParse.Low.ErrorCode.validator_error_generic",
"Prims.unit",
"Prims._assert",
"Prims.l_False",
"LowParse.Low.BitSum.validate_bitsum_cases_bitsum'_t"
] | [] | false | false | false | false | false | let validate_bitsum_cases_bitsum'_nil
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat{key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot})
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(h: squash (e == e `L.append` []))
: Tot (validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload e []) =
| (fun u f v x xr #rrel #rel sl pos ->
assert False;
validator_error_generic) | false |
LowParse.Low.BitSum.fst | LowParse.Low.BitSum.mk_validate_bitsum_cases_t' | val mk_validate_bitsum_cases_t'
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(#bitsum'_size: nat)
(b: bitsum' cl bitsum'_size)
: Tot (validate_bitsum_cases_t u#r b) (decreases b) | val mk_validate_bitsum_cases_t'
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(#bitsum'_size: nat)
(b: bitsum' cl bitsum'_size)
: Tot (validate_bitsum_cases_t u#r b) (decreases b) | let rec mk_validate_bitsum_cases_t'
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(#bitsum'_size: nat)
(b: bitsum' cl bitsum'_size)
: Tot (validate_bitsum_cases_t u#r b)
(decreases b)
= match b with
| BitStop _ -> validate_bitsum_cases_bitstop cl
| BitField sz rest -> validate_bitsum_cases_bitfield cl bitsum'_size sz rest (mk_validate_bitsum_cases_t' rest)
| BitSum' key key_size e payload ->
validate_bitsum_cases_bitsum'_intro cl bitsum'_size key key_size e payload (mk_validate_bitsum_cases_bitsum'_t' cl bitsum'_size key key_size e payload [] e (mk_validate_bitsum_cases_t' #tot #t #cl #(bitsum'_size - key_size))) | {
"file_name": "src/lowparse/LowParse.Low.BitSum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 229,
"end_line": 258,
"start_col": 0,
"start_line": 246
} | module LowParse.Low.BitSum
include LowParse.Low.Combinators
include LowParse.Spec.BitSum
module U32 = FStar.UInt32
module HS = FStar.HyperStack
#push-options "--z3rlimit 16"
inline_for_extraction
let validate_bitsum'
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#k: parser_kind)
(#p: parser k t)
(v: validator p)
(r: leaf_reader p)
(phi: filter_bitsum'_t b)
: Tot (validator (parse_bitsum' b p))
= synth_bitsum'_injective b;
validate_synth
(validate_filter
v
r
(filter_bitsum' b)
(fun x -> phi x))
(synth_bitsum' b)
()
module HST = FStar.HyperStack.ST
inline_for_extraction
noextract
let validate_bitsum_cases_t
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(#from: nat)
(b: bitsum' cl from)
: Tot (Type u#(r+1))
= (u: (bitsum'_key_type b -> Tot (Type u#r))) ->
(f: ((x: bitsum'_key_type b) -> Tot (k: parser_kind & parser k (u x)))) ->
(v: ((x: bitsum'_key_type b) -> Tot (validator (dsnd (f x))))) ->
(x: parse_filter_refine (filter_bitsum' b)) ->
Tot (validator (dsnd (f (bitsum'_key_of_t b (synth_bitsum' b x)))))
inline_for_extraction
let validate_bitsum_cases_bitstop
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
: Tot (validate_bitsum_cases_t u#r #tot #t #cl #0 (BitStop ()))
= fun u f v x #rrel #rel sl pos ->
v () sl pos
inline_for_extraction
let validate_bitsum_cases_bitfield
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(sz: nat { sz > 0 /\ sz <= bitsum'_size /\ bitsum'_size <= tot })
(rest: bitsum' cl (bitsum'_size - sz))
(phi: validate_bitsum_cases_t u#r rest)
: Tot (validate_bitsum_cases_t u#r (BitField sz rest))
= fun u f v x #rrel #rel sl pos ->
phi
(fun x -> u (coerce (bitsum'_key_type (BitField sz rest)) x))
(fun x -> f (coerce (bitsum'_key_type (BitField sz rest)) x))
(fun x -> v (coerce (bitsum'_key_type (BitField sz rest)) x))
x
sl
pos
inline_for_extraction
let validate_bitsum_cases_bitsum_gen
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(key_of: ((x: enum_repr e) -> Tot (y: enum_key e { y == enum_key_of_repr e x })))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(destr_payload: ((k: enum_key e) -> Tot (validate_bitsum_cases_t u#r (payload k))))
: Tot (validate_bitsum_cases_t u#r (BitSum' key key_size e payload))
= fun u f v x_ #rrel #rel sl pos ->
[@inline_let]
let r = cl.get_bitfield x_ (bitsum'_size - key_size) bitsum'_size in
[@inline_let]
let k = key_of r in
destr_payload
k
(fun x -> u (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> f (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> v (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
x_ sl pos
module L = FStar.List.Tot
inline_for_extraction
noextract
let validate_bitsum_cases_bitsum'_t
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(l2: list (key & bitfield cl key_size) { e == l1 `L.append` l2 } )
: Tot (Type u#(r+1))
= (u: (bitsum'_key_type (BitSum' key key_size e payload) -> Tot (Type u#r))) ->
(f: ((x: bitsum'_key_type (BitSum' key key_size e payload)) -> Tot (k: parser_kind & parser k (u x)))) ->
(v: ((x: bitsum'_key_type (BitSum' key key_size e payload)) -> Tot (validator (dsnd (f x))))) ->
(x: parse_filter_refine (filter_bitsum' (BitSum' key key_size e payload)) { ~ (list_mem (cl.get_bitfield x (bitsum'_size - key_size) bitsum'_size <: bitfield cl key_size) (list_map snd l1)) }) ->
(xr: t { xr == cl.bitfield_eq_lhs x (bitsum'_size - key_size) bitsum'_size }) ->
Tot (validator (dsnd (f (bitsum'_key_of_t (BitSum' key key_size e payload) (synth_bitsum' (BitSum' key key_size e payload) x)))))
inline_for_extraction
let validate_bitsum_cases_bitsum'_intro
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(phi: validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload [] e)
: Tot (validate_bitsum_cases_t u#r (BitSum' key key_size e payload))
= fun u f v x #rrel #rel sl pos ->
let xr = cl.bitfield_eq_lhs x (bitsum'_size - key_size) bitsum'_size in
phi u f v x xr sl pos
inline_for_extraction
let validate_bitsum_cases_bitsum'_nil
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(h: squash (e == e `L.append` []))
: Tot (validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload e [])
= (fun u f v x xr #rrel #rel sl pos ->
assert False;
validator_error_generic (* dummy *))
#push-options "--z3rlimit 32"
inline_for_extraction
let validate_bitsum_cases_bitsum'_cons
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(k: key)
(r: bitfield cl key_size)
(l2: list (key & bitfield cl key_size) {
e == l1 `L.append` ((k, r) :: l2) /\
list_mem k (list_map fst e) /\
enum_repr_of_key e k == r /\
e == (l1 `L.append` [(k, r)]) `L.append` l2
})
(destr_payload: validate_bitsum_cases_t u#r (payload k))
(destr_tail: validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload (l1 `L.append` [(k, r)]) l2)
: Tot (validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload l1 ((k, r) :: l2))
= fun u f v x xr #rrel #rel sl pos ->
// [@inline_let]
let _ =
enum_repr_of_key_append_cons e l1 (k, r) l2
in
[@inline_let] let yr = cl.bitfield_eq_rhs x (bitsum'_size - key_size) bitsum'_size r in
[@inline_let] let cond = (xr <: t) = yr in
[@inline_let] let _ =
assert (cond == true <==> (cl.get_bitfield x (bitsum'_size - key_size) bitsum'_size <: bitfield cl key_size) == r)
in
if cond
then
destr_payload
(fun x -> u (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> f (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> v (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
x sl pos
else
[@inline_let] let _ =
L.append_assoc l1 [(k, r)] l2;
L.map_append snd l1 [(k, r)];
L.append_mem (L.map snd l1) (L.map snd [(k, r)]) (cl.get_bitfield x (bitsum'_size - key_size) bitsum'_size <: bitfield cl key_size)
in
destr_tail u f v (x <: t) xr sl pos
[@filter_bitsum'_t_attr]
noextract
let rec mk_validate_bitsum_cases_bitsum'_t'
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(l2: list (key & bitfield cl key_size) { e == l1 `L.append` l2 } )
(mk_validate_bitsum_cases_t':
(* universe-polymorphic mutually recursive functions must be "split off"
cf. https://github.com/FStarLang/FStar/issues/1480#issuecomment-623260544
*)
(b: bitsum' cl (bitsum'_size - key_size) { b << BitSum' key key_size e payload }) ->
Tot (validate_bitsum_cases_t u#r b)
)
: Tot (validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload l1 l2)
(decreases %[BitSum' key key_size e payload; l2])
= bitsum_wellfoundedness (BitSum' key key_size e payload);
match l2 with
| [] ->
[@inline_let] let _ =
L.append_l_nil l1
in
validate_bitsum_cases_bitsum'_nil cl bitsum'_size key key_size e payload ()
| (k, r) :: q ->
[@inline_let] let _ =
enum_repr_of_key_append_cons e l1 (k, r) q;
L.append_assoc l1 [(k, r)] q
in
validate_bitsum_cases_bitsum'_cons cl bitsum'_size key key_size e payload l1 k r q
(mk_validate_bitsum_cases_t' (payload k))
(mk_validate_bitsum_cases_bitsum'_t' cl bitsum'_size key key_size e payload (l1 `L.append` [(k, r)]) q mk_validate_bitsum_cases_t')
[@filter_bitsum'_t_attr] | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.BitSum.fst.checked",
"LowParse.Low.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.BitSum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.BitSum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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
}
] | {
"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": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b: LowParse.Spec.BitSum.bitsum' cl bitsum'_size
-> Prims.Tot (LowParse.Low.BitSum.validate_bitsum_cases_t b) | Prims.Tot | [
"total",
""
] | [] | [
"Prims.pos",
"Prims.eqtype",
"LowParse.BitFields.uint_t",
"Prims.nat",
"LowParse.Spec.BitSum.bitsum'",
"Prims.squash",
"Prims.eq2",
"Prims.int",
"LowParse.Low.BitSum.validate_bitsum_cases_bitstop",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"LowParse.Low.BitSum.validate_bitsum_cases_bitfield",
"LowParse.Low.BitSum.mk_validate_bitsum_cases_t'",
"LowParse.Spec.Enum.enum",
"LowParse.BitFields.bitfield",
"LowParse.Spec.Enum.enum_key",
"LowParse.Low.BitSum.validate_bitsum_cases_bitsum'_intro",
"LowParse.Low.BitSum.mk_validate_bitsum_cases_bitsum'_t'",
"Prims.Nil",
"FStar.Pervasives.Native.tuple2",
"LowParse.Low.BitSum.validate_bitsum_cases_t"
] | [
"recursion"
] | false | false | false | false | false | let rec mk_validate_bitsum_cases_t'
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(#bitsum'_size: nat)
(b: bitsum' cl bitsum'_size)
: Tot (validate_bitsum_cases_t u#r b) (decreases b) =
| match b with
| BitStop _ -> validate_bitsum_cases_bitstop cl
| BitField sz rest ->
validate_bitsum_cases_bitfield cl bitsum'_size sz rest (mk_validate_bitsum_cases_t' rest)
| BitSum' key key_size e payload ->
validate_bitsum_cases_bitsum'_intro cl
bitsum'_size
key
key_size
e
payload
(mk_validate_bitsum_cases_bitsum'_t' cl
bitsum'_size
key
key_size
e
payload
[]
e
(mk_validate_bitsum_cases_t' #tot #t #cl #(bitsum'_size - key_size))) | false |
Steel.ST.MonotonicReference.fst | Steel.ST.MonotonicReference.alloc | val alloc (#a:Type) (p:Preorder.preorder a) (v:a)
: STT (ref a p) emp (fun r -> pts_to r full_perm v) | val alloc (#a:Type) (p:Preorder.preorder a) (v:a)
: STT (ref a p) emp (fun r -> pts_to r full_perm v) | let alloc (#a:Type) (p:Preorder.preorder a) (v:a)
: STT (ref a p) emp (fun r -> pts_to r full_perm v)
= let x = coerce_steel (fun _ -> MR.alloc p v) in
return x | {
"file_name": "lib/steel/Steel.ST.MonotonicReference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 12,
"end_line": 39,
"start_col": 0,
"start_line": 36
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.ST.MonotonicReference
open FStar.Ghost
open Steel.ST.Util
open Steel.ST.Coercions
module Preorder = FStar.Preorder
module MR = Steel.MonotonicReference
let ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0
= MR.ref a p
let pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
([@@@smt_fallback]f:perm)
([@@@smt_fallback]v:a)
: vprop
= MR.pts_to #a #p r f v | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Coercions.fsti.checked",
"Steel.MonotonicReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.MonotonicReference.fst"
} | [
{
"abbrev": true,
"full_module": "Steel.MonotonicReference",
"short_module": "MR"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Coercions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p: FStar.Preorder.preorder a -> v: a -> Steel.ST.Effect.STT (Steel.ST.MonotonicReference.ref a p) | Steel.ST.Effect.STT | [] | [] | [
"FStar.Preorder.preorder",
"Steel.ST.Util.return",
"Steel.ST.MonotonicReference.ref",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.ST.MonotonicReference.pts_to",
"Steel.FractionalPermission.full_perm",
"Steel.Effect.Common.vprop",
"Steel.MonotonicReference.ref",
"Steel.ST.Coercions.coerce_steel",
"Steel.Effect.Common.emp",
"Steel.Effect.Common.VUnit",
"Steel.Effect.Common.to_vprop'",
"Steel.MonotonicReference.pts_to_sl",
"Prims.l_True",
"Prims.unit",
"Steel.MonotonicReference.alloc"
] | [] | false | true | false | false | false | let alloc (#a: Type) (p: Preorder.preorder a) (v: a)
: STT (ref a p) emp (fun r -> pts_to r full_perm v) =
| let x = coerce_steel (fun _ -> MR.alloc p v) in
return x | false |
LowParse.Low.BitSum.fst | LowParse.Low.BitSum.mk_validate_bitsum_cases_bitsum'_t' | val mk_validate_bitsum_cases_bitsum'_t'
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat{key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot})
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(l2: list (key & bitfield cl key_size) {e == l1 `L.append` l2})
(mk_validate_bitsum_cases_t':
(b: bitsum' cl (bitsum'_size - key_size) {b << BitSum' key key_size e payload}
-> Tot (validate_bitsum_cases_t u#r b)))
: Tot (validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload l1 l2)
(decreases %[BitSum' key key_size e payload;l2]) | val mk_validate_bitsum_cases_bitsum'_t'
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat{key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot})
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(l2: list (key & bitfield cl key_size) {e == l1 `L.append` l2})
(mk_validate_bitsum_cases_t':
(b: bitsum' cl (bitsum'_size - key_size) {b << BitSum' key key_size e payload}
-> Tot (validate_bitsum_cases_t u#r b)))
: Tot (validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload l1 l2)
(decreases %[BitSum' key key_size e payload;l2]) | let rec mk_validate_bitsum_cases_bitsum'_t'
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(l2: list (key & bitfield cl key_size) { e == l1 `L.append` l2 } )
(mk_validate_bitsum_cases_t':
(* universe-polymorphic mutually recursive functions must be "split off"
cf. https://github.com/FStarLang/FStar/issues/1480#issuecomment-623260544
*)
(b: bitsum' cl (bitsum'_size - key_size) { b << BitSum' key key_size e payload }) ->
Tot (validate_bitsum_cases_t u#r b)
)
: Tot (validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload l1 l2)
(decreases %[BitSum' key key_size e payload; l2])
= bitsum_wellfoundedness (BitSum' key key_size e payload);
match l2 with
| [] ->
[@inline_let] let _ =
L.append_l_nil l1
in
validate_bitsum_cases_bitsum'_nil cl bitsum'_size key key_size e payload ()
| (k, r) :: q ->
[@inline_let] let _ =
enum_repr_of_key_append_cons e l1 (k, r) q;
L.append_assoc l1 [(k, r)] q
in
validate_bitsum_cases_bitsum'_cons cl bitsum'_size key key_size e payload l1 k r q
(mk_validate_bitsum_cases_t' (payload k))
(mk_validate_bitsum_cases_bitsum'_t' cl bitsum'_size key key_size e payload (l1 `L.append` [(k, r)]) q mk_validate_bitsum_cases_t') | {
"file_name": "src/lowparse/LowParse.Low.BitSum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 137,
"end_line": 242,
"start_col": 0,
"start_line": 208
} | module LowParse.Low.BitSum
include LowParse.Low.Combinators
include LowParse.Spec.BitSum
module U32 = FStar.UInt32
module HS = FStar.HyperStack
#push-options "--z3rlimit 16"
inline_for_extraction
let validate_bitsum'
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#k: parser_kind)
(#p: parser k t)
(v: validator p)
(r: leaf_reader p)
(phi: filter_bitsum'_t b)
: Tot (validator (parse_bitsum' b p))
= synth_bitsum'_injective b;
validate_synth
(validate_filter
v
r
(filter_bitsum' b)
(fun x -> phi x))
(synth_bitsum' b)
()
module HST = FStar.HyperStack.ST
inline_for_extraction
noextract
let validate_bitsum_cases_t
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(#from: nat)
(b: bitsum' cl from)
: Tot (Type u#(r+1))
= (u: (bitsum'_key_type b -> Tot (Type u#r))) ->
(f: ((x: bitsum'_key_type b) -> Tot (k: parser_kind & parser k (u x)))) ->
(v: ((x: bitsum'_key_type b) -> Tot (validator (dsnd (f x))))) ->
(x: parse_filter_refine (filter_bitsum' b)) ->
Tot (validator (dsnd (f (bitsum'_key_of_t b (synth_bitsum' b x)))))
inline_for_extraction
let validate_bitsum_cases_bitstop
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
: Tot (validate_bitsum_cases_t u#r #tot #t #cl #0 (BitStop ()))
= fun u f v x #rrel #rel sl pos ->
v () sl pos
inline_for_extraction
let validate_bitsum_cases_bitfield
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(sz: nat { sz > 0 /\ sz <= bitsum'_size /\ bitsum'_size <= tot })
(rest: bitsum' cl (bitsum'_size - sz))
(phi: validate_bitsum_cases_t u#r rest)
: Tot (validate_bitsum_cases_t u#r (BitField sz rest))
= fun u f v x #rrel #rel sl pos ->
phi
(fun x -> u (coerce (bitsum'_key_type (BitField sz rest)) x))
(fun x -> f (coerce (bitsum'_key_type (BitField sz rest)) x))
(fun x -> v (coerce (bitsum'_key_type (BitField sz rest)) x))
x
sl
pos
inline_for_extraction
let validate_bitsum_cases_bitsum_gen
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(key_of: ((x: enum_repr e) -> Tot (y: enum_key e { y == enum_key_of_repr e x })))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(destr_payload: ((k: enum_key e) -> Tot (validate_bitsum_cases_t u#r (payload k))))
: Tot (validate_bitsum_cases_t u#r (BitSum' key key_size e payload))
= fun u f v x_ #rrel #rel sl pos ->
[@inline_let]
let r = cl.get_bitfield x_ (bitsum'_size - key_size) bitsum'_size in
[@inline_let]
let k = key_of r in
destr_payload
k
(fun x -> u (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> f (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> v (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
x_ sl pos
module L = FStar.List.Tot
inline_for_extraction
noextract
let validate_bitsum_cases_bitsum'_t
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(l2: list (key & bitfield cl key_size) { e == l1 `L.append` l2 } )
: Tot (Type u#(r+1))
= (u: (bitsum'_key_type (BitSum' key key_size e payload) -> Tot (Type u#r))) ->
(f: ((x: bitsum'_key_type (BitSum' key key_size e payload)) -> Tot (k: parser_kind & parser k (u x)))) ->
(v: ((x: bitsum'_key_type (BitSum' key key_size e payload)) -> Tot (validator (dsnd (f x))))) ->
(x: parse_filter_refine (filter_bitsum' (BitSum' key key_size e payload)) { ~ (list_mem (cl.get_bitfield x (bitsum'_size - key_size) bitsum'_size <: bitfield cl key_size) (list_map snd l1)) }) ->
(xr: t { xr == cl.bitfield_eq_lhs x (bitsum'_size - key_size) bitsum'_size }) ->
Tot (validator (dsnd (f (bitsum'_key_of_t (BitSum' key key_size e payload) (synth_bitsum' (BitSum' key key_size e payload) x)))))
inline_for_extraction
let validate_bitsum_cases_bitsum'_intro
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(phi: validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload [] e)
: Tot (validate_bitsum_cases_t u#r (BitSum' key key_size e payload))
= fun u f v x #rrel #rel sl pos ->
let xr = cl.bitfield_eq_lhs x (bitsum'_size - key_size) bitsum'_size in
phi u f v x xr sl pos
inline_for_extraction
let validate_bitsum_cases_bitsum'_nil
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(h: squash (e == e `L.append` []))
: Tot (validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload e [])
= (fun u f v x xr #rrel #rel sl pos ->
assert False;
validator_error_generic (* dummy *))
#push-options "--z3rlimit 32"
inline_for_extraction
let validate_bitsum_cases_bitsum'_cons
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(k: key)
(r: bitfield cl key_size)
(l2: list (key & bitfield cl key_size) {
e == l1 `L.append` ((k, r) :: l2) /\
list_mem k (list_map fst e) /\
enum_repr_of_key e k == r /\
e == (l1 `L.append` [(k, r)]) `L.append` l2
})
(destr_payload: validate_bitsum_cases_t u#r (payload k))
(destr_tail: validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload (l1 `L.append` [(k, r)]) l2)
: Tot (validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload l1 ((k, r) :: l2))
= fun u f v x xr #rrel #rel sl pos ->
// [@inline_let]
let _ =
enum_repr_of_key_append_cons e l1 (k, r) l2
in
[@inline_let] let yr = cl.bitfield_eq_rhs x (bitsum'_size - key_size) bitsum'_size r in
[@inline_let] let cond = (xr <: t) = yr in
[@inline_let] let _ =
assert (cond == true <==> (cl.get_bitfield x (bitsum'_size - key_size) bitsum'_size <: bitfield cl key_size) == r)
in
if cond
then
destr_payload
(fun x -> u (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> f (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> v (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
x sl pos
else
[@inline_let] let _ =
L.append_assoc l1 [(k, r)] l2;
L.map_append snd l1 [(k, r)];
L.append_mem (L.map snd l1) (L.map snd [(k, r)]) (cl.get_bitfield x (bitsum'_size - key_size) bitsum'_size <: bitfield cl key_size)
in
destr_tail u f v (x <: t) xr sl pos
[@filter_bitsum'_t_attr] | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.BitSum.fst.checked",
"LowParse.Low.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.BitSum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.BitSum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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
}
] | {
"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": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
cl: LowParse.BitFields.uint_t tot t ->
bitsum'_size: Prims.nat ->
key: Prims.eqtype ->
key_size: Prims.nat{key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot} ->
e: LowParse.Spec.Enum.enum key (LowParse.BitFields.bitfield cl key_size) ->
payload:
(_: LowParse.Spec.Enum.enum_key e -> LowParse.Spec.BitSum.bitsum' cl (bitsum'_size - key_size)
) ->
l1: Prims.list (key * LowParse.BitFields.bitfield cl key_size) ->
l2: Prims.list (key * LowParse.BitFields.bitfield cl key_size) {e == l1 @ l2} ->
mk_validate_bitsum_cases_t':
(
b:
LowParse.Spec.BitSum.bitsum' cl (bitsum'_size - key_size)
{b << LowParse.Spec.BitSum.BitSum' key key_size e payload}
-> LowParse.Low.BitSum.validate_bitsum_cases_t b)
-> Prims.Tot
(LowParse.Low.BitSum.validate_bitsum_cases_bitsum'_t cl
bitsum'_size
key
key_size
e
payload
l1
l2) | Prims.Tot | [
"total",
""
] | [] | [
"Prims.pos",
"Prims.eqtype",
"LowParse.BitFields.uint_t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"LowParse.Spec.Enum.enum",
"LowParse.BitFields.bitfield",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.BitSum.bitsum'",
"Prims.op_Subtraction",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.eq2",
"FStar.List.Tot.Base.append",
"Prims.precedes",
"LowParse.Spec.BitSum.BitSum'",
"LowParse.Low.BitSum.validate_bitsum_cases_t",
"LowParse.Low.BitSum.validate_bitsum_cases_bitsum'_nil",
"Prims.unit",
"FStar.List.Tot.Properties.append_l_nil",
"LowParse.Low.BitSum.validate_bitsum_cases_bitsum'_cons",
"LowParse.Low.BitSum.mk_validate_bitsum_cases_bitsum'_t'",
"Prims.Cons",
"FStar.Pervasives.Native.Mktuple2",
"Prims.Nil",
"FStar.List.Tot.Properties.append_assoc",
"LowParse.Spec.Enum.enum_repr_of_key_append_cons",
"LowParse.Low.BitSum.validate_bitsum_cases_bitsum'_t",
"LowParse.Spec.BitSum.bitsum_wellfoundedness"
] | [
"recursion"
] | false | false | false | false | false | let rec mk_validate_bitsum_cases_bitsum'_t'
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat{key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot})
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(l2: list (key & bitfield cl key_size) {e == l1 `L.append` l2})
(mk_validate_bitsum_cases_t':
(b: bitsum' cl (bitsum'_size - key_size) {b << BitSum' key key_size e payload}
-> Tot (validate_bitsum_cases_t u#r b)))
: Tot (validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload l1 l2)
(decreases %[BitSum' key key_size e payload;l2]) =
| bitsum_wellfoundedness (BitSum' key key_size e payload);
match l2 with
| [] ->
[@@ inline_let ]let _ = L.append_l_nil l1 in
validate_bitsum_cases_bitsum'_nil cl bitsum'_size key key_size e payload ()
| (k, r) :: q ->
[@@ inline_let ]let _ =
enum_repr_of_key_append_cons e l1 (k, r) q;
L.append_assoc l1 [(k, r)] q
in
validate_bitsum_cases_bitsum'_cons cl bitsum'_size key key_size e payload l1 k r q
(mk_validate_bitsum_cases_t' (payload k))
(mk_validate_bitsum_cases_bitsum'_t' cl
bitsum'_size
key
key_size
e
payload
(l1 `L.append` [(k, r)])
q
mk_validate_bitsum_cases_t') | false |
LowParse.Low.BitSum.fst | LowParse.Low.BitSum.validate_bitsum_cases_bitsum_gen | val validate_bitsum_cases_bitsum_gen
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat{key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot})
(e: enum key (bitfield cl key_size))
(key_of: (x: enum_repr e -> Tot (y: enum_key e {y == enum_key_of_repr e x})))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(destr_payload: (k: enum_key e -> Tot (validate_bitsum_cases_t u#r (payload k))))
: Tot (validate_bitsum_cases_t u#r (BitSum' key key_size e payload)) | val validate_bitsum_cases_bitsum_gen
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat{key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot})
(e: enum key (bitfield cl key_size))
(key_of: (x: enum_repr e -> Tot (y: enum_key e {y == enum_key_of_repr e x})))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(destr_payload: (k: enum_key e -> Tot (validate_bitsum_cases_t u#r (payload k))))
: Tot (validate_bitsum_cases_t u#r (BitSum' key key_size e payload)) | let validate_bitsum_cases_bitsum_gen
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(key_of: ((x: enum_repr e) -> Tot (y: enum_key e { y == enum_key_of_repr e x })))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(destr_payload: ((k: enum_key e) -> Tot (validate_bitsum_cases_t u#r (payload k))))
: Tot (validate_bitsum_cases_t u#r (BitSum' key key_size e payload))
= fun u f v x_ #rrel #rel sl pos ->
[@inline_let]
let r = cl.get_bitfield x_ (bitsum'_size - key_size) bitsum'_size in
[@inline_let]
let k = key_of r in
destr_payload
k
(fun x -> u (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> f (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> v (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
x_ sl pos | {
"file_name": "src/lowparse/LowParse.Low.BitSum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 17,
"end_line": 100,
"start_col": 0,
"start_line": 78
} | module LowParse.Low.BitSum
include LowParse.Low.Combinators
include LowParse.Spec.BitSum
module U32 = FStar.UInt32
module HS = FStar.HyperStack
#push-options "--z3rlimit 16"
inline_for_extraction
let validate_bitsum'
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#k: parser_kind)
(#p: parser k t)
(v: validator p)
(r: leaf_reader p)
(phi: filter_bitsum'_t b)
: Tot (validator (parse_bitsum' b p))
= synth_bitsum'_injective b;
validate_synth
(validate_filter
v
r
(filter_bitsum' b)
(fun x -> phi x))
(synth_bitsum' b)
()
module HST = FStar.HyperStack.ST
inline_for_extraction
noextract
let validate_bitsum_cases_t
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(#from: nat)
(b: bitsum' cl from)
: Tot (Type u#(r+1))
= (u: (bitsum'_key_type b -> Tot (Type u#r))) ->
(f: ((x: bitsum'_key_type b) -> Tot (k: parser_kind & parser k (u x)))) ->
(v: ((x: bitsum'_key_type b) -> Tot (validator (dsnd (f x))))) ->
(x: parse_filter_refine (filter_bitsum' b)) ->
Tot (validator (dsnd (f (bitsum'_key_of_t b (synth_bitsum' b x)))))
inline_for_extraction
let validate_bitsum_cases_bitstop
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
: Tot (validate_bitsum_cases_t u#r #tot #t #cl #0 (BitStop ()))
= fun u f v x #rrel #rel sl pos ->
v () sl pos
inline_for_extraction
let validate_bitsum_cases_bitfield
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(sz: nat { sz > 0 /\ sz <= bitsum'_size /\ bitsum'_size <= tot })
(rest: bitsum' cl (bitsum'_size - sz))
(phi: validate_bitsum_cases_t u#r rest)
: Tot (validate_bitsum_cases_t u#r (BitField sz rest))
= fun u f v x #rrel #rel sl pos ->
phi
(fun x -> u (coerce (bitsum'_key_type (BitField sz rest)) x))
(fun x -> f (coerce (bitsum'_key_type (BitField sz rest)) x))
(fun x -> v (coerce (bitsum'_key_type (BitField sz rest)) x))
x
sl
pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.BitSum.fst.checked",
"LowParse.Low.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.BitSum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.BitSum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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
}
] | {
"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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
cl: LowParse.BitFields.uint_t tot t ->
bitsum'_size: Prims.nat ->
key: Prims.eqtype ->
key_size: Prims.nat{key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot} ->
e: LowParse.Spec.Enum.enum key (LowParse.BitFields.bitfield cl key_size) ->
key_of:
(x: LowParse.Spec.Enum.enum_repr e
-> y: LowParse.Spec.Enum.enum_key e {y == LowParse.Spec.Enum.enum_key_of_repr e x}) ->
payload:
(_: LowParse.Spec.Enum.enum_key e -> LowParse.Spec.BitSum.bitsum' cl (bitsum'_size - key_size)
) ->
destr_payload:
(k: LowParse.Spec.Enum.enum_key e -> LowParse.Low.BitSum.validate_bitsum_cases_t (payload k))
-> LowParse.Low.BitSum.validate_bitsum_cases_t (LowParse.Spec.BitSum.BitSum' key
key_size
e
payload) | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"Prims.eqtype",
"LowParse.BitFields.uint_t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"LowParse.Spec.Enum.enum",
"LowParse.BitFields.bitfield",
"LowParse.Spec.Enum.enum_repr",
"LowParse.Spec.Enum.enum_key",
"Prims.eq2",
"LowParse.Spec.Enum.enum_key_of_repr",
"LowParse.Spec.BitSum.bitsum'",
"Prims.op_Subtraction",
"LowParse.Low.BitSum.validate_bitsum_cases_t",
"LowParse.Spec.BitSum.bitsum'_key_type",
"LowParse.Spec.BitSum.BitSum'",
"Prims.dtuple2",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.validator",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.BitSum.filter_bitsum'",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt64.t",
"LowParse.Spec.BitSum.bitsum'_key_type_intro_BitSum'",
"Prims.Mkdtuple2",
"FStar.UInt.uint_t",
"LowParse.BitFields.__proj__Mkuint_t__item__v",
"LowParse.BitFields.get_bitfield",
"LowParse.BitFields.__proj__Mkuint_t__item__get_bitfield"
] | [] | false | false | false | false | false | let validate_bitsum_cases_bitsum_gen
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat{key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot})
(e: enum key (bitfield cl key_size))
(key_of: (x: enum_repr e -> Tot (y: enum_key e {y == enum_key_of_repr e x})))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(destr_payload: (k: enum_key e -> Tot (validate_bitsum_cases_t u#r (payload k))))
: Tot (validate_bitsum_cases_t u#r (BitSum' key key_size e payload)) =
| fun u f v x_ #rrel #rel sl pos ->
[@@ inline_let ]let r = cl.get_bitfield x_ (bitsum'_size - key_size) bitsum'_size in
[@@ inline_let ]let k = key_of r in
destr_payload k
(fun x -> u (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> f (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> v (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
x_
sl
pos | false |
LowParse.Low.BitSum.fst | LowParse.Low.BitSum.valid_bitsum_elim | val valid_bitsum_elim
(#kt: parser_kind)
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#data: Type)
(tag_of_data: (data -> Tot (bitsum'_type b)))
(type_of_tag: (bitsum'_key_type b -> Tot Type))
(synth_case: synth_case_t b data tag_of_data type_of_tag)
(p: parser kt t)
(f: (x: bitsum'_key_type b -> Tot (k: parser_kind & parser k (type_of_tag x))))
(h: HS.mem)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos))
(ensures
(valid p h sl pos /\
(let x = contents p h sl pos in
filter_bitsum' b x == true /\
(let tg = synth_bitsum' b x in
let k = bitsum'_key_of_t b tg in
let pos1 = get_valid_pos p h sl pos in
valid (dsnd (f k)) h sl pos1 /\
valid_pos (parse_bitsum b tag_of_data type_of_tag synth_case p f)
h
sl
pos
(get_valid_pos (dsnd (f k)) h sl pos1) /\
(let x = contents (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos in
let y = contents (dsnd (f k)) h sl pos1 in
tg == tag_of_data x /\ x == synth_case.f tg y /\ y == synth_case.g tg x))))) | val valid_bitsum_elim
(#kt: parser_kind)
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#data: Type)
(tag_of_data: (data -> Tot (bitsum'_type b)))
(type_of_tag: (bitsum'_key_type b -> Tot Type))
(synth_case: synth_case_t b data tag_of_data type_of_tag)
(p: parser kt t)
(f: (x: bitsum'_key_type b -> Tot (k: parser_kind & parser k (type_of_tag x))))
(h: HS.mem)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos))
(ensures
(valid p h sl pos /\
(let x = contents p h sl pos in
filter_bitsum' b x == true /\
(let tg = synth_bitsum' b x in
let k = bitsum'_key_of_t b tg in
let pos1 = get_valid_pos p h sl pos in
valid (dsnd (f k)) h sl pos1 /\
valid_pos (parse_bitsum b tag_of_data type_of_tag synth_case p f)
h
sl
pos
(get_valid_pos (dsnd (f k)) h sl pos1) /\
(let x = contents (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos in
let y = contents (dsnd (f k)) h sl pos1 in
tg == tag_of_data x /\ x == synth_case.f tg y /\ y == synth_case.g tg x))))) | let valid_bitsum_elim
(#kt: parser_kind)
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#data: Type)
(tag_of_data: (data -> Tot (bitsum'_type b)))
(type_of_tag: (bitsum'_key_type b -> Tot Type))
(synth_case: synth_case_t b data tag_of_data type_of_tag)
(p: parser kt t)
(f: (x: bitsum'_key_type b) -> Tot (k: parser_kind & parser k (type_of_tag x)))
(h: HS.mem)
(#rrel: _)
(#rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos
))
(ensures (
valid p h sl pos /\ (
let x = contents p h sl pos in
filter_bitsum' b x == true /\ (
let tg = synth_bitsum' b x in
let k = bitsum'_key_of_t b tg in
let pos1 = get_valid_pos p h sl pos in
valid (dsnd (f k)) h sl pos1 /\
valid_pos (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos (get_valid_pos (dsnd (f k)) h sl pos1) /\ (
let x = contents (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos in
let y = contents (dsnd (f k)) h sl pos1 in
tg == tag_of_data x /\
x == synth_case.f tg y /\
y == synth_case.g tg x
)))))
= valid_bitsum_elim' b tag_of_data type_of_tag synth_case p f h sl pos;
synth_bitsum'_injective b;
assert (valid ((p `parse_filter` filter_bitsum' b) `parse_synth` synth_bitsum' b) h sl pos);
valid_synth h (p `parse_filter` filter_bitsum' b) (synth_bitsum' b) sl pos;
valid_filter h p (filter_bitsum' b) sl pos;
let tg = synth_bitsum' b (contents p h sl pos) in
let tg = contents (parse_bitsum' b p) h sl pos in
let k = bitsum'_key_of_t b tg in
let pos1 = get_valid_pos (parse_bitsum' b p) h sl pos in
let x = contents (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos in
let y = contents (dsnd (f k)) h sl pos1 in
assert (tg == tag_of_data x);
assert (x == synth_case.f tg y);
synth_case.f_g_eq tg x;
synth_case.f_inj tg (synth_case.g tg x) y | {
"file_name": "src/lowparse/LowParse.Low.BitSum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 43,
"end_line": 442,
"start_col": 0,
"start_line": 392
} | module LowParse.Low.BitSum
include LowParse.Low.Combinators
include LowParse.Spec.BitSum
module U32 = FStar.UInt32
module HS = FStar.HyperStack
#push-options "--z3rlimit 16"
inline_for_extraction
let validate_bitsum'
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#k: parser_kind)
(#p: parser k t)
(v: validator p)
(r: leaf_reader p)
(phi: filter_bitsum'_t b)
: Tot (validator (parse_bitsum' b p))
= synth_bitsum'_injective b;
validate_synth
(validate_filter
v
r
(filter_bitsum' b)
(fun x -> phi x))
(synth_bitsum' b)
()
module HST = FStar.HyperStack.ST
inline_for_extraction
noextract
let validate_bitsum_cases_t
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(#from: nat)
(b: bitsum' cl from)
: Tot (Type u#(r+1))
= (u: (bitsum'_key_type b -> Tot (Type u#r))) ->
(f: ((x: bitsum'_key_type b) -> Tot (k: parser_kind & parser k (u x)))) ->
(v: ((x: bitsum'_key_type b) -> Tot (validator (dsnd (f x))))) ->
(x: parse_filter_refine (filter_bitsum' b)) ->
Tot (validator (dsnd (f (bitsum'_key_of_t b (synth_bitsum' b x)))))
inline_for_extraction
let validate_bitsum_cases_bitstop
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
: Tot (validate_bitsum_cases_t u#r #tot #t #cl #0 (BitStop ()))
= fun u f v x #rrel #rel sl pos ->
v () sl pos
inline_for_extraction
let validate_bitsum_cases_bitfield
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(sz: nat { sz > 0 /\ sz <= bitsum'_size /\ bitsum'_size <= tot })
(rest: bitsum' cl (bitsum'_size - sz))
(phi: validate_bitsum_cases_t u#r rest)
: Tot (validate_bitsum_cases_t u#r (BitField sz rest))
= fun u f v x #rrel #rel sl pos ->
phi
(fun x -> u (coerce (bitsum'_key_type (BitField sz rest)) x))
(fun x -> f (coerce (bitsum'_key_type (BitField sz rest)) x))
(fun x -> v (coerce (bitsum'_key_type (BitField sz rest)) x))
x
sl
pos
inline_for_extraction
let validate_bitsum_cases_bitsum_gen
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(key_of: ((x: enum_repr e) -> Tot (y: enum_key e { y == enum_key_of_repr e x })))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(destr_payload: ((k: enum_key e) -> Tot (validate_bitsum_cases_t u#r (payload k))))
: Tot (validate_bitsum_cases_t u#r (BitSum' key key_size e payload))
= fun u f v x_ #rrel #rel sl pos ->
[@inline_let]
let r = cl.get_bitfield x_ (bitsum'_size - key_size) bitsum'_size in
[@inline_let]
let k = key_of r in
destr_payload
k
(fun x -> u (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> f (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> v (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
x_ sl pos
module L = FStar.List.Tot
inline_for_extraction
noextract
let validate_bitsum_cases_bitsum'_t
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(l2: list (key & bitfield cl key_size) { e == l1 `L.append` l2 } )
: Tot (Type u#(r+1))
= (u: (bitsum'_key_type (BitSum' key key_size e payload) -> Tot (Type u#r))) ->
(f: ((x: bitsum'_key_type (BitSum' key key_size e payload)) -> Tot (k: parser_kind & parser k (u x)))) ->
(v: ((x: bitsum'_key_type (BitSum' key key_size e payload)) -> Tot (validator (dsnd (f x))))) ->
(x: parse_filter_refine (filter_bitsum' (BitSum' key key_size e payload)) { ~ (list_mem (cl.get_bitfield x (bitsum'_size - key_size) bitsum'_size <: bitfield cl key_size) (list_map snd l1)) }) ->
(xr: t { xr == cl.bitfield_eq_lhs x (bitsum'_size - key_size) bitsum'_size }) ->
Tot (validator (dsnd (f (bitsum'_key_of_t (BitSum' key key_size e payload) (synth_bitsum' (BitSum' key key_size e payload) x)))))
inline_for_extraction
let validate_bitsum_cases_bitsum'_intro
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(phi: validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload [] e)
: Tot (validate_bitsum_cases_t u#r (BitSum' key key_size e payload))
= fun u f v x #rrel #rel sl pos ->
let xr = cl.bitfield_eq_lhs x (bitsum'_size - key_size) bitsum'_size in
phi u f v x xr sl pos
inline_for_extraction
let validate_bitsum_cases_bitsum'_nil
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(h: squash (e == e `L.append` []))
: Tot (validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload e [])
= (fun u f v x xr #rrel #rel sl pos ->
assert False;
validator_error_generic (* dummy *))
#push-options "--z3rlimit 32"
inline_for_extraction
let validate_bitsum_cases_bitsum'_cons
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(k: key)
(r: bitfield cl key_size)
(l2: list (key & bitfield cl key_size) {
e == l1 `L.append` ((k, r) :: l2) /\
list_mem k (list_map fst e) /\
enum_repr_of_key e k == r /\
e == (l1 `L.append` [(k, r)]) `L.append` l2
})
(destr_payload: validate_bitsum_cases_t u#r (payload k))
(destr_tail: validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload (l1 `L.append` [(k, r)]) l2)
: Tot (validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload l1 ((k, r) :: l2))
= fun u f v x xr #rrel #rel sl pos ->
// [@inline_let]
let _ =
enum_repr_of_key_append_cons e l1 (k, r) l2
in
[@inline_let] let yr = cl.bitfield_eq_rhs x (bitsum'_size - key_size) bitsum'_size r in
[@inline_let] let cond = (xr <: t) = yr in
[@inline_let] let _ =
assert (cond == true <==> (cl.get_bitfield x (bitsum'_size - key_size) bitsum'_size <: bitfield cl key_size) == r)
in
if cond
then
destr_payload
(fun x -> u (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> f (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> v (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
x sl pos
else
[@inline_let] let _ =
L.append_assoc l1 [(k, r)] l2;
L.map_append snd l1 [(k, r)];
L.append_mem (L.map snd l1) (L.map snd [(k, r)]) (cl.get_bitfield x (bitsum'_size - key_size) bitsum'_size <: bitfield cl key_size)
in
destr_tail u f v (x <: t) xr sl pos
[@filter_bitsum'_t_attr]
noextract
let rec mk_validate_bitsum_cases_bitsum'_t'
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(l2: list (key & bitfield cl key_size) { e == l1 `L.append` l2 } )
(mk_validate_bitsum_cases_t':
(* universe-polymorphic mutually recursive functions must be "split off"
cf. https://github.com/FStarLang/FStar/issues/1480#issuecomment-623260544
*)
(b: bitsum' cl (bitsum'_size - key_size) { b << BitSum' key key_size e payload }) ->
Tot (validate_bitsum_cases_t u#r b)
)
: Tot (validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload l1 l2)
(decreases %[BitSum' key key_size e payload; l2])
= bitsum_wellfoundedness (BitSum' key key_size e payload);
match l2 with
| [] ->
[@inline_let] let _ =
L.append_l_nil l1
in
validate_bitsum_cases_bitsum'_nil cl bitsum'_size key key_size e payload ()
| (k, r) :: q ->
[@inline_let] let _ =
enum_repr_of_key_append_cons e l1 (k, r) q;
L.append_assoc l1 [(k, r)] q
in
validate_bitsum_cases_bitsum'_cons cl bitsum'_size key key_size e payload l1 k r q
(mk_validate_bitsum_cases_t' (payload k))
(mk_validate_bitsum_cases_bitsum'_t' cl bitsum'_size key key_size e payload (l1 `L.append` [(k, r)]) q mk_validate_bitsum_cases_t')
[@filter_bitsum'_t_attr]
noextract
let rec mk_validate_bitsum_cases_t'
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(#bitsum'_size: nat)
(b: bitsum' cl bitsum'_size)
: Tot (validate_bitsum_cases_t u#r b)
(decreases b)
= match b with
| BitStop _ -> validate_bitsum_cases_bitstop cl
| BitField sz rest -> validate_bitsum_cases_bitfield cl bitsum'_size sz rest (mk_validate_bitsum_cases_t' rest)
| BitSum' key key_size e payload ->
validate_bitsum_cases_bitsum'_intro cl bitsum'_size key key_size e payload (mk_validate_bitsum_cases_bitsum'_t' cl bitsum'_size key key_size e payload [] e (mk_validate_bitsum_cases_t' #tot #t #cl #(bitsum'_size - key_size)))
#push-options "--z3rlimit 64"
#restart-solver
inline_for_extraction
let validate_bitsum
(#kt: parser_kind)
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#data: Type)
(tag_of_data: (data -> Tot (bitsum'_type b)))
(type_of_tag: (bitsum'_key_type b -> Tot Type))
(synth_case: synth_case_t b data tag_of_data type_of_tag)
(#p: parser kt t)
(v: validator p)
(r: leaf_reader p)
(phi: filter_bitsum'_t b)
(f: (x: bitsum'_key_type b) -> Tot (k: parser_kind & parser k (type_of_tag x)))
(vf: (x: bitsum'_key_type b) -> Tot (validator (dsnd (f x))))
(vs: validate_bitsum_cases_t b)
: Tot (validator (parse_bitsum b tag_of_data type_of_tag synth_case p f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl (uint64_to_uint32 pos);
parse_bitsum_eq b tag_of_data type_of_tag synth_case p f (bytes_of_slice_from h sl (uint64_to_uint32 pos));
valid_facts (parse_bitsum' b p) h sl (uint64_to_uint32 pos)
in
let pos1 = validate_bitsum' b v r phi sl pos in
if is_error pos1
then pos1
else
[@inline_let] let _ =
synth_bitsum'_injective b;
parse_synth_eq (p `parse_filter` filter_bitsum' b) (synth_bitsum' b) (bytes_of_slice_from h sl (uint64_to_uint32 pos));
parse_filter_eq p (filter_bitsum' b) (bytes_of_slice_from h sl (uint64_to_uint32 pos));
valid_facts p h sl (uint64_to_uint32 pos)
in
let x = r sl (uint64_to_uint32 pos) in
[@inline_let]
let _ =
let y = synth_bitsum' b x in
let tg = bitsum'_key_of_t b y in
parse_synth_eq (dsnd (f tg)) (synth_case.f y) (bytes_of_slice_from h sl (uint64_to_uint32 pos1));
valid_facts (dsnd (f tg)) h sl (uint64_to_uint32 pos1)
in
vs (type_of_tag) f vf x sl pos1
#pop-options
let valid_bitsum_intro
(#kt: parser_kind)
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#data: Type)
(tag_of_data: (data -> Tot (bitsum'_type b)))
(type_of_tag: (bitsum'_key_type b -> Tot Type))
(synth_case: synth_case_t b data tag_of_data type_of_tag)
(p: parser kt t)
(f: (x: bitsum'_key_type b) -> Tot (k: parser_kind & parser k (type_of_tag x)))
(h: HS.mem)
(#rrel: _)
(#rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_bitsum' b p) h sl pos /\ (
let tg = contents (parse_bitsum' b p) h sl pos in
let k = bitsum'_key_of_t b tg in
valid (dsnd (f k)) h sl (get_valid_pos (parse_bitsum' b p) h sl pos)
)))
(ensures (
let tg = contents (parse_bitsum' b p) h sl pos in
let k = bitsum'_key_of_t b tg in
let pos1 = get_valid_pos (parse_bitsum' b p) h sl pos in
let y = contents (dsnd (f k)) h sl pos1 in
valid_content_pos (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos (synth_case.f tg y) (get_valid_pos (dsnd (f k)) h sl pos1)
))
= valid_facts (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos;
parse_bitsum_eq b tag_of_data type_of_tag synth_case p f (bytes_of_slice_from h sl pos);
valid_facts (parse_bitsum' b p) h sl pos;
let tg = contents (parse_bitsum' b p) h sl pos in
let k = bitsum'_key_of_t b tg in
let pos1 = get_valid_pos (parse_bitsum' b p) h sl pos in
valid_facts (dsnd (f k)) h sl pos1
#pop-options
let valid_bitsum_elim'
(#kt: parser_kind)
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#data: Type)
(tag_of_data: (data -> Tot (bitsum'_type b)))
(type_of_tag: (bitsum'_key_type b -> Tot Type))
(synth_case: synth_case_t b data tag_of_data type_of_tag)
(p: parser kt t)
(f: (x: bitsum'_key_type b) -> Tot (k: parser_kind & parser k (type_of_tag x)))
(h: HS.mem)
(#rrel: _)
(#rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos
))
(ensures (
valid (parse_bitsum' b p) h sl pos /\ (
let tg = contents (parse_bitsum' b p) h sl pos in
let k = bitsum'_key_of_t b tg in
let pos1 = get_valid_pos (parse_bitsum' b p) h sl pos in
valid (dsnd (f k)) h sl pos1 /\ (
let y = contents (dsnd (f k)) h sl pos1 in
valid_content_pos (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos (synth_case.f tg y) (get_valid_pos (dsnd (f k)) h sl pos1)
))))
= valid_facts (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos;
parse_bitsum_eq b tag_of_data type_of_tag synth_case p f (bytes_of_slice_from h sl pos);
valid_facts (parse_bitsum' b p) h sl pos;
let tg = contents (parse_bitsum' b p) h sl pos in
let k = bitsum'_key_of_t b tg in
let pos1 = get_valid_pos (parse_bitsum' b p) h sl pos in
valid_facts (dsnd (f k)) h sl pos1;
valid_bitsum_intro b tag_of_data type_of_tag synth_case p f h sl pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.BitSum.fst.checked",
"LowParse.Low.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.BitSum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.BitSum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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
}
] | {
"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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: LowParse.Spec.BitSum.bitsum' cl tot ->
tag_of_data: (_: data -> LowParse.Spec.BitSum.bitsum'_type b) ->
type_of_tag: (_: LowParse.Spec.BitSum.bitsum'_key_type b -> Type) ->
synth_case: LowParse.Spec.BitSum.synth_case_t b data tag_of_data type_of_tag ->
p: LowParse.Spec.Base.parser kt t ->
f:
(x: LowParse.Spec.BitSum.bitsum'_key_type b
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (type_of_tag x))) ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid (LowParse.Spec.BitSum.parse_bitsum b
tag_of_data
type_of_tag
synth_case
p
f)
h
sl
pos)
(ensures
LowParse.Low.Base.Spec.valid p h sl pos /\
(let x = LowParse.Low.Base.Spec.contents p h sl pos in
LowParse.Spec.BitSum.filter_bitsum' b x == true /\
(let tg = LowParse.Spec.BitSum.synth_bitsum' b x in
let k = LowParse.Spec.BitSum.bitsum'_key_of_t b tg in
let pos1 = LowParse.Low.Base.Spec.get_valid_pos p h sl pos in
LowParse.Low.Base.Spec.valid (FStar.Pervasives.dsnd (f k)) h sl pos1 /\
LowParse.Low.Base.Spec.valid_pos (LowParse.Spec.BitSum.parse_bitsum b
tag_of_data
type_of_tag
synth_case
p
f)
h
sl
pos
(LowParse.Low.Base.Spec.get_valid_pos (FStar.Pervasives.dsnd (f k)) h sl pos1) /\
(let x =
LowParse.Low.Base.Spec.contents (LowParse.Spec.BitSum.parse_bitsum b
tag_of_data
type_of_tag
synth_case
p
f)
h
sl
pos
in
let y = LowParse.Low.Base.Spec.contents (FStar.Pervasives.dsnd (f k)) h sl pos1 in
tg == tag_of_data x /\ x == SynthCase?.f synth_case tg y /\
y == SynthCase?.g synth_case tg x)))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"Prims.pos",
"Prims.eqtype",
"LowParse.BitFields.uint_t",
"LowParse.Spec.BitSum.bitsum'",
"LowParse.Spec.BitSum.bitsum'_type",
"LowParse.Spec.BitSum.bitsum'_key_type",
"LowParse.Spec.BitSum.synth_case_t",
"LowParse.Spec.Base.parser",
"Prims.dtuple2",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Spec.BitSum.__proj__SynthCase__item__f_inj",
"LowParse.Spec.BitSum.__proj__SynthCase__item__g",
"Prims.unit",
"LowParse.Spec.BitSum.__proj__SynthCase__item__f_g_eq",
"Prims._assert",
"Prims.eq2",
"LowParse.Spec.BitSum.__proj__SynthCase__item__f",
"LowParse.Low.Base.Spec.contents",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Spec.BitSum.parse_bitsum_kind",
"LowParse.Spec.BitSum.parse_bitsum",
"LowParse.Low.Base.Spec.get_valid_pos",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.BitSum.parse_bitsum'",
"LowParse.Spec.BitSum.bitsum'_key_of_t",
"LowParse.Spec.BitSum.synth_bitsum'",
"LowParse.Low.Combinators.valid_filter",
"LowParse.Spec.BitSum.filter_bitsum'",
"LowParse.Low.Combinators.valid_synth",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.Combinators.parse_filter",
"LowParse.Low.Base.Spec.valid",
"LowParse.Spec.Combinators.parse_synth",
"LowParse.Spec.BitSum.synth_bitsum'_injective",
"LowParse.Low.BitSum.valid_bitsum_elim'",
"Prims.squash",
"Prims.l_and",
"Prims.bool",
"LowParse.Low.Base.Spec.valid_pos",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let valid_bitsum_elim
(#kt: parser_kind)
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#data: Type)
(tag_of_data: (data -> Tot (bitsum'_type b)))
(type_of_tag: (bitsum'_key_type b -> Tot Type))
(synth_case: synth_case_t b data tag_of_data type_of_tag)
(p: parser kt t)
(f: (x: bitsum'_key_type b -> Tot (k: parser_kind & parser k (type_of_tag x))))
(h: HS.mem)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos))
(ensures
(valid p h sl pos /\
(let x = contents p h sl pos in
filter_bitsum' b x == true /\
(let tg = synth_bitsum' b x in
let k = bitsum'_key_of_t b tg in
let pos1 = get_valid_pos p h sl pos in
valid (dsnd (f k)) h sl pos1 /\
valid_pos (parse_bitsum b tag_of_data type_of_tag synth_case p f)
h
sl
pos
(get_valid_pos (dsnd (f k)) h sl pos1) /\
(let x = contents (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos in
let y = contents (dsnd (f k)) h sl pos1 in
tg == tag_of_data x /\ x == synth_case.f tg y /\ y == synth_case.g tg x))))) =
| valid_bitsum_elim' b tag_of_data type_of_tag synth_case p f h sl pos;
synth_bitsum'_injective b;
assert (valid ((p `parse_filter` (filter_bitsum' b)) `parse_synth` (synth_bitsum' b)) h sl pos);
valid_synth h (p `parse_filter` (filter_bitsum' b)) (synth_bitsum' b) sl pos;
valid_filter h p (filter_bitsum' b) sl pos;
let tg = synth_bitsum' b (contents p h sl pos) in
let tg = contents (parse_bitsum' b p) h sl pos in
let k = bitsum'_key_of_t b tg in
let pos1 = get_valid_pos (parse_bitsum' b p) h sl pos in
let x = contents (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos in
let y = contents (dsnd (f k)) h sl pos1 in
assert (tg == tag_of_data x);
assert (x == synth_case.f tg y);
synth_case.f_g_eq tg x;
synth_case.f_inj tg (synth_case.g tg x) y | false |
LowParse.Low.BitSum.fst | LowParse.Low.BitSum.valid_bitsum_elim' | val valid_bitsum_elim'
(#kt: parser_kind)
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#data: Type)
(tag_of_data: (data -> Tot (bitsum'_type b)))
(type_of_tag: (bitsum'_key_type b -> Tot Type))
(synth_case: synth_case_t b data tag_of_data type_of_tag)
(p: parser kt t)
(f: (x: bitsum'_key_type b -> Tot (k: parser_kind & parser k (type_of_tag x))))
(h: HS.mem)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos))
(ensures
(valid (parse_bitsum' b p) h sl pos /\
(let tg = contents (parse_bitsum' b p) h sl pos in
let k = bitsum'_key_of_t b tg in
let pos1 = get_valid_pos (parse_bitsum' b p) h sl pos in
valid (dsnd (f k)) h sl pos1 /\
(let y = contents (dsnd (f k)) h sl pos1 in
valid_content_pos (parse_bitsum b tag_of_data type_of_tag synth_case p f)
h
sl
pos
(synth_case.f tg y)
(get_valid_pos (dsnd (f k)) h sl pos1))))) | val valid_bitsum_elim'
(#kt: parser_kind)
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#data: Type)
(tag_of_data: (data -> Tot (bitsum'_type b)))
(type_of_tag: (bitsum'_key_type b -> Tot Type))
(synth_case: synth_case_t b data tag_of_data type_of_tag)
(p: parser kt t)
(f: (x: bitsum'_key_type b -> Tot (k: parser_kind & parser k (type_of_tag x))))
(h: HS.mem)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos))
(ensures
(valid (parse_bitsum' b p) h sl pos /\
(let tg = contents (parse_bitsum' b p) h sl pos in
let k = bitsum'_key_of_t b tg in
let pos1 = get_valid_pos (parse_bitsum' b p) h sl pos in
valid (dsnd (f k)) h sl pos1 /\
(let y = contents (dsnd (f k)) h sl pos1 in
valid_content_pos (parse_bitsum b tag_of_data type_of_tag synth_case p f)
h
sl
pos
(synth_case.f tg y)
(get_valid_pos (dsnd (f k)) h sl pos1))))) | let valid_bitsum_elim'
(#kt: parser_kind)
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#data: Type)
(tag_of_data: (data -> Tot (bitsum'_type b)))
(type_of_tag: (bitsum'_key_type b -> Tot Type))
(synth_case: synth_case_t b data tag_of_data type_of_tag)
(p: parser kt t)
(f: (x: bitsum'_key_type b) -> Tot (k: parser_kind & parser k (type_of_tag x)))
(h: HS.mem)
(#rrel: _)
(#rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos
))
(ensures (
valid (parse_bitsum' b p) h sl pos /\ (
let tg = contents (parse_bitsum' b p) h sl pos in
let k = bitsum'_key_of_t b tg in
let pos1 = get_valid_pos (parse_bitsum' b p) h sl pos in
valid (dsnd (f k)) h sl pos1 /\ (
let y = contents (dsnd (f k)) h sl pos1 in
valid_content_pos (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos (synth_case.f tg y) (get_valid_pos (dsnd (f k)) h sl pos1)
))))
= valid_facts (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos;
parse_bitsum_eq b tag_of_data type_of_tag synth_case p f (bytes_of_slice_from h sl pos);
valid_facts (parse_bitsum' b p) h sl pos;
let tg = contents (parse_bitsum' b p) h sl pos in
let k = bitsum'_key_of_t b tg in
let pos1 = get_valid_pos (parse_bitsum' b p) h sl pos in
valid_facts (dsnd (f k)) h sl pos1;
valid_bitsum_intro b tag_of_data type_of_tag synth_case p f h sl pos | {
"file_name": "src/lowparse/LowParse.Low.BitSum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 70,
"end_line": 390,
"start_col": 0,
"start_line": 353
} | module LowParse.Low.BitSum
include LowParse.Low.Combinators
include LowParse.Spec.BitSum
module U32 = FStar.UInt32
module HS = FStar.HyperStack
#push-options "--z3rlimit 16"
inline_for_extraction
let validate_bitsum'
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#k: parser_kind)
(#p: parser k t)
(v: validator p)
(r: leaf_reader p)
(phi: filter_bitsum'_t b)
: Tot (validator (parse_bitsum' b p))
= synth_bitsum'_injective b;
validate_synth
(validate_filter
v
r
(filter_bitsum' b)
(fun x -> phi x))
(synth_bitsum' b)
()
module HST = FStar.HyperStack.ST
inline_for_extraction
noextract
let validate_bitsum_cases_t
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(#from: nat)
(b: bitsum' cl from)
: Tot (Type u#(r+1))
= (u: (bitsum'_key_type b -> Tot (Type u#r))) ->
(f: ((x: bitsum'_key_type b) -> Tot (k: parser_kind & parser k (u x)))) ->
(v: ((x: bitsum'_key_type b) -> Tot (validator (dsnd (f x))))) ->
(x: parse_filter_refine (filter_bitsum' b)) ->
Tot (validator (dsnd (f (bitsum'_key_of_t b (synth_bitsum' b x)))))
inline_for_extraction
let validate_bitsum_cases_bitstop
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
: Tot (validate_bitsum_cases_t u#r #tot #t #cl #0 (BitStop ()))
= fun u f v x #rrel #rel sl pos ->
v () sl pos
inline_for_extraction
let validate_bitsum_cases_bitfield
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(sz: nat { sz > 0 /\ sz <= bitsum'_size /\ bitsum'_size <= tot })
(rest: bitsum' cl (bitsum'_size - sz))
(phi: validate_bitsum_cases_t u#r rest)
: Tot (validate_bitsum_cases_t u#r (BitField sz rest))
= fun u f v x #rrel #rel sl pos ->
phi
(fun x -> u (coerce (bitsum'_key_type (BitField sz rest)) x))
(fun x -> f (coerce (bitsum'_key_type (BitField sz rest)) x))
(fun x -> v (coerce (bitsum'_key_type (BitField sz rest)) x))
x
sl
pos
inline_for_extraction
let validate_bitsum_cases_bitsum_gen
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(key_of: ((x: enum_repr e) -> Tot (y: enum_key e { y == enum_key_of_repr e x })))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(destr_payload: ((k: enum_key e) -> Tot (validate_bitsum_cases_t u#r (payload k))))
: Tot (validate_bitsum_cases_t u#r (BitSum' key key_size e payload))
= fun u f v x_ #rrel #rel sl pos ->
[@inline_let]
let r = cl.get_bitfield x_ (bitsum'_size - key_size) bitsum'_size in
[@inline_let]
let k = key_of r in
destr_payload
k
(fun x -> u (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> f (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> v (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
x_ sl pos
module L = FStar.List.Tot
inline_for_extraction
noextract
let validate_bitsum_cases_bitsum'_t
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(l2: list (key & bitfield cl key_size) { e == l1 `L.append` l2 } )
: Tot (Type u#(r+1))
= (u: (bitsum'_key_type (BitSum' key key_size e payload) -> Tot (Type u#r))) ->
(f: ((x: bitsum'_key_type (BitSum' key key_size e payload)) -> Tot (k: parser_kind & parser k (u x)))) ->
(v: ((x: bitsum'_key_type (BitSum' key key_size e payload)) -> Tot (validator (dsnd (f x))))) ->
(x: parse_filter_refine (filter_bitsum' (BitSum' key key_size e payload)) { ~ (list_mem (cl.get_bitfield x (bitsum'_size - key_size) bitsum'_size <: bitfield cl key_size) (list_map snd l1)) }) ->
(xr: t { xr == cl.bitfield_eq_lhs x (bitsum'_size - key_size) bitsum'_size }) ->
Tot (validator (dsnd (f (bitsum'_key_of_t (BitSum' key key_size e payload) (synth_bitsum' (BitSum' key key_size e payload) x)))))
inline_for_extraction
let validate_bitsum_cases_bitsum'_intro
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(phi: validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload [] e)
: Tot (validate_bitsum_cases_t u#r (BitSum' key key_size e payload))
= fun u f v x #rrel #rel sl pos ->
let xr = cl.bitfield_eq_lhs x (bitsum'_size - key_size) bitsum'_size in
phi u f v x xr sl pos
inline_for_extraction
let validate_bitsum_cases_bitsum'_nil
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(h: squash (e == e `L.append` []))
: Tot (validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload e [])
= (fun u f v x xr #rrel #rel sl pos ->
assert False;
validator_error_generic (* dummy *))
#push-options "--z3rlimit 32"
inline_for_extraction
let validate_bitsum_cases_bitsum'_cons
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(k: key)
(r: bitfield cl key_size)
(l2: list (key & bitfield cl key_size) {
e == l1 `L.append` ((k, r) :: l2) /\
list_mem k (list_map fst e) /\
enum_repr_of_key e k == r /\
e == (l1 `L.append` [(k, r)]) `L.append` l2
})
(destr_payload: validate_bitsum_cases_t u#r (payload k))
(destr_tail: validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload (l1 `L.append` [(k, r)]) l2)
: Tot (validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload l1 ((k, r) :: l2))
= fun u f v x xr #rrel #rel sl pos ->
// [@inline_let]
let _ =
enum_repr_of_key_append_cons e l1 (k, r) l2
in
[@inline_let] let yr = cl.bitfield_eq_rhs x (bitsum'_size - key_size) bitsum'_size r in
[@inline_let] let cond = (xr <: t) = yr in
[@inline_let] let _ =
assert (cond == true <==> (cl.get_bitfield x (bitsum'_size - key_size) bitsum'_size <: bitfield cl key_size) == r)
in
if cond
then
destr_payload
(fun x -> u (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> f (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> v (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
x sl pos
else
[@inline_let] let _ =
L.append_assoc l1 [(k, r)] l2;
L.map_append snd l1 [(k, r)];
L.append_mem (L.map snd l1) (L.map snd [(k, r)]) (cl.get_bitfield x (bitsum'_size - key_size) bitsum'_size <: bitfield cl key_size)
in
destr_tail u f v (x <: t) xr sl pos
[@filter_bitsum'_t_attr]
noextract
let rec mk_validate_bitsum_cases_bitsum'_t'
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(l2: list (key & bitfield cl key_size) { e == l1 `L.append` l2 } )
(mk_validate_bitsum_cases_t':
(* universe-polymorphic mutually recursive functions must be "split off"
cf. https://github.com/FStarLang/FStar/issues/1480#issuecomment-623260544
*)
(b: bitsum' cl (bitsum'_size - key_size) { b << BitSum' key key_size e payload }) ->
Tot (validate_bitsum_cases_t u#r b)
)
: Tot (validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload l1 l2)
(decreases %[BitSum' key key_size e payload; l2])
= bitsum_wellfoundedness (BitSum' key key_size e payload);
match l2 with
| [] ->
[@inline_let] let _ =
L.append_l_nil l1
in
validate_bitsum_cases_bitsum'_nil cl bitsum'_size key key_size e payload ()
| (k, r) :: q ->
[@inline_let] let _ =
enum_repr_of_key_append_cons e l1 (k, r) q;
L.append_assoc l1 [(k, r)] q
in
validate_bitsum_cases_bitsum'_cons cl bitsum'_size key key_size e payload l1 k r q
(mk_validate_bitsum_cases_t' (payload k))
(mk_validate_bitsum_cases_bitsum'_t' cl bitsum'_size key key_size e payload (l1 `L.append` [(k, r)]) q mk_validate_bitsum_cases_t')
[@filter_bitsum'_t_attr]
noextract
let rec mk_validate_bitsum_cases_t'
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(#bitsum'_size: nat)
(b: bitsum' cl bitsum'_size)
: Tot (validate_bitsum_cases_t u#r b)
(decreases b)
= match b with
| BitStop _ -> validate_bitsum_cases_bitstop cl
| BitField sz rest -> validate_bitsum_cases_bitfield cl bitsum'_size sz rest (mk_validate_bitsum_cases_t' rest)
| BitSum' key key_size e payload ->
validate_bitsum_cases_bitsum'_intro cl bitsum'_size key key_size e payload (mk_validate_bitsum_cases_bitsum'_t' cl bitsum'_size key key_size e payload [] e (mk_validate_bitsum_cases_t' #tot #t #cl #(bitsum'_size - key_size)))
#push-options "--z3rlimit 64"
#restart-solver
inline_for_extraction
let validate_bitsum
(#kt: parser_kind)
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#data: Type)
(tag_of_data: (data -> Tot (bitsum'_type b)))
(type_of_tag: (bitsum'_key_type b -> Tot Type))
(synth_case: synth_case_t b data tag_of_data type_of_tag)
(#p: parser kt t)
(v: validator p)
(r: leaf_reader p)
(phi: filter_bitsum'_t b)
(f: (x: bitsum'_key_type b) -> Tot (k: parser_kind & parser k (type_of_tag x)))
(vf: (x: bitsum'_key_type b) -> Tot (validator (dsnd (f x))))
(vs: validate_bitsum_cases_t b)
: Tot (validator (parse_bitsum b tag_of_data type_of_tag synth_case p f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl (uint64_to_uint32 pos);
parse_bitsum_eq b tag_of_data type_of_tag synth_case p f (bytes_of_slice_from h sl (uint64_to_uint32 pos));
valid_facts (parse_bitsum' b p) h sl (uint64_to_uint32 pos)
in
let pos1 = validate_bitsum' b v r phi sl pos in
if is_error pos1
then pos1
else
[@inline_let] let _ =
synth_bitsum'_injective b;
parse_synth_eq (p `parse_filter` filter_bitsum' b) (synth_bitsum' b) (bytes_of_slice_from h sl (uint64_to_uint32 pos));
parse_filter_eq p (filter_bitsum' b) (bytes_of_slice_from h sl (uint64_to_uint32 pos));
valid_facts p h sl (uint64_to_uint32 pos)
in
let x = r sl (uint64_to_uint32 pos) in
[@inline_let]
let _ =
let y = synth_bitsum' b x in
let tg = bitsum'_key_of_t b y in
parse_synth_eq (dsnd (f tg)) (synth_case.f y) (bytes_of_slice_from h sl (uint64_to_uint32 pos1));
valid_facts (dsnd (f tg)) h sl (uint64_to_uint32 pos1)
in
vs (type_of_tag) f vf x sl pos1
#pop-options
let valid_bitsum_intro
(#kt: parser_kind)
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#data: Type)
(tag_of_data: (data -> Tot (bitsum'_type b)))
(type_of_tag: (bitsum'_key_type b -> Tot Type))
(synth_case: synth_case_t b data tag_of_data type_of_tag)
(p: parser kt t)
(f: (x: bitsum'_key_type b) -> Tot (k: parser_kind & parser k (type_of_tag x)))
(h: HS.mem)
(#rrel: _)
(#rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_bitsum' b p) h sl pos /\ (
let tg = contents (parse_bitsum' b p) h sl pos in
let k = bitsum'_key_of_t b tg in
valid (dsnd (f k)) h sl (get_valid_pos (parse_bitsum' b p) h sl pos)
)))
(ensures (
let tg = contents (parse_bitsum' b p) h sl pos in
let k = bitsum'_key_of_t b tg in
let pos1 = get_valid_pos (parse_bitsum' b p) h sl pos in
let y = contents (dsnd (f k)) h sl pos1 in
valid_content_pos (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos (synth_case.f tg y) (get_valid_pos (dsnd (f k)) h sl pos1)
))
= valid_facts (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos;
parse_bitsum_eq b tag_of_data type_of_tag synth_case p f (bytes_of_slice_from h sl pos);
valid_facts (parse_bitsum' b p) h sl pos;
let tg = contents (parse_bitsum' b p) h sl pos in
let k = bitsum'_key_of_t b tg in
let pos1 = get_valid_pos (parse_bitsum' b p) h sl pos in
valid_facts (dsnd (f k)) h sl pos1
#pop-options | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.BitSum.fst.checked",
"LowParse.Low.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.BitSum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.BitSum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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
}
] | {
"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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: LowParse.Spec.BitSum.bitsum' cl tot ->
tag_of_data: (_: data -> LowParse.Spec.BitSum.bitsum'_type b) ->
type_of_tag: (_: LowParse.Spec.BitSum.bitsum'_key_type b -> Type) ->
synth_case: LowParse.Spec.BitSum.synth_case_t b data tag_of_data type_of_tag ->
p: LowParse.Spec.Base.parser kt t ->
f:
(x: LowParse.Spec.BitSum.bitsum'_key_type b
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (type_of_tag x))) ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid (LowParse.Spec.BitSum.parse_bitsum b
tag_of_data
type_of_tag
synth_case
p
f)
h
sl
pos)
(ensures
LowParse.Low.Base.Spec.valid (LowParse.Spec.BitSum.parse_bitsum' b p) h sl pos /\
(let tg =
LowParse.Low.Base.Spec.contents (LowParse.Spec.BitSum.parse_bitsum' b p) h sl pos
in
let k = LowParse.Spec.BitSum.bitsum'_key_of_t b tg in
let pos1 =
LowParse.Low.Base.Spec.get_valid_pos (LowParse.Spec.BitSum.parse_bitsum' b p) h sl pos
in
LowParse.Low.Base.Spec.valid (FStar.Pervasives.dsnd (f k)) h sl pos1 /\
(let y = LowParse.Low.Base.Spec.contents (FStar.Pervasives.dsnd (f k)) h sl pos1 in
LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.BitSum.parse_bitsum b
tag_of_data
type_of_tag
synth_case
p
f)
h
sl
pos
(SynthCase?.f synth_case tg y)
(LowParse.Low.Base.Spec.get_valid_pos (FStar.Pervasives.dsnd (f k)) h sl pos1)))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"Prims.pos",
"Prims.eqtype",
"LowParse.BitFields.uint_t",
"LowParse.Spec.BitSum.bitsum'",
"LowParse.Spec.BitSum.bitsum'_type",
"LowParse.Spec.BitSum.bitsum'_key_type",
"LowParse.Spec.BitSum.synth_case_t",
"LowParse.Spec.Base.parser",
"Prims.dtuple2",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.BitSum.valid_bitsum_intro",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_facts",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Low.Base.Spec.get_valid_pos",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.BitSum.parse_bitsum'",
"LowParse.Spec.BitSum.bitsum'_key_of_t",
"LowParse.Low.Base.Spec.contents",
"LowParse.Spec.BitSum.parse_bitsum_eq",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Spec.BitSum.parse_bitsum_kind",
"LowParse.Spec.BitSum.parse_bitsum",
"LowParse.Low.Base.Spec.valid",
"Prims.squash",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Spec.BitSum.__proj__SynthCase__item__f",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let valid_bitsum_elim'
(#kt: parser_kind)
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#data: Type)
(tag_of_data: (data -> Tot (bitsum'_type b)))
(type_of_tag: (bitsum'_key_type b -> Tot Type))
(synth_case: synth_case_t b data tag_of_data type_of_tag)
(p: parser kt t)
(f: (x: bitsum'_key_type b -> Tot (k: parser_kind & parser k (type_of_tag x))))
(h: HS.mem)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos))
(ensures
(valid (parse_bitsum' b p) h sl pos /\
(let tg = contents (parse_bitsum' b p) h sl pos in
let k = bitsum'_key_of_t b tg in
let pos1 = get_valid_pos (parse_bitsum' b p) h sl pos in
valid (dsnd (f k)) h sl pos1 /\
(let y = contents (dsnd (f k)) h sl pos1 in
valid_content_pos (parse_bitsum b tag_of_data type_of_tag synth_case p f)
h
sl
pos
(synth_case.f tg y)
(get_valid_pos (dsnd (f k)) h sl pos1))))) =
| valid_facts (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos;
parse_bitsum_eq b tag_of_data type_of_tag synth_case p f (bytes_of_slice_from h sl pos);
valid_facts (parse_bitsum' b p) h sl pos;
let tg = contents (parse_bitsum' b p) h sl pos in
let k = bitsum'_key_of_t b tg in
let pos1 = get_valid_pos (parse_bitsum' b p) h sl pos in
valid_facts (dsnd (f k)) h sl pos1;
valid_bitsum_intro b tag_of_data type_of_tag synth_case p f h sl pos | false |
LowParse.Low.BitSum.fst | LowParse.Low.BitSum.valid_bitsum_intro | val valid_bitsum_intro
(#kt: parser_kind)
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#data: Type)
(tag_of_data: (data -> Tot (bitsum'_type b)))
(type_of_tag: (bitsum'_key_type b -> Tot Type))
(synth_case: synth_case_t b data tag_of_data type_of_tag)
(p: parser kt t)
(f: (x: bitsum'_key_type b -> Tot (k: parser_kind & parser k (type_of_tag x))))
(h: HS.mem)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid (parse_bitsum' b p) h sl pos /\
(let tg = contents (parse_bitsum' b p) h sl pos in
let k = bitsum'_key_of_t b tg in
valid (dsnd (f k)) h sl (get_valid_pos (parse_bitsum' b p) h sl pos))))
(ensures
(let tg = contents (parse_bitsum' b p) h sl pos in
let k = bitsum'_key_of_t b tg in
let pos1 = get_valid_pos (parse_bitsum' b p) h sl pos in
let y = contents (dsnd (f k)) h sl pos1 in
valid_content_pos (parse_bitsum b tag_of_data type_of_tag synth_case p f)
h
sl
pos
(synth_case.f tg y)
(get_valid_pos (dsnd (f k)) h sl pos1))) | val valid_bitsum_intro
(#kt: parser_kind)
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#data: Type)
(tag_of_data: (data -> Tot (bitsum'_type b)))
(type_of_tag: (bitsum'_key_type b -> Tot Type))
(synth_case: synth_case_t b data tag_of_data type_of_tag)
(p: parser kt t)
(f: (x: bitsum'_key_type b -> Tot (k: parser_kind & parser k (type_of_tag x))))
(h: HS.mem)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid (parse_bitsum' b p) h sl pos /\
(let tg = contents (parse_bitsum' b p) h sl pos in
let k = bitsum'_key_of_t b tg in
valid (dsnd (f k)) h sl (get_valid_pos (parse_bitsum' b p) h sl pos))))
(ensures
(let tg = contents (parse_bitsum' b p) h sl pos in
let k = bitsum'_key_of_t b tg in
let pos1 = get_valid_pos (parse_bitsum' b p) h sl pos in
let y = contents (dsnd (f k)) h sl pos1 in
valid_content_pos (parse_bitsum b tag_of_data type_of_tag synth_case p f)
h
sl
pos
(synth_case.f tg y)
(get_valid_pos (dsnd (f k)) h sl pos1))) | let valid_bitsum_intro
(#kt: parser_kind)
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#data: Type)
(tag_of_data: (data -> Tot (bitsum'_type b)))
(type_of_tag: (bitsum'_key_type b -> Tot Type))
(synth_case: synth_case_t b data tag_of_data type_of_tag)
(p: parser kt t)
(f: (x: bitsum'_key_type b) -> Tot (k: parser_kind & parser k (type_of_tag x)))
(h: HS.mem)
(#rrel: _)
(#rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_bitsum' b p) h sl pos /\ (
let tg = contents (parse_bitsum' b p) h sl pos in
let k = bitsum'_key_of_t b tg in
valid (dsnd (f k)) h sl (get_valid_pos (parse_bitsum' b p) h sl pos)
)))
(ensures (
let tg = contents (parse_bitsum' b p) h sl pos in
let k = bitsum'_key_of_t b tg in
let pos1 = get_valid_pos (parse_bitsum' b p) h sl pos in
let y = contents (dsnd (f k)) h sl pos1 in
valid_content_pos (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos (synth_case.f tg y) (get_valid_pos (dsnd (f k)) h sl pos1)
))
= valid_facts (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos;
parse_bitsum_eq b tag_of_data type_of_tag synth_case p f (bytes_of_slice_from h sl pos);
valid_facts (parse_bitsum' b p) h sl pos;
let tg = contents (parse_bitsum' b p) h sl pos in
let k = bitsum'_key_of_t b tg in
let pos1 = get_valid_pos (parse_bitsum' b p) h sl pos in
valid_facts (dsnd (f k)) h sl pos1 | {
"file_name": "src/lowparse/LowParse.Low.BitSum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 36,
"end_line": 349,
"start_col": 0,
"start_line": 312
} | module LowParse.Low.BitSum
include LowParse.Low.Combinators
include LowParse.Spec.BitSum
module U32 = FStar.UInt32
module HS = FStar.HyperStack
#push-options "--z3rlimit 16"
inline_for_extraction
let validate_bitsum'
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#k: parser_kind)
(#p: parser k t)
(v: validator p)
(r: leaf_reader p)
(phi: filter_bitsum'_t b)
: Tot (validator (parse_bitsum' b p))
= synth_bitsum'_injective b;
validate_synth
(validate_filter
v
r
(filter_bitsum' b)
(fun x -> phi x))
(synth_bitsum' b)
()
module HST = FStar.HyperStack.ST
inline_for_extraction
noextract
let validate_bitsum_cases_t
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(#from: nat)
(b: bitsum' cl from)
: Tot (Type u#(r+1))
= (u: (bitsum'_key_type b -> Tot (Type u#r))) ->
(f: ((x: bitsum'_key_type b) -> Tot (k: parser_kind & parser k (u x)))) ->
(v: ((x: bitsum'_key_type b) -> Tot (validator (dsnd (f x))))) ->
(x: parse_filter_refine (filter_bitsum' b)) ->
Tot (validator (dsnd (f (bitsum'_key_of_t b (synth_bitsum' b x)))))
inline_for_extraction
let validate_bitsum_cases_bitstop
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
: Tot (validate_bitsum_cases_t u#r #tot #t #cl #0 (BitStop ()))
= fun u f v x #rrel #rel sl pos ->
v () sl pos
inline_for_extraction
let validate_bitsum_cases_bitfield
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(sz: nat { sz > 0 /\ sz <= bitsum'_size /\ bitsum'_size <= tot })
(rest: bitsum' cl (bitsum'_size - sz))
(phi: validate_bitsum_cases_t u#r rest)
: Tot (validate_bitsum_cases_t u#r (BitField sz rest))
= fun u f v x #rrel #rel sl pos ->
phi
(fun x -> u (coerce (bitsum'_key_type (BitField sz rest)) x))
(fun x -> f (coerce (bitsum'_key_type (BitField sz rest)) x))
(fun x -> v (coerce (bitsum'_key_type (BitField sz rest)) x))
x
sl
pos
inline_for_extraction
let validate_bitsum_cases_bitsum_gen
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(key_of: ((x: enum_repr e) -> Tot (y: enum_key e { y == enum_key_of_repr e x })))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(destr_payload: ((k: enum_key e) -> Tot (validate_bitsum_cases_t u#r (payload k))))
: Tot (validate_bitsum_cases_t u#r (BitSum' key key_size e payload))
= fun u f v x_ #rrel #rel sl pos ->
[@inline_let]
let r = cl.get_bitfield x_ (bitsum'_size - key_size) bitsum'_size in
[@inline_let]
let k = key_of r in
destr_payload
k
(fun x -> u (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> f (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> v (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
x_ sl pos
module L = FStar.List.Tot
inline_for_extraction
noextract
let validate_bitsum_cases_bitsum'_t
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(l2: list (key & bitfield cl key_size) { e == l1 `L.append` l2 } )
: Tot (Type u#(r+1))
= (u: (bitsum'_key_type (BitSum' key key_size e payload) -> Tot (Type u#r))) ->
(f: ((x: bitsum'_key_type (BitSum' key key_size e payload)) -> Tot (k: parser_kind & parser k (u x)))) ->
(v: ((x: bitsum'_key_type (BitSum' key key_size e payload)) -> Tot (validator (dsnd (f x))))) ->
(x: parse_filter_refine (filter_bitsum' (BitSum' key key_size e payload)) { ~ (list_mem (cl.get_bitfield x (bitsum'_size - key_size) bitsum'_size <: bitfield cl key_size) (list_map snd l1)) }) ->
(xr: t { xr == cl.bitfield_eq_lhs x (bitsum'_size - key_size) bitsum'_size }) ->
Tot (validator (dsnd (f (bitsum'_key_of_t (BitSum' key key_size e payload) (synth_bitsum' (BitSum' key key_size e payload) x)))))
inline_for_extraction
let validate_bitsum_cases_bitsum'_intro
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(phi: validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload [] e)
: Tot (validate_bitsum_cases_t u#r (BitSum' key key_size e payload))
= fun u f v x #rrel #rel sl pos ->
let xr = cl.bitfield_eq_lhs x (bitsum'_size - key_size) bitsum'_size in
phi u f v x xr sl pos
inline_for_extraction
let validate_bitsum_cases_bitsum'_nil
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(h: squash (e == e `L.append` []))
: Tot (validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload e [])
= (fun u f v x xr #rrel #rel sl pos ->
assert False;
validator_error_generic (* dummy *))
#push-options "--z3rlimit 32"
inline_for_extraction
let validate_bitsum_cases_bitsum'_cons
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(k: key)
(r: bitfield cl key_size)
(l2: list (key & bitfield cl key_size) {
e == l1 `L.append` ((k, r) :: l2) /\
list_mem k (list_map fst e) /\
enum_repr_of_key e k == r /\
e == (l1 `L.append` [(k, r)]) `L.append` l2
})
(destr_payload: validate_bitsum_cases_t u#r (payload k))
(destr_tail: validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload (l1 `L.append` [(k, r)]) l2)
: Tot (validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload l1 ((k, r) :: l2))
= fun u f v x xr #rrel #rel sl pos ->
// [@inline_let]
let _ =
enum_repr_of_key_append_cons e l1 (k, r) l2
in
[@inline_let] let yr = cl.bitfield_eq_rhs x (bitsum'_size - key_size) bitsum'_size r in
[@inline_let] let cond = (xr <: t) = yr in
[@inline_let] let _ =
assert (cond == true <==> (cl.get_bitfield x (bitsum'_size - key_size) bitsum'_size <: bitfield cl key_size) == r)
in
if cond
then
destr_payload
(fun x -> u (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> f (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> v (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
x sl pos
else
[@inline_let] let _ =
L.append_assoc l1 [(k, r)] l2;
L.map_append snd l1 [(k, r)];
L.append_mem (L.map snd l1) (L.map snd [(k, r)]) (cl.get_bitfield x (bitsum'_size - key_size) bitsum'_size <: bitfield cl key_size)
in
destr_tail u f v (x <: t) xr sl pos
[@filter_bitsum'_t_attr]
noextract
let rec mk_validate_bitsum_cases_bitsum'_t'
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(l2: list (key & bitfield cl key_size) { e == l1 `L.append` l2 } )
(mk_validate_bitsum_cases_t':
(* universe-polymorphic mutually recursive functions must be "split off"
cf. https://github.com/FStarLang/FStar/issues/1480#issuecomment-623260544
*)
(b: bitsum' cl (bitsum'_size - key_size) { b << BitSum' key key_size e payload }) ->
Tot (validate_bitsum_cases_t u#r b)
)
: Tot (validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload l1 l2)
(decreases %[BitSum' key key_size e payload; l2])
= bitsum_wellfoundedness (BitSum' key key_size e payload);
match l2 with
| [] ->
[@inline_let] let _ =
L.append_l_nil l1
in
validate_bitsum_cases_bitsum'_nil cl bitsum'_size key key_size e payload ()
| (k, r) :: q ->
[@inline_let] let _ =
enum_repr_of_key_append_cons e l1 (k, r) q;
L.append_assoc l1 [(k, r)] q
in
validate_bitsum_cases_bitsum'_cons cl bitsum'_size key key_size e payload l1 k r q
(mk_validate_bitsum_cases_t' (payload k))
(mk_validate_bitsum_cases_bitsum'_t' cl bitsum'_size key key_size e payload (l1 `L.append` [(k, r)]) q mk_validate_bitsum_cases_t')
[@filter_bitsum'_t_attr]
noextract
let rec mk_validate_bitsum_cases_t'
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(#bitsum'_size: nat)
(b: bitsum' cl bitsum'_size)
: Tot (validate_bitsum_cases_t u#r b)
(decreases b)
= match b with
| BitStop _ -> validate_bitsum_cases_bitstop cl
| BitField sz rest -> validate_bitsum_cases_bitfield cl bitsum'_size sz rest (mk_validate_bitsum_cases_t' rest)
| BitSum' key key_size e payload ->
validate_bitsum_cases_bitsum'_intro cl bitsum'_size key key_size e payload (mk_validate_bitsum_cases_bitsum'_t' cl bitsum'_size key key_size e payload [] e (mk_validate_bitsum_cases_t' #tot #t #cl #(bitsum'_size - key_size)))
#push-options "--z3rlimit 64"
#restart-solver
inline_for_extraction
let validate_bitsum
(#kt: parser_kind)
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#data: Type)
(tag_of_data: (data -> Tot (bitsum'_type b)))
(type_of_tag: (bitsum'_key_type b -> Tot Type))
(synth_case: synth_case_t b data tag_of_data type_of_tag)
(#p: parser kt t)
(v: validator p)
(r: leaf_reader p)
(phi: filter_bitsum'_t b)
(f: (x: bitsum'_key_type b) -> Tot (k: parser_kind & parser k (type_of_tag x)))
(vf: (x: bitsum'_key_type b) -> Tot (validator (dsnd (f x))))
(vs: validate_bitsum_cases_t b)
: Tot (validator (parse_bitsum b tag_of_data type_of_tag synth_case p f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl (uint64_to_uint32 pos);
parse_bitsum_eq b tag_of_data type_of_tag synth_case p f (bytes_of_slice_from h sl (uint64_to_uint32 pos));
valid_facts (parse_bitsum' b p) h sl (uint64_to_uint32 pos)
in
let pos1 = validate_bitsum' b v r phi sl pos in
if is_error pos1
then pos1
else
[@inline_let] let _ =
synth_bitsum'_injective b;
parse_synth_eq (p `parse_filter` filter_bitsum' b) (synth_bitsum' b) (bytes_of_slice_from h sl (uint64_to_uint32 pos));
parse_filter_eq p (filter_bitsum' b) (bytes_of_slice_from h sl (uint64_to_uint32 pos));
valid_facts p h sl (uint64_to_uint32 pos)
in
let x = r sl (uint64_to_uint32 pos) in
[@inline_let]
let _ =
let y = synth_bitsum' b x in
let tg = bitsum'_key_of_t b y in
parse_synth_eq (dsnd (f tg)) (synth_case.f y) (bytes_of_slice_from h sl (uint64_to_uint32 pos1));
valid_facts (dsnd (f tg)) h sl (uint64_to_uint32 pos1)
in
vs (type_of_tag) f vf x sl pos1
#pop-options | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.BitSum.fst.checked",
"LowParse.Low.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.BitSum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.BitSum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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
}
] | {
"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": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: LowParse.Spec.BitSum.bitsum' cl tot ->
tag_of_data: (_: data -> LowParse.Spec.BitSum.bitsum'_type b) ->
type_of_tag: (_: LowParse.Spec.BitSum.bitsum'_key_type b -> Type) ->
synth_case: LowParse.Spec.BitSum.synth_case_t b data tag_of_data type_of_tag ->
p: LowParse.Spec.Base.parser kt t ->
f:
(x: LowParse.Spec.BitSum.bitsum'_key_type b
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (type_of_tag x))) ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid (LowParse.Spec.BitSum.parse_bitsum' b p) h sl pos /\
(let tg =
LowParse.Low.Base.Spec.contents (LowParse.Spec.BitSum.parse_bitsum' b p) h sl pos
in
let k = LowParse.Spec.BitSum.bitsum'_key_of_t b tg in
LowParse.Low.Base.Spec.valid (FStar.Pervasives.dsnd (f k))
h
sl
(LowParse.Low.Base.Spec.get_valid_pos (LowParse.Spec.BitSum.parse_bitsum' b p) h sl pos)
))
(ensures
(let tg =
LowParse.Low.Base.Spec.contents (LowParse.Spec.BitSum.parse_bitsum' b p) h sl pos
in
let k = LowParse.Spec.BitSum.bitsum'_key_of_t b tg in
let pos1 =
LowParse.Low.Base.Spec.get_valid_pos (LowParse.Spec.BitSum.parse_bitsum' b p) h sl pos
in
let y = LowParse.Low.Base.Spec.contents (FStar.Pervasives.dsnd (f k)) h sl pos1 in
LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.BitSum.parse_bitsum b
tag_of_data
type_of_tag
synth_case
p
f)
h
sl
pos
(SynthCase?.f synth_case tg y)
(LowParse.Low.Base.Spec.get_valid_pos (FStar.Pervasives.dsnd (f k)) h sl pos1))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"Prims.pos",
"Prims.eqtype",
"LowParse.BitFields.uint_t",
"LowParse.Spec.BitSum.bitsum'",
"LowParse.Spec.BitSum.bitsum'_type",
"LowParse.Spec.BitSum.bitsum'_key_type",
"LowParse.Spec.BitSum.synth_case_t",
"LowParse.Spec.Base.parser",
"Prims.dtuple2",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_facts",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Low.Base.Spec.get_valid_pos",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.BitSum.parse_bitsum'",
"LowParse.Spec.BitSum.bitsum'_key_of_t",
"LowParse.Low.Base.Spec.contents",
"Prims.unit",
"LowParse.Spec.BitSum.parse_bitsum_eq",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Spec.BitSum.parse_bitsum_kind",
"LowParse.Spec.BitSum.parse_bitsum",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid",
"Prims.squash",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Spec.BitSum.__proj__SynthCase__item__f",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let valid_bitsum_intro
(#kt: parser_kind)
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#data: Type)
(tag_of_data: (data -> Tot (bitsum'_type b)))
(type_of_tag: (bitsum'_key_type b -> Tot Type))
(synth_case: synth_case_t b data tag_of_data type_of_tag)
(p: parser kt t)
(f: (x: bitsum'_key_type b -> Tot (k: parser_kind & parser k (type_of_tag x))))
(h: HS.mem)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid (parse_bitsum' b p) h sl pos /\
(let tg = contents (parse_bitsum' b p) h sl pos in
let k = bitsum'_key_of_t b tg in
valid (dsnd (f k)) h sl (get_valid_pos (parse_bitsum' b p) h sl pos))))
(ensures
(let tg = contents (parse_bitsum' b p) h sl pos in
let k = bitsum'_key_of_t b tg in
let pos1 = get_valid_pos (parse_bitsum' b p) h sl pos in
let y = contents (dsnd (f k)) h sl pos1 in
valid_content_pos (parse_bitsum b tag_of_data type_of_tag synth_case p f)
h
sl
pos
(synth_case.f tg y)
(get_valid_pos (dsnd (f k)) h sl pos1))) =
| valid_facts (parse_bitsum b tag_of_data type_of_tag synth_case p f) h sl pos;
parse_bitsum_eq b tag_of_data type_of_tag synth_case p f (bytes_of_slice_from h sl pos);
valid_facts (parse_bitsum' b p) h sl pos;
let tg = contents (parse_bitsum' b p) h sl pos in
let k = bitsum'_key_of_t b tg in
let pos1 = get_valid_pos (parse_bitsum' b p) h sl pos in
valid_facts (dsnd (f k)) h sl pos1 | false |
Hacl.Impl.K256.Qinv.fst | Hacl.Impl.K256.Qinv.linv_ctx | val linv_ctx (a: LSeq.lseq uint64 0) : Type0 | val linv_ctx (a: LSeq.lseq uint64 0) : Type0 | let linv_ctx (a:LSeq.lseq uint64 0) : Type0 = True | {
"file_name": "code/k256/Hacl.Impl.K256.Qinv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 50,
"end_line": 25,
"start_col": 0,
"start_line": 25
} | module Hacl.Impl.K256.Qinv
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.K256.Scalar
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Spec.K256
module SI = Hacl.Spec.K256.Qinv
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module SD = Hacl.Spec.Bignum.Definitions
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0" | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.K256.Qinv.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.K256.Scalar.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.K256.Qinv.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "SD"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Qinv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.K256.Scalar",
"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.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Lib.Sequence.lseq Lib.IntTypes.uint64 0 -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Prims.l_True"
] | [] | false | false | false | false | true | let linv_ctx (a: LSeq.lseq uint64 0) : Type0 =
| True | false |
LowParse.Low.BitSum.fst | LowParse.Low.BitSum.validate_bitsum_cases_bitsum'_cons | val validate_bitsum_cases_bitsum'_cons
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat{key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot})
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(k: key)
(r: bitfield cl key_size)
(l2:
list (key & bitfield cl key_size)
{ e == l1 `L.append` ((k, r) :: l2) /\ list_mem k (list_map fst e) /\
enum_repr_of_key e k == r /\ e == (l1 `L.append` [(k, r)]) `L.append` l2 })
(destr_payload: validate_bitsum_cases_t u#r (payload k))
(destr_tail:
validate_bitsum_cases_bitsum'_t u#r
cl
bitsum'_size
key
key_size
e
payload
(l1 `L.append` [(k, r)])
l2)
: Tot
(validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload l1 ((k, r) :: l2)) | val validate_bitsum_cases_bitsum'_cons
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat{key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot})
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(k: key)
(r: bitfield cl key_size)
(l2:
list (key & bitfield cl key_size)
{ e == l1 `L.append` ((k, r) :: l2) /\ list_mem k (list_map fst e) /\
enum_repr_of_key e k == r /\ e == (l1 `L.append` [(k, r)]) `L.append` l2 })
(destr_payload: validate_bitsum_cases_t u#r (payload k))
(destr_tail:
validate_bitsum_cases_bitsum'_t u#r
cl
bitsum'_size
key
key_size
e
payload
(l1 `L.append` [(k, r)])
l2)
: Tot
(validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload l1 ((k, r) :: l2)) | let validate_bitsum_cases_bitsum'_cons
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(k: key)
(r: bitfield cl key_size)
(l2: list (key & bitfield cl key_size) {
e == l1 `L.append` ((k, r) :: l2) /\
list_mem k (list_map fst e) /\
enum_repr_of_key e k == r /\
e == (l1 `L.append` [(k, r)]) `L.append` l2
})
(destr_payload: validate_bitsum_cases_t u#r (payload k))
(destr_tail: validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload (l1 `L.append` [(k, r)]) l2)
: Tot (validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload l1 ((k, r) :: l2))
= fun u f v x xr #rrel #rel sl pos ->
// [@inline_let]
let _ =
enum_repr_of_key_append_cons e l1 (k, r) l2
in
[@inline_let] let yr = cl.bitfield_eq_rhs x (bitsum'_size - key_size) bitsum'_size r in
[@inline_let] let cond = (xr <: t) = yr in
[@inline_let] let _ =
assert (cond == true <==> (cl.get_bitfield x (bitsum'_size - key_size) bitsum'_size <: bitfield cl key_size) == r)
in
if cond
then
destr_payload
(fun x -> u (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> f (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> v (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
x sl pos
else
[@inline_let] let _ =
L.append_assoc l1 [(k, r)] l2;
L.map_append snd l1 [(k, r)];
L.append_mem (L.map snd l1) (L.map snd [(k, r)]) (cl.get_bitfield x (bitsum'_size - key_size) bitsum'_size <: bitfield cl key_size)
in
destr_tail u f v (x <: t) xr sl pos | {
"file_name": "src/lowparse/LowParse.Low.BitSum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 41,
"end_line": 204,
"start_col": 0,
"start_line": 160
} | module LowParse.Low.BitSum
include LowParse.Low.Combinators
include LowParse.Spec.BitSum
module U32 = FStar.UInt32
module HS = FStar.HyperStack
#push-options "--z3rlimit 16"
inline_for_extraction
let validate_bitsum'
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(b: bitsum' cl tot)
(#k: parser_kind)
(#p: parser k t)
(v: validator p)
(r: leaf_reader p)
(phi: filter_bitsum'_t b)
: Tot (validator (parse_bitsum' b p))
= synth_bitsum'_injective b;
validate_synth
(validate_filter
v
r
(filter_bitsum' b)
(fun x -> phi x))
(synth_bitsum' b)
()
module HST = FStar.HyperStack.ST
inline_for_extraction
noextract
let validate_bitsum_cases_t
(#tot: pos)
(#t: eqtype)
(#cl: uint_t tot t)
(#from: nat)
(b: bitsum' cl from)
: Tot (Type u#(r+1))
= (u: (bitsum'_key_type b -> Tot (Type u#r))) ->
(f: ((x: bitsum'_key_type b) -> Tot (k: parser_kind & parser k (u x)))) ->
(v: ((x: bitsum'_key_type b) -> Tot (validator (dsnd (f x))))) ->
(x: parse_filter_refine (filter_bitsum' b)) ->
Tot (validator (dsnd (f (bitsum'_key_of_t b (synth_bitsum' b x)))))
inline_for_extraction
let validate_bitsum_cases_bitstop
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
: Tot (validate_bitsum_cases_t u#r #tot #t #cl #0 (BitStop ()))
= fun u f v x #rrel #rel sl pos ->
v () sl pos
inline_for_extraction
let validate_bitsum_cases_bitfield
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(sz: nat { sz > 0 /\ sz <= bitsum'_size /\ bitsum'_size <= tot })
(rest: bitsum' cl (bitsum'_size - sz))
(phi: validate_bitsum_cases_t u#r rest)
: Tot (validate_bitsum_cases_t u#r (BitField sz rest))
= fun u f v x #rrel #rel sl pos ->
phi
(fun x -> u (coerce (bitsum'_key_type (BitField sz rest)) x))
(fun x -> f (coerce (bitsum'_key_type (BitField sz rest)) x))
(fun x -> v (coerce (bitsum'_key_type (BitField sz rest)) x))
x
sl
pos
inline_for_extraction
let validate_bitsum_cases_bitsum_gen
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(key_of: ((x: enum_repr e) -> Tot (y: enum_key e { y == enum_key_of_repr e x })))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(destr_payload: ((k: enum_key e) -> Tot (validate_bitsum_cases_t u#r (payload k))))
: Tot (validate_bitsum_cases_t u#r (BitSum' key key_size e payload))
= fun u f v x_ #rrel #rel sl pos ->
[@inline_let]
let r = cl.get_bitfield x_ (bitsum'_size - key_size) bitsum'_size in
[@inline_let]
let k = key_of r in
destr_payload
k
(fun x -> u (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> f (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> v (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
x_ sl pos
module L = FStar.List.Tot
inline_for_extraction
noextract
let validate_bitsum_cases_bitsum'_t
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(l2: list (key & bitfield cl key_size) { e == l1 `L.append` l2 } )
: Tot (Type u#(r+1))
= (u: (bitsum'_key_type (BitSum' key key_size e payload) -> Tot (Type u#r))) ->
(f: ((x: bitsum'_key_type (BitSum' key key_size e payload)) -> Tot (k: parser_kind & parser k (u x)))) ->
(v: ((x: bitsum'_key_type (BitSum' key key_size e payload)) -> Tot (validator (dsnd (f x))))) ->
(x: parse_filter_refine (filter_bitsum' (BitSum' key key_size e payload)) { ~ (list_mem (cl.get_bitfield x (bitsum'_size - key_size) bitsum'_size <: bitfield cl key_size) (list_map snd l1)) }) ->
(xr: t { xr == cl.bitfield_eq_lhs x (bitsum'_size - key_size) bitsum'_size }) ->
Tot (validator (dsnd (f (bitsum'_key_of_t (BitSum' key key_size e payload) (synth_bitsum' (BitSum' key key_size e payload) x)))))
inline_for_extraction
let validate_bitsum_cases_bitsum'_intro
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(phi: validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload [] e)
: Tot (validate_bitsum_cases_t u#r (BitSum' key key_size e payload))
= fun u f v x #rrel #rel sl pos ->
let xr = cl.bitfield_eq_lhs x (bitsum'_size - key_size) bitsum'_size in
phi u f v x xr sl pos
inline_for_extraction
let validate_bitsum_cases_bitsum'_nil
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat { key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot })
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(h: squash (e == e `L.append` []))
: Tot (validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload e [])
= (fun u f v x xr #rrel #rel sl pos ->
assert False;
validator_error_generic (* dummy *))
#push-options "--z3rlimit 32" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.BitSum.fst.checked",
"LowParse.Low.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.BitSum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.BitSum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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
}
] | {
"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": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
cl: LowParse.BitFields.uint_t tot t ->
bitsum'_size: Prims.nat ->
key: Prims.eqtype ->
key_size: Prims.nat{key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot} ->
e: LowParse.Spec.Enum.enum key (LowParse.BitFields.bitfield cl key_size) ->
payload:
(_: LowParse.Spec.Enum.enum_key e -> LowParse.Spec.BitSum.bitsum' cl (bitsum'_size - key_size)
) ->
l1: Prims.list (key * LowParse.BitFields.bitfield cl key_size) ->
k: key ->
r: LowParse.BitFields.bitfield cl key_size ->
l2:
Prims.list (key * LowParse.BitFields.bitfield cl key_size)
{ e == l1 @ (k, r) :: l2 /\
LowParse.Spec.Enum.list_mem k (LowParse.Spec.Enum.list_map FStar.Pervasives.Native.fst e) /\
LowParse.Spec.Enum.enum_repr_of_key e k == r /\ e == (l1 @ [k, r]) @ l2 } ->
destr_payload: LowParse.Low.BitSum.validate_bitsum_cases_t (payload k) ->
destr_tail:
LowParse.Low.BitSum.validate_bitsum_cases_bitsum'_t cl
bitsum'_size
key
key_size
e
payload
(l1 @ [k, r])
l2
-> LowParse.Low.BitSum.validate_bitsum_cases_bitsum'_t cl
bitsum'_size
key
key_size
e
payload
l1
((k, r) :: l2) | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"Prims.eqtype",
"LowParse.BitFields.uint_t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"LowParse.Spec.Enum.enum",
"LowParse.BitFields.bitfield",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.BitSum.bitsum'",
"Prims.op_Subtraction",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.eq2",
"FStar.List.Tot.Base.append",
"Prims.Cons",
"FStar.Pervasives.Native.Mktuple2",
"LowParse.Spec.Enum.list_mem",
"LowParse.Spec.Enum.list_map",
"FStar.Pervasives.Native.fst",
"LowParse.Spec.Enum.enum_repr_of_key",
"Prims.Nil",
"LowParse.Low.BitSum.validate_bitsum_cases_t",
"LowParse.Low.BitSum.validate_bitsum_cases_bitsum'_t",
"LowParse.Spec.BitSum.bitsum'_key_type",
"LowParse.Spec.BitSum.BitSum'",
"Prims.dtuple2",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.validator",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.BitSum.filter_bitsum'",
"Prims.l_not",
"LowParse.BitFields.__proj__Mkuint_t__item__get_bitfield",
"FStar.Pervasives.Native.snd",
"LowParse.BitFields.__proj__Mkuint_t__item__bitfield_eq_lhs",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt64.t",
"LowParse.Spec.BitSum.bitsum'_key_type_intro_BitSum'",
"Prims.Mkdtuple2",
"Prims.bool",
"Prims.unit",
"FStar.List.Tot.Properties.append_mem",
"FStar.List.Tot.Base.map",
"FStar.List.Tot.Properties.map_append",
"FStar.List.Tot.Properties.append_assoc",
"Prims._assert",
"Prims.l_iff",
"Prims.op_Equality",
"LowParse.BitFields.__proj__Mkuint_t__item__bitfield_eq_rhs",
"LowParse.Spec.Enum.enum_repr_of_key_append_cons"
] | [] | false | false | false | false | false | let validate_bitsum_cases_bitsum'_cons
(#tot: pos)
(#t: eqtype)
(cl: uint_t tot t)
(bitsum'_size: nat)
(key: eqtype)
(key_size: nat{key_size > 0 /\ key_size <= bitsum'_size /\ bitsum'_size <= tot})
(e: enum key (bitfield cl key_size))
(payload: (enum_key e -> Tot (bitsum' cl (bitsum'_size - key_size))))
(l1: list (key & bitfield cl key_size))
(k: key)
(r: bitfield cl key_size)
(l2:
list (key & bitfield cl key_size)
{ e == l1 `L.append` ((k, r) :: l2) /\ list_mem k (list_map fst e) /\
enum_repr_of_key e k == r /\ e == (l1 `L.append` [(k, r)]) `L.append` l2 })
(destr_payload: validate_bitsum_cases_t u#r (payload k))
(destr_tail:
validate_bitsum_cases_bitsum'_t u#r
cl
bitsum'_size
key
key_size
e
payload
(l1 `L.append` [(k, r)])
l2)
: Tot
(validate_bitsum_cases_bitsum'_t u#r cl bitsum'_size key key_size e payload l1 ((k, r) :: l2)) =
| fun u f v x xr #rrel #rel sl pos ->
let _ = enum_repr_of_key_append_cons e l1 (k, r) l2 in
[@@ inline_let ]let yr = cl.bitfield_eq_rhs x (bitsum'_size - key_size) bitsum'_size r in
[@@ inline_let ]let cond = (xr <: t) = yr in
[@@ inline_let ]let _ =
assert (cond == true <==>
(cl.get_bitfield x (bitsum'_size - key_size) bitsum'_size <: bitfield cl key_size) == r)
in
if cond
then
destr_payload (fun x ->
u (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |)))
(fun x -> f (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |))
)
(fun x -> v (bitsum'_key_type_intro_BitSum' cl bitsum'_size key key_size e payload (| k, x |))
)
x
sl
pos
else
[@@ inline_let ]let _ =
L.append_assoc l1 [(k, r)] l2;
L.map_append snd l1 [(k, r)];
L.append_mem (L.map snd l1)
(L.map snd [(k, r)])
(cl.get_bitfield x (bitsum'_size - key_size) bitsum'_size <: bitfield cl key_size)
in
destr_tail u f v (x <: t) xr sl pos | false |
Hacl.Impl.K256.Qinv.fst | Hacl.Impl.K256.Qinv.mk_to_k256_scalar_comm_monoid | val mk_to_k256_scalar_comm_monoid:BE.to_comm_monoid U64 4ul 0ul | val mk_to_k256_scalar_comm_monoid:BE.to_comm_monoid U64 4ul 0ul | let mk_to_k256_scalar_comm_monoid : BE.to_comm_monoid U64 4ul 0ul = {
BE.a_spec = S.qelem;
BE.comm_monoid = SI.nat_mod_comm_monoid;
BE.linv_ctx = linv_ctx;
BE.linv = linv;
BE.refl = refl;
} | {
"file_name": "code/k256/Hacl.Impl.K256.Qinv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 1,
"end_line": 42,
"start_col": 0,
"start_line": 36
} | module Hacl.Impl.K256.Qinv
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.K256.Scalar
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Spec.K256
module SI = Hacl.Spec.K256.Qinv
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module SD = Hacl.Spec.Bignum.Definitions
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
unfold
let linv_ctx (a:LSeq.lseq uint64 0) : Type0 = True
unfold
let linv (a:LSeq.lseq uint64 4) : Type0 =
SD.bn_v #U64 #4 a < S.q
unfold
let refl (a:LSeq.lseq uint64 4{linv a}) : GTot S.qelem =
SD.bn_v #U64 #4 a | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.K256.Qinv.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.K256.Scalar.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.K256.Qinv.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "SD"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Qinv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.K256.Scalar",
"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.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Hacl.Impl.Exponentiation.Definitions.to_comm_monoid Lib.IntTypes.U64
(4ul <: FStar.UInt32.t)
(0ul <: FStar.UInt32.t) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.Exponentiation.Definitions.Mkto_comm_monoid",
"Lib.IntTypes.U64",
"FStar.UInt32.uint_to_t",
"Spec.K256.PointOps.qelem",
"Hacl.Spec.K256.Qinv.nat_mod_comm_monoid",
"Hacl.Impl.K256.Qinv.linv_ctx",
"Hacl.Impl.K256.Qinv.linv",
"Hacl.Impl.K256.Qinv.refl"
] | [] | false | false | false | false | false | let mk_to_k256_scalar_comm_monoid:BE.to_comm_monoid U64 4ul 0ul =
| {
BE.a_spec = S.qelem;
BE.comm_monoid = SI.nat_mod_comm_monoid;
BE.linv_ctx = linv_ctx;
BE.linv = linv;
BE.refl = refl
} | false |
Hacl.Impl.K256.Qinv.fst | Hacl.Impl.K256.Qinv.one_mod | val one_mod : BE.lone_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid | val one_mod : BE.lone_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid | let one_mod ctx one = make_u64_4 one (u64 1, u64 0, u64 0, u64 0) | {
"file_name": "code/k256/Hacl.Impl.K256.Qinv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 65,
"end_line": 47,
"start_col": 0,
"start_line": 47
} | module Hacl.Impl.K256.Qinv
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.K256.Scalar
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Spec.K256
module SI = Hacl.Spec.K256.Qinv
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module SD = Hacl.Spec.Bignum.Definitions
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
unfold
let linv_ctx (a:LSeq.lseq uint64 0) : Type0 = True
unfold
let linv (a:LSeq.lseq uint64 4) : Type0 =
SD.bn_v #U64 #4 a < S.q
unfold
let refl (a:LSeq.lseq uint64 4{linv a}) : GTot S.qelem =
SD.bn_v #U64 #4 a
inline_for_extraction noextract
let mk_to_k256_scalar_comm_monoid : BE.to_comm_monoid U64 4ul 0ul = {
BE.a_spec = S.qelem;
BE.comm_monoid = SI.nat_mod_comm_monoid;
BE.linv_ctx = linv_ctx;
BE.linv = linv;
BE.refl = refl;
}
inline_for_extraction noextract | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.K256.Qinv.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.K256.Scalar.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.K256.Qinv.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "SD"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Qinv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.K256.Scalar",
"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.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Hacl.Impl.Exponentiation.Definitions.lone_st Lib.IntTypes.U64
4ul
0ul
Hacl.Impl.K256.Qinv.mk_to_k256_scalar_comm_monoid | Prims.Tot | [
"total"
] | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.__uint_to_t",
"Hacl.K256.Scalar.make_u64_4",
"FStar.Pervasives.Native.Mktuple4",
"Lib.IntTypes.uint64",
"Lib.IntTypes.u64",
"Prims.unit"
] | [] | false | false | false | false | false | let one_mod ctx one =
| make_u64_4 one (u64 1, u64 0, u64 0, u64 0) | false |
Hacl.Impl.K256.Qinv.fst | Hacl.Impl.K256.Qinv.mk_k256_scalar_concrete_ops | val mk_k256_scalar_concrete_ops:BE.concrete_ops U64 4ul 0ul | val mk_k256_scalar_concrete_ops:BE.concrete_ops U64 4ul 0ul | let mk_k256_scalar_concrete_ops : BE.concrete_ops U64 4ul 0ul = {
BE.to = mk_to_k256_scalar_comm_monoid;
BE.lone = one_mod;
BE.lmul = mul_mod;
BE.lsqr = sqr_mod;
} | {
"file_name": "code/k256/Hacl.Impl.K256.Qinv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 1,
"end_line": 66,
"start_col": 0,
"start_line": 61
} | module Hacl.Impl.K256.Qinv
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.K256.Scalar
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Spec.K256
module SI = Hacl.Spec.K256.Qinv
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module SD = Hacl.Spec.Bignum.Definitions
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
unfold
let linv_ctx (a:LSeq.lseq uint64 0) : Type0 = True
unfold
let linv (a:LSeq.lseq uint64 4) : Type0 =
SD.bn_v #U64 #4 a < S.q
unfold
let refl (a:LSeq.lseq uint64 4{linv a}) : GTot S.qelem =
SD.bn_v #U64 #4 a
inline_for_extraction noextract
let mk_to_k256_scalar_comm_monoid : BE.to_comm_monoid U64 4ul 0ul = {
BE.a_spec = S.qelem;
BE.comm_monoid = SI.nat_mod_comm_monoid;
BE.linv_ctx = linv_ctx;
BE.linv = linv;
BE.refl = refl;
}
inline_for_extraction noextract
val one_mod : BE.lone_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let one_mod ctx one = make_u64_4 one (u64 1, u64 0, u64 0, u64 0)
inline_for_extraction noextract
val mul_mod : BE.lmul_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let mul_mod ctx x y xy = qmul xy x y
inline_for_extraction noextract
val sqr_mod : BE.lsqr_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let sqr_mod ctx x xx = qsqr xx x | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.K256.Qinv.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.K256.Scalar.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.K256.Qinv.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "SD"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Qinv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.K256.Scalar",
"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.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Hacl.Impl.Exponentiation.Definitions.concrete_ops Lib.IntTypes.U64
(4ul <: FStar.UInt32.t)
(0ul <: FStar.UInt32.t) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.Exponentiation.Definitions.Mkconcrete_ops",
"Lib.IntTypes.U64",
"FStar.UInt32.uint_to_t",
"FStar.Ghost.hide",
"Hacl.Impl.Exponentiation.Definitions.to_comm_monoid",
"Hacl.Impl.K256.Qinv.mk_to_k256_scalar_comm_monoid",
"Hacl.Impl.K256.Qinv.one_mod",
"Hacl.Impl.K256.Qinv.mul_mod",
"Hacl.Impl.K256.Qinv.sqr_mod"
] | [] | false | false | false | false | false | let mk_k256_scalar_concrete_ops:BE.concrete_ops U64 4ul 0ul =
| { BE.to = mk_to_k256_scalar_comm_monoid; BE.lone = one_mod; BE.lmul = mul_mod; BE.lsqr = sqr_mod } | false |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.