effect
stringclasses 48
values | original_source_type
stringlengths 0
23k
| opens_and_abbrevs
listlengths 2
92
| isa_cross_project_example
bool 1
class | source_definition
stringlengths 9
57.9k
| partial_definition
stringlengths 7
23.3k
| is_div
bool 2
classes | is_type
null | is_proof
bool 2
classes | completed_definiton
stringlengths 1
250k
| dependencies
dict | effect_flags
sequencelengths 0
2
| ideal_premises
sequencelengths 0
236
| mutual_with
sequencelengths 0
11
| file_context
stringlengths 0
407k
| interleaved
bool 1
class | is_simply_typed
bool 2
classes | file_name
stringlengths 5
48
| vconfig
dict | is_simple_lemma
null | source_type
stringlengths 10
23k
| proof_features
sequencelengths 0
1
| name
stringlengths 8
95
| source
dict | verbose_type
stringlengths 1
7.42k
| source_range
dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Prims.Tot | val sha384_update: update_vec_t SHA2_384 M32 | [
{
"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
}
] | 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 | val sha384_update: update_vec_t SHA2_384 M32
let sha384_update b st = | false | null | false | 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 | {
"checked_file": "Hacl.SHA2.Scalar32.fst.checked",
"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"
} | [
"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"
] | [] | 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" | false | true | Hacl.SHA2.Scalar32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val sha384_update: update_vec_t SHA2_384 M32 | [] | Hacl.SHA2.Scalar32.sha384_update | {
"file_name": "code/sha2-mb/Hacl.SHA2.Scalar32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.SHA2.Generic.update_vec_t Spec.Hash.Definitions.SHA2_384 Hacl.Spec.SHA2.Vec.M32 | {
"end_col": 20,
"end_line": 78,
"start_col": 2,
"start_line": 75
} |
Prims.Tot | val sha224_update_nblocks: update_nblocks_vec_t' SHA2_224 M32 | [
{
"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
}
] | 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 | val sha224_update_nblocks: update_nblocks_vec_t' SHA2_224 M32
let sha224_update_nblocks len b st = | false | null | false | 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 | {
"checked_file": "Hacl.SHA2.Scalar32.fst.checked",
"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"
} | [
"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"
] | [] | 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] | false | true | Hacl.SHA2.Scalar32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val sha224_update_nblocks: update_nblocks_vec_t' SHA2_224 M32 | [] | Hacl.SHA2.Scalar32.sha224_update_nblocks | {
"file_name": "code/sha2-mb/Hacl.SHA2.Scalar32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.SHA2.Generic.update_nblocks_vec_t' Spec.Hash.Definitions.SHA2_224 Hacl.Spec.SHA2.Vec.M32 | {
"end_col": 32,
"end_line": 46,
"start_col": 36,
"start_line": 43
} |
Prims.Tot | [
{
"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
}
] | false | let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length | let less_than_max_input_length = | false | null | false | Spec.Hash.Definitions.less_than_max_input_length | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [
"total"
] | [
"Spec.Hash.Definitions.less_than_max_input_length"
] | [] | 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 | false | true | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val less_than_max_input_length : l: Prims.int -> a: Spec.Hash.Definitions.hash_alg -> Prims.bool | [] | Hacl.Spec.RSAPSS.less_than_max_input_length | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | l: Prims.int -> a: Spec.Hash.Definitions.hash_alg -> Prims.bool | {
"end_col": 81,
"end_line": 159,
"start_col": 33,
"start_line": 159
} |
|
Prims.Tot | [
{
"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
}
] | false | 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 pkey_len_pre (t: limb_t) (modBits eBits: size_nat) = | false | null | false | 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": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.l_and",
"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"
] | [] | 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) | false | true | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val pkey_len_pre : t: Hacl.Spec.Bignum.Definitions.limb_t ->
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat
-> Prims.logical | [] | Hacl.Spec.RSAPSS.pkey_len_pre | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
t: Hacl.Spec.Bignum.Definitions.limb_t ->
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat
-> Prims.logical | {
"end_col": 59,
"end_line": 100,
"start_col": 65,
"start_line": 95
} |
|
Prims.Tot | 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 | [
{
"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
}
] | false | 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_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 = | false | null | false | 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 | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [
"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"
] | [] | 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 | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 | [] | Hacl.Spec.RSAPSS.rsapss_verify_pre | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 39,
"end_line": 238,
"start_col": 2,
"start_line": 236
} |
Prims.Tot | [
{
"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
}
] | false | 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 | let skey_len_pre (t: limb_t) (modBits eBits dBits: size_nat) = | false | null | false | 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 | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [
"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"
] | [] | 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 | false | true | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 | [] | Hacl.Spec.RSAPSS.skey_len_pre | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
t: Hacl.Spec.Bignum.Definitions.limb_t ->
modBits: Lib.IntTypes.size_nat ->
eBits: Lib.IntTypes.size_nat ->
dBits: Lib.IntTypes.size_nat
-> Prims.logical | {
"end_col": 79,
"end_line": 107,
"start_col": 82,
"start_line": 103
} |
|
Prims.Tot | val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool | [
{
"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
}
] | 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)) | 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 = | false | null | false | if (modBits - 1) % 8 <> 0 then true else BB.unsafe_bool_of_limb0 (bn_get_ith_bit m (modBits - 1)) | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [
"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"
] | [] | 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 | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val bn_lt_pow2: #t:limb_t -> modBits:size_pos{1 < modBits} -> m:lbignum t (blocks modBits (bits t)) -> bool | [] | Hacl.Spec.RSAPSS.bn_lt_pow2 | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 63,
"end_line": 33,
"start_col": 2,
"start_line": 32
} |
Prims.Tot | 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 | [
{
"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
}
] | false | 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_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 = | false | null | false | 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) | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [
"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"
] | [] | 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 | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 | [] | Hacl.Spec.RSAPSS.rsapss_verify_post1 | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 67,
"end_line": 288,
"start_col": 2,
"start_line": 280
} |
Prims.Tot | 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 | [
{
"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
}
] | false | 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_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 = | false | null | false | 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) | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [
"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"
] | [] | 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 | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 | [] | Hacl.Spec.RSAPSS.rsapss_verify_post | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 66,
"end_line": 263,
"start_col": 2,
"start_line": 254
} |
Prims.Tot | 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))} | [
{
"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
}
] | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [
"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"
] | [] | 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))} | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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))} | [] | Hacl.Spec.RSAPSS.rsapss_check_exponent | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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)) } | {
"end_col": 3,
"end_line": 780,
"start_col": 38,
"start_line": 773
} |
Prims.Pure | 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) | [
{
"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
}
] | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [] | [
"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"
] | [] | 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) | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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) | [] | Hacl.Spec.RSAPSS.rsapss_verify_ | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 9,
"end_line": 630,
"start_col": 65,
"start_line": 625
} |
Prims.Tot | 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))} | [
{
"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
}
] | 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 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 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 = | false | null | false | 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 | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [
"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"
] | [] | 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))} | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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))} | [] | Hacl.Spec.RSAPSS.bn_check_num_bits | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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)) } | {
"end_col": 3,
"end_line": 748,
"start_col": 31,
"start_line": 738
} |
FStar.Pervasives.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))) | [
{
"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
}
] | 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 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_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 = | false | null | true | 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)) | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [
"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"
] | [] | 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))) | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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))) | [] | Hacl.Spec.RSAPSS.bn_lt_pow2_lemma | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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))) | {
"end_col": 44,
"end_line": 75,
"start_col": 35,
"start_line": 61
} |
Prims.Pure | 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) | [
{
"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
}
] | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [] | [
"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"
] | [] | 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) | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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) | [] | Hacl.Spec.RSAPSS.rsapss_verify_bn_to_msg | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 42,
"end_line": 580,
"start_col": 60,
"start_line": 565
} |
Prims.Tot | 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))} | [
{
"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
}
] | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [
"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"
] | [] | 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))} | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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))} | [] | Hacl.Spec.RSAPSS.rsapss_check_modulus | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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)) } | {
"end_col": 3,
"end_line": 767,
"start_col": 39,
"start_line": 754
} |
Prims.Pure | 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) | [
{
"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
}
] | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [] | [
"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"
] | [] | 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) | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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) | [] | Hacl.Spec.RSAPSS.rsapss_pkey_verify | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 9,
"end_line": 1002,
"start_col": 72,
"start_line": 995
} |
Prims.Tot | 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 | [
{
"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
}
] | false | 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_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 = | false | null | false | 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 | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [
"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"
] | [] | 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 | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 | [] | Hacl.Spec.RSAPSS.rsapss_skey_pre | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 35,
"end_line": 147,
"start_col": 49,
"start_line": 137
} |
Prims.Tot | 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 | [
{
"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
}
] | false | 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_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 = | false | null | false | 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) | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [
"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"
] | [] | 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 | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 | [] | Hacl.Spec.RSAPSS.rsapss_sign_post1 | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 72,
"end_line": 226,
"start_col": 2,
"start_line": 214
} |
Prims.Pure | 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) | [
{
"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
}
] | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [] | [
"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"
] | [] | 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) | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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) | [] | Hacl.Spec.RSAPSS.rsapss_verify_compute_msg | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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))) | {
"end_col": 48,
"end_line": 606,
"start_col": 58,
"start_line": 593
} |
Prims.Pure | 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) | [
{
"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
}
] | 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 (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 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 = | false | null | false | 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 | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [] | [
"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"
] | [] | 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) | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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) | [] | Hacl.Spec.RSAPSS.rsapss_verify | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 9,
"end_line": 731,
"start_col": 66,
"start_line": 715
} |
Prims.Tot | 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 | [
{
"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
}
] | false | 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_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 = | false | null | false | 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) | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [
"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"
] | [] | 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 | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 | [] | Hacl.Spec.RSAPSS.rsapss_load_pkey_post | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 48,
"end_line": 804,
"start_col": 55,
"start_line": 791
} |
Prims.Tot | 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 | [
{
"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
}
] | false | 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_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 = | false | null | false | 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) | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [
"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"
] | [] | 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 | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 | [] | Hacl.Spec.RSAPSS.rsapss_sign_post | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 35,
"end_line": 196,
"start_col": 2,
"start_line": 183
} |
Prims.Pure | 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) | [
{
"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
}
] | 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 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_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 = | false | null | false | 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 | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [] | [
"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"
] | [] | 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) | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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) | [] | Hacl.Spec.RSAPSS.rsapss_sign | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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)) | {
"end_col": 15,
"end_line": 516,
"start_col": 73,
"start_line": 502
} |
Prims.Tot | 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 | [
{
"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
}
] | false | 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_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 = | false | null | false | 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 | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [
"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"
] | [] | 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 | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 | [] | Hacl.Spec.RSAPSS.rsapss_pkey_pre | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 35,
"end_line": 127,
"start_col": 43,
"start_line": 116
} |
FStar.Pervasives.Lemma | 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)))) | [
{
"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
}
] | 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) | 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 = | false | null | true | 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) | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [
"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"
] | [] | 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)))) | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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)))) | [] | Hacl.Spec.RSAPSS.bn_eval_sub | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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)))) | {
"end_col": 56,
"end_line": 92,
"start_col": 30,
"start_line": 82
} |
Prims.Pure | 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)) | [
{
"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
}
] | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [] | [
"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"
] | [] | 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)) | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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)) | [] | Hacl.Spec.RSAPSS.rsapss_sign_msg_to_bn | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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))) | {
"end_col": 3,
"end_line": 359,
"start_col": 61,
"start_line": 339
} |
Prims.Pure | 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)) | [
{
"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
}
] | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [] | [
"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"
] | [] | 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)) | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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)) | [] | Hacl.Spec.RSAPSS.rsapss_skey_sign | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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)) | {
"end_col": 15,
"end_line": 975,
"start_col": 82,
"start_line": 968
} |
Prims.Pure | 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) | [
{
"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
}
] | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [] | [
"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"
] | [] | 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) | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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) | [] | Hacl.Spec.RSAPSS.rsapss_sign_ | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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)) | {
"end_col": 56,
"end_line": 412,
"start_col": 69,
"start_line": 410
} |
Prims.Tot | 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))) | [
{
"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
}
] | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [
"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"
] | [] | 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))) | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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))) | [] | Hacl.Spec.RSAPSS.rsapss_load_pkey | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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)) | {
"end_col": 32,
"end_line": 854,
"start_col": 45,
"start_line": 845
} |
Prims.Pure | 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) | [
{
"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
}
] | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [] | [
"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"
] | [] | 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) | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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) | [] | Hacl.Spec.RSAPSS.rsapss_sign_compute_sgnt | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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)) | {
"end_col": 12,
"end_line": 389,
"start_col": 60,
"start_line": 377
} |
Prims.Pure | 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) | [
{
"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
}
] | 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 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:
#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 = | false | null | false | 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 | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [] | [
"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"
] | [] | 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) | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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) | [] | Hacl.Spec.RSAPSS.rsapss_verify_bn | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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))) | {
"end_col": 19,
"end_line": 550,
"start_col": 52,
"start_line": 530
} |
FStar.Pervasives.Lemma | 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)) | [
{
"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
}
] | 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);
} | 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 = | false | null | true | 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);
} | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [
"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"
] | [] | 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)) | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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)) | [] | Hacl.Spec.RSAPSS.bn_eval_lt_pow2_modBits | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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)) | {
"end_col": 5,
"end_line": 54,
"start_col": 2,
"start_line": 44
} |
Prims.Tot | 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 | [
{
"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
}
] | false | 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_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 = | false | null | false | 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)) | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [
"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"
] | [] | 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 | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 | [] | Hacl.Spec.RSAPSS.rsapss_load_skey_post | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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 | {
"end_col": 49,
"end_line": 834,
"start_col": 64,
"start_line": 818
} |
Prims.Tot | 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))) | [
{
"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
}
] | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [
"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"
] | [] | 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))) | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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))) | [] | Hacl.Spec.RSAPSS.rsapss_load_skey | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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)) | {
"end_col": 10,
"end_line": 911,
"start_col": 54,
"start_line": 904
} |
FStar.Pervasives.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)) | [
{
"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
}
] | 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 | 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 = | false | null | true | 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 | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [
"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"
] | [] | 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)) | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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)) | [] | Hacl.Spec.RSAPSS.rsapss_load_pkey_lemma | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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)) | {
"end_col": 20,
"end_line": 891,
"start_col": 51,
"start_line": 868
} |
FStar.Pervasives.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)) | [
{
"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
}
] | 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 | 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 = | false | null | true | 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 | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [
"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"
] | [] | 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)) | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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)) | [] | Hacl.Spec.RSAPSS.rsapss_load_skey_lemma | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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)) | {
"end_col": 49,
"end_line": 945,
"start_col": 60,
"start_line": 927
} |
FStar.Pervasives.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)) | [
{
"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
}
] | 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 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_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 = | false | null | true | 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
() | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [
"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"
] | [] | 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)) | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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)) | [] | Hacl.Spec.RSAPSS.rsapss_verify_lemma | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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)) | {
"end_col": 4,
"end_line": 697,
"start_col": 70,
"start_line": 650
} |
Prims.Pure | 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) | [
{
"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
}
] | 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 | 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 = | false | null | false | 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 | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [] | [
"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"
] | [] | 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) | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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) | [] | Hacl.Spec.RSAPSS.rsapss_sign_bn | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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))) | {
"end_col": 32,
"end_line": 324,
"start_col": 50,
"start_line": 306
} |
FStar.Pervasives.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)) | [
{
"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
}
] | 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' | 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 = | false | null | true | 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' | {
"checked_file": "Hacl.Spec.RSAPSS.fst.checked",
"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"
} | [
"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"
] | [] | 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)) | false | false | Hacl.Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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)) | [] | Hacl.Spec.RSAPSS.rsapss_sign_lemma | {
"file_name": "code/rsapss/Hacl.Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
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)) | {
"end_col": 27,
"end_line": 482,
"start_col": 74,
"start_line": 433
} |
Prims.Tot | val pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
([@@@smt_fallback]f:perm)
([@@@smt_fallback]v:a)
: vprop | [
{
"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
}
] | 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 | 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 = | false | null | false | MR.pts_to #a #p r f v | {
"checked_file": "Steel.ST.MonotonicReference.fst.checked",
"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"
} | [
"total"
] | [
"FStar.Preorder.preorder",
"Steel.ST.MonotonicReference.ref",
"Steel.FractionalPermission.perm",
"Steel.MonotonicReference.pts_to",
"Steel.Effect.Common.vprop"
] | [] | (*
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) | false | false | Steel.ST.MonotonicReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
([@@@smt_fallback]f:perm)
([@@@smt_fallback]v:a)
: vprop | [] | Steel.ST.MonotonicReference.pts_to | {
"file_name": "lib/steel/Steel.ST.MonotonicReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.ST.MonotonicReference.ref a p -> f: Steel.FractionalPermission.perm -> v: a
-> Steel.Effect.Common.vprop | {
"end_col": 26,
"end_line": 34,
"start_col": 5,
"start_line": 34
} |
Prims.Tot | val witnessed (#a:Type u#0) (#p:Preorder.preorder a) (r:ref a p) (fact:property a)
: Type0 | [
{
"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
}
] | false | let witnessed (#a:Type u#0)
(#p:Preorder.preorder a)
(r:ref a p)
(fact:property a)
: Type0
= MR.witnessed r fact | 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 = | false | null | false | MR.witnessed r fact | {
"checked_file": "Steel.ST.MonotonicReference.fst.checked",
"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"
} | [
"total"
] | [
"FStar.Preorder.preorder",
"Steel.ST.MonotonicReference.ref",
"Steel.ST.MonotonicReference.property",
"Steel.MonotonicReference.witnessed"
] | [] | (*
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) | false | false | Steel.ST.MonotonicReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val witnessed (#a:Type u#0) (#p:Preorder.preorder a) (r:ref a p) (fact:property a)
: Type0 | [] | Steel.ST.MonotonicReference.witnessed | {
"file_name": "lib/steel/Steel.ST.MonotonicReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.ST.MonotonicReference.ref a p -> fact: Steel.ST.MonotonicReference.property a -> Type0 | {
"end_col": 23,
"end_line": 55,
"start_col": 4,
"start_line": 55
} |
Prims.Tot | val ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0 | [
{
"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
}
] | false | let ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0
= MR.ref a p | 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 = | false | null | false | MR.ref a p | {
"checked_file": "Steel.ST.MonotonicReference.fst.checked",
"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"
} | [
"total"
] | [
"FStar.Preorder.preorder",
"Steel.MonotonicReference.ref"
] | [] | (*
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) | false | false | Steel.ST.MonotonicReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0 | [] | Steel.ST.MonotonicReference.ref | {
"file_name": "lib/steel/Steel.ST.MonotonicReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | a: Type0 -> p: FStar.Preorder.preorder a -> Type0 | {
"end_col": 14,
"end_line": 26,
"start_col": 4,
"start_line": 26
} |
Steel.ST.Effect.Atomic.STAtomicU | 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) | [
{
"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
}
] | 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) | 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)
= | true | null | false | coerce_atomic (fun _ -> MR.recall #inames #a #q #p fact r v w) | {
"checked_file": "Steel.ST.MonotonicReference.fst.checked",
"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"
} | [] | [
"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"
] | [] | (*
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) | false | false | Steel.ST.MonotonicReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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) | [] | Steel.ST.MonotonicReference.recall | {
"file_name": "lib/steel/Steel.ST.MonotonicReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
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 | {
"end_col": 66,
"end_line": 89,
"start_col": 4,
"start_line": 89
} |
Steel.ST.Effect.Atomic.STAtomicUT | 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) | [
{
"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
}
] | 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) | 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))
= | true | null | false | coerce_atomic (witness' r fact v pf) | {
"checked_file": "Steel.ST.MonotonicReference.fst.checked",
"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"
} | [] | [
"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'"
] | [] | (*
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) | false | false | Steel.ST.MonotonicReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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) | [] | Steel.ST.MonotonicReference.witness | {
"file_name": "lib/steel/Steel.ST.MonotonicReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
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) | {
"end_col": 40,
"end_line": 79,
"start_col": 4,
"start_line": 79
} |
Steel.ST.Effect.ST | 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) | [
{
"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
}
] | 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) | 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) = | true | null | false | coerce_steel (fun _ -> MR.write r x) | {
"checked_file": "Steel.ST.MonotonicReference.fst.checked",
"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"
} | [] | [
"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"
] | [] | (*
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) | false | false | Steel.ST.MonotonicReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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) | [] | Steel.ST.MonotonicReference.write | {
"file_name": "lib/steel/Steel.ST.MonotonicReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.ST.MonotonicReference.ref a p -> x: a -> Steel.ST.Effect.ST Prims.unit | {
"end_col": 40,
"end_line": 48,
"start_col": 4,
"start_line": 48
} |
Steel.ST.Effect.Ghost.STGhostT | 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) | [
{
"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
}
] | 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) | 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)) = | true | null | false | coerce_ghost (fun _ -> MR.share r f v) | {
"checked_file": "Steel.ST.MonotonicReference.fst.checked",
"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"
} | [] | [
"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"
] | [] | (*
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) | false | false | Steel.ST.MonotonicReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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) | [] | Steel.ST.MonotonicReference.share | {
"file_name": "lib/steel/Steel.ST.MonotonicReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
r: Steel.ST.MonotonicReference.ref a p ->
f: Steel.FractionalPermission.perm ->
v: FStar.Ghost.erased a
-> Steel.ST.Effect.Ghost.STGhostT Prims.unit | {
"end_col": 42,
"end_line": 100,
"start_col": 4,
"start_line": 100
} |
Steel.ST.Effect.Ghost.STGhostT | 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) | [
{
"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
}
] | 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) | 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) = | true | null | false | coerce_ghost (fun _ -> MR.gather #inames #a #p r f g v) | {
"checked_file": "Steel.ST.MonotonicReference.fst.checked",
"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"
} | [] | [
"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"
] | [] | (*
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)
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) | false | false | Steel.ST.MonotonicReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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) | [] | Steel.ST.MonotonicReference.gather | {
"file_name": "lib/steel/Steel.ST.MonotonicReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
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 | {
"end_col": 59,
"end_line": 111,
"start_col": 4,
"start_line": 111
} |
Steel.Effect.Atomic.SteelAtomicUT | 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) | [
{
"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
}
] | 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 | 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) = | true | null | false | MR.witness #inames #a #q #p r fact v pf | {
"checked_file": "Steel.ST.MonotonicReference.fst.checked",
"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"
} | [] | [
"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"
] | [] | (*
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) | false | false | Steel.ST.MonotonicReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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) | [] | Steel.ST.MonotonicReference.witness' | {
"file_name": "lib/steel/Steel.ST.MonotonicReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
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) | {
"end_col": 43,
"end_line": 69,
"start_col": 4,
"start_line": 69
} |
Steel.ST.Effect.STT | val alloc (#a:Type) (p:Preorder.preorder a) (v:a)
: STT (ref a p) emp (fun r -> pts_to r full_perm v) | [
{
"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
}
] | 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 | 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) = | true | null | false | let x = coerce_steel (fun _ -> MR.alloc p v) in
return x | {
"checked_file": "Steel.ST.MonotonicReference.fst.checked",
"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"
} | [] | [
"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"
] | [] | (*
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) | false | false | Steel.ST.MonotonicReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val alloc (#a:Type) (p:Preorder.preorder a) (v:a)
: STT (ref a p) emp (fun r -> pts_to r full_perm v) | [] | Steel.ST.MonotonicReference.alloc | {
"file_name": "lib/steel/Steel.ST.MonotonicReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: FStar.Preorder.preorder a -> v: a -> Steel.ST.Effect.STT (Steel.ST.MonotonicReference.ref a p) | {
"end_col": 12,
"end_line": 39,
"start_col": 3,
"start_line": 38
} |
Prims.Tot | val inull (#a: Type0) : ibuffer a | [
{
"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
}
] | false | let inull (#a:Type0) :ibuffer a = mnull #a #(immutable_preorder a) #(immutable_preorder a) | val inull (#a: Type0) : ibuffer a
let inull (#a: Type0) : ibuffer a = | false | null | false | mnull #a #(immutable_preorder a) #(immutable_preorder a) | {
"checked_file": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [
"total"
] | [
"LowStar.Monotonic.Buffer.mnull",
"LowStar.ImmutableBuffer.immutable_preorder",
"LowStar.ImmutableBuffer.ibuffer"
] | [] | (*
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) | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val inull (#a: Type0) : ibuffer a | [] | LowStar.ImmutableBuffer.inull | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | LowStar.ImmutableBuffer.ibuffer a | {
"end_col": 97,
"end_line": 32,
"start_col": 41,
"start_line": 32
} |
Prims.Ghost | [
{
"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
}
] | false | let igsub (#a:Type0) = mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) | let igsub (#a: Type0) = | false | null | false | mgsub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) | {
"checked_file": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [] | [
"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"
] | [] | (*
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) | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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)) | [] | LowStar.ImmutableBuffer.igsub | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
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)) | {
"end_col": 109,
"end_line": 34,
"start_col": 30,
"start_line": 34
} |
|
FStar.Pervasives.Lemma | [
{
"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
}
] | false | let igsub_inj (#a:Type0) = mgsub_inj #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) (immutable_preorder a) | let igsub_inj (#a: Type0) = | false | null | true | mgsub_inj #a
#(immutable_preorder a)
#(immutable_preorder a)
(immutable_preorder a)
(immutable_preorder a) | {
"checked_file": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [
"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"
] | [] | (*
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) | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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)) | [] | LowStar.ImmutableBuffer.igsub_inj | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
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)) | {
"end_col": 140,
"end_line": 36,
"start_col": 34,
"start_line": 36
} |
|
FStar.HyperStack.ST.Stack | [
{
"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
}
] | false | let isub (#a:Type0) = msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) | let isub (#a: Type0) = | true | null | false | msub #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) | {
"checked_file": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [] | [
"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"
] | [] | (*
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} | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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)) | [] | LowStar.ImmutableBuffer.isub | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
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)) | {
"end_col": 122,
"end_line": 44,
"start_col": 44,
"start_line": 44
} |
|
FStar.HyperStack.ST.Stack | [
{
"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
}
] | false | let ioffset (#a:Type0) = moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) | let ioffset (#a: Type0) = | true | null | false | moffset #a #(immutable_preorder a) #(immutable_preorder a) (immutable_preorder a) | {
"checked_file": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [] | [
"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"
] | [] | (*
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) | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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)) | [] | LowStar.ImmutableBuffer.ioffset | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
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)) | {
"end_col": 128,
"end_line": 46,
"start_col": 47,
"start_line": 46
} |
|
Prims.Tot | val seq_eq (s: Ghost.erased (Seq.seq 'a)) : spred 'a | [
{
"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
}
] | false | let seq_eq (s:Ghost.erased (Seq.seq 'a)) : spred 'a =
fun s' -> s' `Seq.equal` Ghost.reveal s | val seq_eq (s: Ghost.erased (Seq.seq 'a)) : spred 'a
let seq_eq (s: Ghost.erased (Seq.seq 'a)) : spred 'a = | false | null | false | fun s' -> s' `Seq.equal` (Ghost.reveal s) | {
"checked_file": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [
"total"
] | [
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.equal",
"FStar.Ghost.reveal",
"LowStar.Monotonic.Buffer.spred"
] | [] | (*
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 | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val seq_eq (s: Ghost.erased (Seq.seq 'a)) : spred 'a | [] | LowStar.ImmutableBuffer.seq_eq | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s: FStar.Ghost.erased (FStar.Seq.Base.seq 'a) -> LowStar.Monotonic.Buffer.spred 'a | {
"end_col": 41,
"end_line": 58,
"start_col": 2,
"start_line": 58
} |
Prims.Tot | [
{
"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
}
] | false | let value_is #a (b:ibuffer a) (s:Ghost.erased (Seq.seq a)) =
witnessed b (seq_eq s) | let value_is #a (b: ibuffer a) (s: Ghost.erased (Seq.seq a)) = | false | null | false | witnessed b (seq_eq s) | {
"checked_file": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [
"total"
] | [
"LowStar.ImmutableBuffer.ibuffer",
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"LowStar.Monotonic.Buffer.witnessed",
"LowStar.ImmutableBuffer.immutable_preorder",
"LowStar.ImmutableBuffer.seq_eq"
] | [] | (*
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 | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val value_is : b: LowStar.ImmutableBuffer.ibuffer a -> s: FStar.Ghost.erased (FStar.Seq.Base.seq a) -> Type0 | [] | LowStar.ImmutableBuffer.value_is | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | b: LowStar.ImmutableBuffer.ibuffer a -> s: FStar.Ghost.erased (FStar.Seq.Base.seq a) -> Type0 | {
"end_col": 24,
"end_line": 61,
"start_col": 2,
"start_line": 61
} |
|
Prims.Tot | val cpred (#a: Type0) (s: Seq.seq a) : spred a | [
{
"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
}
] | false | let cpred (#a:Type0) (s:Seq.seq a) :spred a = fun s1 -> Seq.equal s s1 | val cpred (#a: Type0) (s: Seq.seq a) : spred a
let cpred (#a: Type0) (s: Seq.seq a) : spred a = | false | null | false | fun s1 -> Seq.equal s s1 | {
"checked_file": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [
"total"
] | [
"FStar.Seq.Base.seq",
"FStar.Seq.Base.equal",
"LowStar.Monotonic.Buffer.spred"
] | [] | (*
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 | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val cpred (#a: Type0) (s: Seq.seq a) : spred a | [] | LowStar.ImmutableBuffer.cpred | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s: FStar.Seq.Base.seq a -> LowStar.Monotonic.Buffer.spred a | {
"end_col": 70,
"end_line": 55,
"start_col": 46,
"start_line": 55
} |
Prims.Tot | [
{
"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
}
] | false | let libuffer (a:Type0) (len:nat) (s:Seq.seq a) =
b:lmbuffer a (immutable_preorder a) (immutable_preorder a) len{witnessed b (cpred s)} | let libuffer (a: Type0) (len: nat) (s: Seq.seq a) = | false | null | false | b: lmbuffer a (immutable_preorder a) (immutable_preorder a) len {witnessed b (cpred s)} | {
"checked_file": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [
"total"
] | [
"Prims.nat",
"FStar.Seq.Base.seq",
"LowStar.Monotonic.Buffer.lmbuffer",
"LowStar.ImmutableBuffer.immutable_preorder",
"LowStar.Monotonic.Buffer.witnessed",
"LowStar.ImmutableBuffer.cpred"
] | [] | (*
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)) | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val libuffer : a: Type0 -> len: Prims.nat -> s: FStar.Seq.Base.seq a -> Type0 | [] | LowStar.ImmutableBuffer.libuffer | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: Type0 -> len: Prims.nat -> s: FStar.Seq.Base.seq a -> Type0 | {
"end_col": 87,
"end_line": 76,
"start_col": 2,
"start_line": 76
} |
|
Prims.Tot | [
{
"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
}
] | false | 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 libuffer_or_null (a: Type0) (len: nat) (r: HS.rid) (s: Seq.seq a) = | false | null | false | b:
lmbuffer_or_null a (immutable_preorder a) (immutable_preorder a) len r
{(not (g_is_null b)) ==> witnessed b (cpred s)} | {
"checked_file": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [
"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"
] | [] | (*
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)} | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val libuffer_or_null : a: Type0 -> len: Prims.nat -> r: FStar.Monotonic.HyperHeap.rid -> s: FStar.Seq.Base.seq a -> Type0 | [] | LowStar.ImmutableBuffer.libuffer_or_null | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: Type0 -> len: Prims.nat -> r: FStar.Monotonic.HyperHeap.rid -> s: FStar.Seq.Base.seq a -> Type0 | {
"end_col": 97,
"end_line": 80,
"start_col": 2,
"start_line": 79
} |
|
Prims.Tot | val immutable_preorder (a: Type0) : srel a | [
{
"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
}
] | false | let immutable_preorder (a:Type0) :srel a = fun s1 s2 -> Seq.equal s1 s2 | val immutable_preorder (a: Type0) : srel a
let immutable_preorder (a: Type0) : srel a = | false | null | false | fun s1 s2 -> Seq.equal s1 s2 | {
"checked_file": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [
"total"
] | [
"FStar.Seq.Base.seq",
"FStar.Seq.Base.equal",
"Prims.prop",
"LowStar.Monotonic.Buffer.srel"
] | [] | (*
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 | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val immutable_preorder (a: Type0) : srel a | [] | LowStar.ImmutableBuffer.immutable_preorder | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: Type0 -> LowStar.Monotonic.Buffer.srel a | {
"end_col": 71,
"end_line": 28,
"start_col": 43,
"start_line": 28
} |
FStar.HyperStack.ST.ST | 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)))) | [
{
"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
}
] | 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) | 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)))) = | true | null | false | let h = HST.get () in
let s = Ghost.hide (as_seq h b) in
witness_p b (seq_eq s) | {
"checked_file": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [] | [
"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"
] | [] | (*
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)) | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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)))) | [] | LowStar.ImmutableBuffer.witness_value | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | b: LowStar.ImmutableBuffer.ibuffer a -> FStar.HyperStack.ST.ST Prims.unit | {
"end_col": 26,
"end_line": 212,
"start_col": 3,
"start_line": 210
} |
FStar.Pervasives.Lemma | val inhabited_immutable_buffer_is_distinct_from_buffer
(#a: Type0)
(x: a)
(ib: ibuffer a)
(b: LowStar.Buffer.buffer a)
: Lemma (~(ib === b)) | [
{
"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
}
] | 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)
= //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) () | 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)) = | false | null | true | 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) () | {
"checked_file": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [
"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"
] | [] | (*
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) | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val inhabited_immutable_buffer_is_distinct_from_buffer
(#a: Type0)
(x: a)
(ib: ibuffer a)
(b: LowStar.Buffer.buffer a)
: Lemma (~(ib === b)) | [] | LowStar.ImmutableBuffer.inhabited_immutable_buffer_is_distinct_from_buffer | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | x: a -> ib: LowStar.ImmutableBuffer.ibuffer a -> b: LowStar.Buffer.buffer a
-> FStar.Pervasives.Lemma (ensures ~(ib === b)) | {
"end_col": 36,
"end_line": 243,
"start_col": 3,
"start_line": 228
} |
FStar.HyperStack.ST.ST | 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))) | [
{
"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
}
] | 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 | 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))) = | true | null | false | igcmalloc_of_list r init | {
"checked_file": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [] | [
"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.Properties.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"
] | [] | (*
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)) | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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))) | [] | LowStar.ImmutableBuffer.igcmalloc_of_list_partial | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | 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.Properties.seq_of_list init) {LowStar.Monotonic.Buffer.recallable b}) | {
"end_col": 28,
"end_line": 195,
"start_col": 4,
"start_line": 195
} |
FStar.HyperStack.ST.StackInline | 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)) | [
{
"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
}
] | 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 | 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)) = | true | null | false | let b = malloca_of_list init in
witness_p b (cpred (Seq.seq_of_list init));
b | {
"checked_file": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [] | [
"Prims.list",
"LowStar.ImmutableBuffer.libuffer",
"FStar.Pervasives.normalize_term",
"Prims.nat",
"FStar.List.Tot.Base.length",
"FStar.Seq.Properties.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"
] | [] | (*
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) /\ | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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)) | [] | LowStar.ImmutableBuffer.ialloca_of_list | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | init: Prims.list a
-> FStar.HyperStack.ST.StackInline
(LowStar.ImmutableBuffer.libuffer a
(FStar.Pervasives.normalize_term (FStar.List.Tot.Base.length init))
(FStar.Seq.Properties.seq_of_list init)) | {
"end_col": 5,
"end_line": 180,
"start_col": 3,
"start_line": 178
} |
FStar.HyperStack.ST.ST | 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))) | [
{
"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
}
] | 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) | 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))) = | true | null | false | witness_p b (cpred s) | {
"checked_file": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [] | [
"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"
] | [] | (*
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)) | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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))) | [] | LowStar.ImmutableBuffer.witness_contents | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | b: LowStar.ImmutableBuffer.ibuffer a -> s: FStar.Seq.Base.seq a -> FStar.HyperStack.ST.ST Prims.unit | {
"end_col": 25,
"end_line": 200,
"start_col": 4,
"start_line": 200
} |
FStar.HyperStack.ST.ST | 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)) | [
{
"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
}
] | 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) | 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)) = | true | null | false | recall_p b (seq_eq s) | {
"checked_file": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [] | [
"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"
] | [] | (*
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)) | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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)) | [] | LowStar.ImmutableBuffer.recall_value | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | b: LowStar.ImmutableBuffer.ibuffer a -> s: FStar.Ghost.erased (FStar.Seq.Base.seq a)
-> FStar.HyperStack.ST.ST Prims.unit | {
"end_col": 25,
"end_line": 217,
"start_col": 4,
"start_line": 217
} |
FStar.HyperStack.ST.ST | 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)) | [
{
"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
}
] | 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) | 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)) = | true | null | false | recall_p b (cpred s) | {
"checked_file": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [] | [
"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"
] | [] | (*
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))) | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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)) | [] | LowStar.ImmutableBuffer.recall_contents | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | b: LowStar.ImmutableBuffer.ibuffer a -> s: FStar.Seq.Base.seq a -> FStar.HyperStack.ST.ST Prims.unit | {
"end_col": 24,
"end_line": 205,
"start_col": 4,
"start_line": 205
} |
FStar.HyperStack.ST.StackInline | 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)) | [
{
"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
}
] | 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 | 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)) = | true | null | false | let b = malloca init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b | {
"checked_file": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [] | [
"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"
] | [] | (*
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) /\ | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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)) | [] | LowStar.ImmutableBuffer.ialloca | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | 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)) | {
"end_col": 5,
"end_line": 155,
"start_col": 3,
"start_line": 153
} |
FStar.HyperStack.ST.ST | 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))) | [
{
"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
}
] | 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 | 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))) = | true | null | false | let b = mmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b | {
"checked_file": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [] | [
"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"
] | [] | (*
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)) | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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))) | [] | LowStar.ImmutableBuffer.imalloc | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | 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}) | {
"end_col": 5,
"end_line": 124,
"start_col": 3,
"start_line": 122
} |
FStar.Pervasives.Lemma | 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)) | [
{
"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
}
] | false | 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 | 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 #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)) = | false | null | true | 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 | {
"checked_file": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [
"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"
] | [] | (*
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) ()
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 | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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)) | [] | LowStar.ImmutableBuffer.buffer_immutable_buffer_disjoint | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
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) | {
"end_col": 5,
"end_line": 265,
"start_col": 2,
"start_line": 257
} |
FStar.HyperStack.ST.ST | 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))) | [
{
"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
}
] | 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 | 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))) = | true | null | false | imalloc r init len | {
"checked_file": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [] | [
"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"
] | [] | (*
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)) | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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))) | [] | LowStar.ImmutableBuffer.imalloc_partial | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | 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 }) | {
"end_col": 22,
"end_line": 146,
"start_col": 4,
"start_line": 146
} |
FStar.HyperStack.ST.ST | 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))) | [
{
"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
}
] | 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 | 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))) = | true | null | false | let b = mgcmalloc_of_list r init in
witness_p b (cpred (Seq.seq_of_list init));
b | {
"checked_file": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [] | [
"FStar.Monotonic.HyperHeap.rid",
"Prims.list",
"LowStar.ImmutableBuffer.libuffer",
"FStar.Pervasives.normalize_term",
"Prims.nat",
"FStar.List.Tot.Base.length",
"FStar.Seq.Properties.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"
] | [] | (*
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)) | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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))) | [] | LowStar.ImmutableBuffer.igcmalloc_of_list | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | 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.Properties.seq_of_list init)
{LowStar.Monotonic.Buffer.frameOf b == r /\ LowStar.Monotonic.Buffer.recallable b}) | {
"end_col": 5,
"end_line": 188,
"start_col": 3,
"start_line": 186
} |
FStar.HyperStack.ST.ST | 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))) | [
{
"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
}
] | 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 | 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))) = | true | null | false | igcmalloc r init len | {
"checked_file": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [] | [
"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"
] | [] | (*
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)) | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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))) | [] | LowStar.ImmutableBuffer.igcmalloc_partial | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | 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}) | {
"end_col": 24,
"end_line": 116,
"start_col": 4,
"start_line": 116
} |
FStar.HyperStack.ST.ST | 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))) | [
{
"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
}
] | 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 | 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))) = | true | null | false | let b = mgcmalloc r init len in
witness_p b (cpred (Seq.create (U32.v len) init));
b | {
"checked_file": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [] | [
"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"
] | [] | (*
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)) | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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))) | [] | LowStar.ImmutableBuffer.igcmalloc | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | 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}) | {
"end_col": 5,
"end_line": 88,
"start_col": 3,
"start_line": 86
} |
FStar.HyperStack.ST.ST | 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)) | [
{
"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
}
] | false | 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 | 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 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)) = | true | null | false | 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": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [] | [
"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"
] | [] | (*
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 /\ | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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)) | [] | LowStar.ImmutableBuffer.imalloc_and_blit | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
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}) | {
"end_col": 5,
"end_line": 139,
"start_col": 3,
"start_line": 136
} |
FStar.Pervasives.Lemma | 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))) | [
{
"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
}
] | 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)) | 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))) = | false | null | true | 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": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [
"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"
] | [] | (*
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 | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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))) | [] | LowStar.ImmutableBuffer.sub_ptr_value_is | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
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)))) | {
"end_col": 87,
"end_line": 73,
"start_col": 2,
"start_line": 72
} |
FStar.HyperStack.ST.ST | 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)) | [
{
"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
}
] | false | 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 | 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 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)) = | true | null | false | 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": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [] | [
"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"
] | [] | (*
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 /\ | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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)) | [] | LowStar.ImmutableBuffer.igcmalloc_and_blit | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
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}) | {
"end_col": 5,
"end_line": 109,
"start_col": 3,
"start_line": 106
} |
FStar.HyperStack.ST.StackInline | 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)) | [
{
"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
}
] | false | 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 | 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 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)) = | true | null | false | 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": "LowStar.ImmutableBuffer.fst.checked",
"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"
} | [] | [
"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"
] | [] | (*
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 /\ | false | false | LowStar.ImmutableBuffer.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | 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)) | [] | LowStar.ImmutableBuffer.ialloca_and_blit | {
"file_name": "ulib/LowStar.ImmutableBuffer.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | 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)) | {
"end_col": 5,
"end_line": 171,
"start_col": 3,
"start_line": 168
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Blake2b_32",
"short_module": "Blake2b32"
},
{
"abbrev": true,
"full_module": "Hacl.Blake2s_32",
"short_module": "Blake2s32"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2.Generic",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Blake2.Core",
"short_module": "Core"
},
{
"abbrev": true,
"full_module": "Spec.Blake2",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Interface",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Functor",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let m_spec = Core.m_spec | let m_spec = | false | null | false | Core.m_spec | {
"checked_file": "Hacl.Streaming.Blake2.fst.checked",
"dependencies": [
"Spec.Blake2.Alternative.fsti.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Interface.fsti.checked",
"Hacl.Streaming.Functor.fsti.checked",
"Hacl.Impl.Blake2.Generic.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Blake2s_32.fst.checked",
"Hacl.Blake2b_32.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt128.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Streaming.Blake2.fst"
} | [
"total"
] | [
"Hacl.Impl.Blake2.Core.m_spec"
] | [] | module Hacl.Streaming.Blake2
module HS = FStar.HyperStack
module B = LowStar.Buffer
module G = FStar.Ghost
module S = FStar.Seq
module LS = Lib.Sequence
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module U128 = FStar.UInt128
module F = Hacl.Streaming.Functor
module I = Hacl.Streaming.Interface
module ST = FStar.HyperStack.ST
open FStar.Mul
module Loops = Lib.LoopCombinators
/// Opening a bunch of modules for Blake2
/// =====================================
inline_for_extraction noextract
let uint8 = Lib.IntTypes.uint8
inline_for_extraction noextract
let uint32 = Lib.IntTypes.uint32
unfold noextract
let size_nat = Lib.IntTypes.size_nat
unfold noextract
let max_key = Spec.Blake2.max_key
unfold noextract
let lbytes = Lib.ByteSequence.lbytes
module Spec = Spec.Blake2
module Core = Hacl.Impl.Blake2.Core
open Hacl.Impl.Blake2.Generic
module Blake2s32 = Hacl.Blake2s_32
module Blake2b32 = Hacl.Blake2b_32
/// An instance of the stateful type class for blake2
/// =================================================
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50"
inline_for_extraction noextract
let index = unit
inline_for_extraction noextract
let alg = Spec.alg | false | false | Hacl.Streaming.Blake2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val m_spec : Type0 | [] | Hacl.Streaming.Blake2.m_spec | {
"file_name": "code/streaming/Hacl.Streaming.Blake2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 24,
"end_line": 55,
"start_col": 13,
"start_line": 55
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Interface",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Functor",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lbytes = Lib.ByteSequence.lbytes | let lbytes = | false | null | false | Lib.ByteSequence.lbytes | {
"checked_file": "Hacl.Streaming.Blake2.fst.checked",
"dependencies": [
"Spec.Blake2.Alternative.fsti.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Interface.fsti.checked",
"Hacl.Streaming.Functor.fsti.checked",
"Hacl.Impl.Blake2.Generic.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Blake2s_32.fst.checked",
"Hacl.Blake2b_32.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt128.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Streaming.Blake2.fst"
} | [
"total"
] | [
"Lib.ByteSequence.lbytes"
] | [] | module Hacl.Streaming.Blake2
module HS = FStar.HyperStack
module B = LowStar.Buffer
module G = FStar.Ghost
module S = FStar.Seq
module LS = Lib.Sequence
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module U128 = FStar.UInt128
module F = Hacl.Streaming.Functor
module I = Hacl.Streaming.Interface
module ST = FStar.HyperStack.ST
open FStar.Mul
module Loops = Lib.LoopCombinators
/// Opening a bunch of modules for Blake2
/// =====================================
inline_for_extraction noextract
let uint8 = Lib.IntTypes.uint8
inline_for_extraction noextract
let uint32 = Lib.IntTypes.uint32
unfold noextract
let size_nat = Lib.IntTypes.size_nat
unfold noextract
let max_key = Spec.Blake2.max_key | false | false | Hacl.Streaming.Blake2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lbytes : len: Lib.IntTypes.size_nat -> Type0 | [] | Hacl.Streaming.Blake2.lbytes | {
"file_name": "code/streaming/Hacl.Streaming.Blake2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Lib.IntTypes.size_nat -> Type0 | {
"end_col": 36,
"end_line": 35,
"start_col": 13,
"start_line": 35
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Interface",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Functor",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let size_nat = Lib.IntTypes.size_nat | let size_nat = | false | null | false | Lib.IntTypes.size_nat | {
"checked_file": "Hacl.Streaming.Blake2.fst.checked",
"dependencies": [
"Spec.Blake2.Alternative.fsti.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Interface.fsti.checked",
"Hacl.Streaming.Functor.fsti.checked",
"Hacl.Impl.Blake2.Generic.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Blake2s_32.fst.checked",
"Hacl.Blake2b_32.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt128.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Streaming.Blake2.fst"
} | [
"total"
] | [
"Lib.IntTypes.size_nat"
] | [] | module Hacl.Streaming.Blake2
module HS = FStar.HyperStack
module B = LowStar.Buffer
module G = FStar.Ghost
module S = FStar.Seq
module LS = Lib.Sequence
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module U128 = FStar.UInt128
module F = Hacl.Streaming.Functor
module I = Hacl.Streaming.Interface
module ST = FStar.HyperStack.ST
open FStar.Mul
module Loops = Lib.LoopCombinators
/// Opening a bunch of modules for Blake2
/// =====================================
inline_for_extraction noextract
let uint8 = Lib.IntTypes.uint8
inline_for_extraction noextract
let uint32 = Lib.IntTypes.uint32 | false | false | Hacl.Streaming.Blake2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val size_nat : Type0 | [] | Hacl.Streaming.Blake2.size_nat | {
"file_name": "code/streaming/Hacl.Streaming.Blake2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 36,
"end_line": 29,
"start_col": 15,
"start_line": 29
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Blake2b_32",
"short_module": "Blake2b32"
},
{
"abbrev": true,
"full_module": "Hacl.Blake2s_32",
"short_module": "Blake2s32"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2.Generic",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Blake2.Core",
"short_module": "Core"
},
{
"abbrev": true,
"full_module": "Spec.Blake2",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Interface",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Functor",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key_size_t (a : alg) =
key_size:U32.t{U32.v key_size <= Spec.max_key a} | let key_size_t (a: alg) = | false | null | false | key_size: U32.t{U32.v key_size <= Spec.max_key a} | {
"checked_file": "Hacl.Streaming.Blake2.fst.checked",
"dependencies": [
"Spec.Blake2.Alternative.fsti.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Interface.fsti.checked",
"Hacl.Streaming.Functor.fsti.checked",
"Hacl.Impl.Blake2.Generic.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Blake2s_32.fst.checked",
"Hacl.Blake2b_32.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt128.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Streaming.Blake2.fst"
} | [
"total"
] | [
"Hacl.Streaming.Blake2.alg",
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"Spec.Blake2.max_key"
] | [] | module Hacl.Streaming.Blake2
module HS = FStar.HyperStack
module B = LowStar.Buffer
module G = FStar.Ghost
module S = FStar.Seq
module LS = Lib.Sequence
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module U128 = FStar.UInt128
module F = Hacl.Streaming.Functor
module I = Hacl.Streaming.Interface
module ST = FStar.HyperStack.ST
open FStar.Mul
module Loops = Lib.LoopCombinators
/// Opening a bunch of modules for Blake2
/// =====================================
inline_for_extraction noextract
let uint8 = Lib.IntTypes.uint8
inline_for_extraction noextract
let uint32 = Lib.IntTypes.uint32
unfold noextract
let size_nat = Lib.IntTypes.size_nat
unfold noextract
let max_key = Spec.Blake2.max_key
unfold noextract
let lbytes = Lib.ByteSequence.lbytes
module Spec = Spec.Blake2
module Core = Hacl.Impl.Blake2.Core
open Hacl.Impl.Blake2.Generic
module Blake2s32 = Hacl.Blake2s_32
module Blake2b32 = Hacl.Blake2b_32
/// An instance of the stateful type class for blake2
/// =================================================
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50"
inline_for_extraction noextract
let index = unit
inline_for_extraction noextract
let alg = Spec.alg
inline_for_extraction noextract
let m_spec = Core.m_spec
/// The stateful state: (wv, hash)
inline_for_extraction noextract
let s (a : alg) (m : m_spec) = Core.(state_p a m & state_p a m)
inline_for_extraction noextract
let t (a : alg) = Spec.state a
(* In the internal state, we keep wv, the working vector. It's essentially
temporary scratch space that the Blake2 implementation expects to receive. (Why
is the implementation not performing its own stack allocations? Don't know!) *)
inline_for_extraction noextract
let get_wv (#a : alg) (#m : m_spec) (s : s a m) : Tot (Core.state_p a m) =
match s with wv, _ -> wv
inline_for_extraction noextract
let get_state_p (#a : alg) (#m : m_spec) (s : s a m) : Tot (Core.state_p a m) =
match s with _, p -> p
(* But the working vector is not reflected in the state at all -- it doesn't
have meaningful specification contents. *)
inline_for_extraction noextract
let state_v (#a : alg) (#m : m_spec) (h : HS.mem) (s : s a m) : GTot (Spec.state a) =
Core.state_v h (get_state_p s)
inline_for_extraction noextract
let s_v (#a : alg) (#m : m_spec) (h : HS.mem) (s : s a m) : GTot (t a) =
state_v h s
/// Small helper which facilitates inferencing implicit arguments for buffer
/// operations
inline_for_extraction noextract
let state_to_lbuffer (#a : alg) (#m : m_spec) (s : Core.state_p a m) :
B.lbuffer (Core.element_t a m) (4 * U32.v (Core.row_len a m)) =
s
inline_for_extraction noextract
let stateful_blake2 (a : alg) (m : m_spec) : I.stateful unit =
I.Stateful
(fun () -> s a m) (* s *)
(* footprint *)
(fun #_ _ acc ->
let wv, b = acc in
B.loc_union
(B.loc_addr_of_buffer (state_to_lbuffer wv))
(B.loc_addr_of_buffer (state_to_lbuffer b)))
(* freeable *)
(fun #_ _ acc ->
let wv, b = acc in
B.freeable (state_to_lbuffer wv) /\
B.freeable (state_to_lbuffer b))
(* invariant *)
(fun #_ h acc ->
let wv, b = acc in
B.live h (state_to_lbuffer wv) /\
B.live h (state_to_lbuffer b) /\
B.disjoint (state_to_lbuffer wv) (state_to_lbuffer b))
(fun () -> t a) (* t *)
(fun () h acc -> s_v h acc) (* v *)
(fun #_ h acc -> let wv, b = acc in ()) (* invariant_loc_in_footprint *)
(fun #_ l acc h0 h1 -> let wv, b = acc in ()) (* frame_invariant *)
(fun #_ _ _ _ _ -> ()) (* frame_freeable *)
(* alloca *)
(fun () ->
let wv = Core.alloc_state a m in
let b = Core.alloc_state a m in
wv, b)
(* create_in *)
(fun () r ->
let wv = B.malloc r (Core.zero_element a m) U32.(4ul *^ Core.row_len a m) in
let b = B.malloc r (Core.zero_element a m) U32.(4ul *^ Core.row_len a m) in
wv, b)
(* free *)
(fun _ acc ->
match acc with wv, b ->
B.free (state_to_lbuffer wv);
B.free (state_to_lbuffer b))
(* copy *)
(fun _ src dst ->
match src with src_wv, src_b ->
match dst with src_wv, dst_b ->
B.blit (state_to_lbuffer src_b) 0ul (state_to_lbuffer dst_b) 0ul
U32.(4ul *^ Core.row_len a m))
/// Stateful key
/// ============
inline_for_extraction noextract
let key_size (a : alg) = kk:nat{kk <= Spec.max_key a}
inline_for_extraction noextract | false | false | Hacl.Streaming.Blake2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key_size_t : a: Hacl.Streaming.Blake2.alg -> Type0 | [] | Hacl.Streaming.Blake2.key_size_t | {
"file_name": "code/streaming/Hacl.Streaming.Blake2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Hacl.Streaming.Blake2.alg -> Type0 | {
"end_col": 50,
"end_line": 148,
"start_col": 2,
"start_line": 148
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Interface",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Functor",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let uint8 = Lib.IntTypes.uint8 | let uint8 = | false | null | false | Lib.IntTypes.uint8 | {
"checked_file": "Hacl.Streaming.Blake2.fst.checked",
"dependencies": [
"Spec.Blake2.Alternative.fsti.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Interface.fsti.checked",
"Hacl.Streaming.Functor.fsti.checked",
"Hacl.Impl.Blake2.Generic.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Blake2s_32.fst.checked",
"Hacl.Blake2b_32.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt128.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Streaming.Blake2.fst"
} | [
"total"
] | [
"Lib.IntTypes.uint8"
] | [] | module Hacl.Streaming.Blake2
module HS = FStar.HyperStack
module B = LowStar.Buffer
module G = FStar.Ghost
module S = FStar.Seq
module LS = Lib.Sequence
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module U128 = FStar.UInt128
module F = Hacl.Streaming.Functor
module I = Hacl.Streaming.Interface
module ST = FStar.HyperStack.ST
open FStar.Mul
module Loops = Lib.LoopCombinators
/// Opening a bunch of modules for Blake2
/// ===================================== | false | false | Hacl.Streaming.Blake2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val uint8 : Type0 | [] | Hacl.Streaming.Blake2.uint8 | {
"file_name": "code/streaming/Hacl.Streaming.Blake2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 30,
"end_line": 23,
"start_col": 12,
"start_line": 23
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Interface",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Functor",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let uint32 = Lib.IntTypes.uint32 | let uint32 = | false | null | false | Lib.IntTypes.uint32 | {
"checked_file": "Hacl.Streaming.Blake2.fst.checked",
"dependencies": [
"Spec.Blake2.Alternative.fsti.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Interface.fsti.checked",
"Hacl.Streaming.Functor.fsti.checked",
"Hacl.Impl.Blake2.Generic.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Blake2s_32.fst.checked",
"Hacl.Blake2b_32.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt128.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Streaming.Blake2.fst"
} | [
"total"
] | [
"Lib.IntTypes.uint32"
] | [] | module Hacl.Streaming.Blake2
module HS = FStar.HyperStack
module B = LowStar.Buffer
module G = FStar.Ghost
module S = FStar.Seq
module LS = Lib.Sequence
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module U128 = FStar.UInt128
module F = Hacl.Streaming.Functor
module I = Hacl.Streaming.Interface
module ST = FStar.HyperStack.ST
open FStar.Mul
module Loops = Lib.LoopCombinators
/// Opening a bunch of modules for Blake2
/// =====================================
inline_for_extraction noextract
let uint8 = Lib.IntTypes.uint8 | false | false | Hacl.Streaming.Blake2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val uint32 : Type0 | [] | Hacl.Streaming.Blake2.uint32 | {
"file_name": "code/streaming/Hacl.Streaming.Blake2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 32,
"end_line": 26,
"start_col": 13,
"start_line": 26
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Blake2b_32",
"short_module": "Blake2b32"
},
{
"abbrev": true,
"full_module": "Hacl.Blake2s_32",
"short_module": "Blake2s32"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2.Generic",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Blake2.Core",
"short_module": "Core"
},
{
"abbrev": true,
"full_module": "Spec.Blake2",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Interface",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Functor",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let alg = Spec.alg | let alg = | false | null | false | Spec.alg | {
"checked_file": "Hacl.Streaming.Blake2.fst.checked",
"dependencies": [
"Spec.Blake2.Alternative.fsti.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Interface.fsti.checked",
"Hacl.Streaming.Functor.fsti.checked",
"Hacl.Impl.Blake2.Generic.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Blake2s_32.fst.checked",
"Hacl.Blake2b_32.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt128.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Streaming.Blake2.fst"
} | [
"total"
] | [
"Spec.Blake2.alg"
] | [] | module Hacl.Streaming.Blake2
module HS = FStar.HyperStack
module B = LowStar.Buffer
module G = FStar.Ghost
module S = FStar.Seq
module LS = Lib.Sequence
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module U128 = FStar.UInt128
module F = Hacl.Streaming.Functor
module I = Hacl.Streaming.Interface
module ST = FStar.HyperStack.ST
open FStar.Mul
module Loops = Lib.LoopCombinators
/// Opening a bunch of modules for Blake2
/// =====================================
inline_for_extraction noextract
let uint8 = Lib.IntTypes.uint8
inline_for_extraction noextract
let uint32 = Lib.IntTypes.uint32
unfold noextract
let size_nat = Lib.IntTypes.size_nat
unfold noextract
let max_key = Spec.Blake2.max_key
unfold noextract
let lbytes = Lib.ByteSequence.lbytes
module Spec = Spec.Blake2
module Core = Hacl.Impl.Blake2.Core
open Hacl.Impl.Blake2.Generic
module Blake2s32 = Hacl.Blake2s_32
module Blake2b32 = Hacl.Blake2b_32
/// An instance of the stateful type class for blake2
/// =================================================
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50"
inline_for_extraction noextract
let index = unit | false | false | Hacl.Streaming.Blake2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val alg : Type0 | [] | Hacl.Streaming.Blake2.alg | {
"file_name": "code/streaming/Hacl.Streaming.Blake2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 18,
"end_line": 52,
"start_col": 10,
"start_line": 52
} |
|
Prims.Tot | val get_wv (#a: alg) (#m: m_spec) (s: s a m) : Tot (Core.state_p a m) | [
{
"abbrev": true,
"full_module": "Hacl.Blake2b_32",
"short_module": "Blake2b32"
},
{
"abbrev": true,
"full_module": "Hacl.Blake2s_32",
"short_module": "Blake2s32"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2.Generic",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Blake2.Core",
"short_module": "Core"
},
{
"abbrev": true,
"full_module": "Spec.Blake2",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Interface",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Functor",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let get_wv (#a : alg) (#m : m_spec) (s : s a m) : Tot (Core.state_p a m) =
match s with wv, _ -> wv | val get_wv (#a: alg) (#m: m_spec) (s: s a m) : Tot (Core.state_p a m)
let get_wv (#a: alg) (#m: m_spec) (s: s a m) : Tot (Core.state_p a m) = | false | null | false | match s with | wv, _ -> wv | {
"checked_file": "Hacl.Streaming.Blake2.fst.checked",
"dependencies": [
"Spec.Blake2.Alternative.fsti.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Interface.fsti.checked",
"Hacl.Streaming.Functor.fsti.checked",
"Hacl.Impl.Blake2.Generic.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Blake2s_32.fst.checked",
"Hacl.Blake2b_32.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt128.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Streaming.Blake2.fst"
} | [
"total"
] | [
"Hacl.Streaming.Blake2.alg",
"Hacl.Streaming.Blake2.m_spec",
"Hacl.Streaming.Blake2.s",
"Hacl.Impl.Blake2.Core.state_p"
] | [] | module Hacl.Streaming.Blake2
module HS = FStar.HyperStack
module B = LowStar.Buffer
module G = FStar.Ghost
module S = FStar.Seq
module LS = Lib.Sequence
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module U128 = FStar.UInt128
module F = Hacl.Streaming.Functor
module I = Hacl.Streaming.Interface
module ST = FStar.HyperStack.ST
open FStar.Mul
module Loops = Lib.LoopCombinators
/// Opening a bunch of modules for Blake2
/// =====================================
inline_for_extraction noextract
let uint8 = Lib.IntTypes.uint8
inline_for_extraction noextract
let uint32 = Lib.IntTypes.uint32
unfold noextract
let size_nat = Lib.IntTypes.size_nat
unfold noextract
let max_key = Spec.Blake2.max_key
unfold noextract
let lbytes = Lib.ByteSequence.lbytes
module Spec = Spec.Blake2
module Core = Hacl.Impl.Blake2.Core
open Hacl.Impl.Blake2.Generic
module Blake2s32 = Hacl.Blake2s_32
module Blake2b32 = Hacl.Blake2b_32
/// An instance of the stateful type class for blake2
/// =================================================
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50"
inline_for_extraction noextract
let index = unit
inline_for_extraction noextract
let alg = Spec.alg
inline_for_extraction noextract
let m_spec = Core.m_spec
/// The stateful state: (wv, hash)
inline_for_extraction noextract
let s (a : alg) (m : m_spec) = Core.(state_p a m & state_p a m)
inline_for_extraction noextract
let t (a : alg) = Spec.state a
(* In the internal state, we keep wv, the working vector. It's essentially
temporary scratch space that the Blake2 implementation expects to receive. (Why
is the implementation not performing its own stack allocations? Don't know!) *)
inline_for_extraction noextract | false | false | Hacl.Streaming.Blake2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val get_wv (#a: alg) (#m: m_spec) (s: s a m) : Tot (Core.state_p a m) | [] | Hacl.Streaming.Blake2.get_wv | {
"file_name": "code/streaming/Hacl.Streaming.Blake2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Streaming.Blake2.s a m -> Hacl.Impl.Blake2.Core.state_p a m | {
"end_col": 26,
"end_line": 69,
"start_col": 2,
"start_line": 69
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Blake2b_32",
"short_module": "Blake2b32"
},
{
"abbrev": true,
"full_module": "Hacl.Blake2s_32",
"short_module": "Blake2s32"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2.Generic",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Blake2.Core",
"short_module": "Core"
},
{
"abbrev": true,
"full_module": "Spec.Blake2",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Interface",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Functor",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let key_size (a : alg) = kk:nat{kk <= Spec.max_key a} | let key_size (a: alg) = | false | null | false | kk: nat{kk <= Spec.max_key a} | {
"checked_file": "Hacl.Streaming.Blake2.fst.checked",
"dependencies": [
"Spec.Blake2.Alternative.fsti.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Interface.fsti.checked",
"Hacl.Streaming.Functor.fsti.checked",
"Hacl.Impl.Blake2.Generic.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Blake2s_32.fst.checked",
"Hacl.Blake2b_32.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt128.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Streaming.Blake2.fst"
} | [
"total"
] | [
"Hacl.Streaming.Blake2.alg",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Spec.Blake2.max_key"
] | [] | module Hacl.Streaming.Blake2
module HS = FStar.HyperStack
module B = LowStar.Buffer
module G = FStar.Ghost
module S = FStar.Seq
module LS = Lib.Sequence
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module U128 = FStar.UInt128
module F = Hacl.Streaming.Functor
module I = Hacl.Streaming.Interface
module ST = FStar.HyperStack.ST
open FStar.Mul
module Loops = Lib.LoopCombinators
/// Opening a bunch of modules for Blake2
/// =====================================
inline_for_extraction noextract
let uint8 = Lib.IntTypes.uint8
inline_for_extraction noextract
let uint32 = Lib.IntTypes.uint32
unfold noextract
let size_nat = Lib.IntTypes.size_nat
unfold noextract
let max_key = Spec.Blake2.max_key
unfold noextract
let lbytes = Lib.ByteSequence.lbytes
module Spec = Spec.Blake2
module Core = Hacl.Impl.Blake2.Core
open Hacl.Impl.Blake2.Generic
module Blake2s32 = Hacl.Blake2s_32
module Blake2b32 = Hacl.Blake2b_32
/// An instance of the stateful type class for blake2
/// =================================================
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50"
inline_for_extraction noextract
let index = unit
inline_for_extraction noextract
let alg = Spec.alg
inline_for_extraction noextract
let m_spec = Core.m_spec
/// The stateful state: (wv, hash)
inline_for_extraction noextract
let s (a : alg) (m : m_spec) = Core.(state_p a m & state_p a m)
inline_for_extraction noextract
let t (a : alg) = Spec.state a
(* In the internal state, we keep wv, the working vector. It's essentially
temporary scratch space that the Blake2 implementation expects to receive. (Why
is the implementation not performing its own stack allocations? Don't know!) *)
inline_for_extraction noextract
let get_wv (#a : alg) (#m : m_spec) (s : s a m) : Tot (Core.state_p a m) =
match s with wv, _ -> wv
inline_for_extraction noextract
let get_state_p (#a : alg) (#m : m_spec) (s : s a m) : Tot (Core.state_p a m) =
match s with _, p -> p
(* But the working vector is not reflected in the state at all -- it doesn't
have meaningful specification contents. *)
inline_for_extraction noextract
let state_v (#a : alg) (#m : m_spec) (h : HS.mem) (s : s a m) : GTot (Spec.state a) =
Core.state_v h (get_state_p s)
inline_for_extraction noextract
let s_v (#a : alg) (#m : m_spec) (h : HS.mem) (s : s a m) : GTot (t a) =
state_v h s
/// Small helper which facilitates inferencing implicit arguments for buffer
/// operations
inline_for_extraction noextract
let state_to_lbuffer (#a : alg) (#m : m_spec) (s : Core.state_p a m) :
B.lbuffer (Core.element_t a m) (4 * U32.v (Core.row_len a m)) =
s
inline_for_extraction noextract
let stateful_blake2 (a : alg) (m : m_spec) : I.stateful unit =
I.Stateful
(fun () -> s a m) (* s *)
(* footprint *)
(fun #_ _ acc ->
let wv, b = acc in
B.loc_union
(B.loc_addr_of_buffer (state_to_lbuffer wv))
(B.loc_addr_of_buffer (state_to_lbuffer b)))
(* freeable *)
(fun #_ _ acc ->
let wv, b = acc in
B.freeable (state_to_lbuffer wv) /\
B.freeable (state_to_lbuffer b))
(* invariant *)
(fun #_ h acc ->
let wv, b = acc in
B.live h (state_to_lbuffer wv) /\
B.live h (state_to_lbuffer b) /\
B.disjoint (state_to_lbuffer wv) (state_to_lbuffer b))
(fun () -> t a) (* t *)
(fun () h acc -> s_v h acc) (* v *)
(fun #_ h acc -> let wv, b = acc in ()) (* invariant_loc_in_footprint *)
(fun #_ l acc h0 h1 -> let wv, b = acc in ()) (* frame_invariant *)
(fun #_ _ _ _ _ -> ()) (* frame_freeable *)
(* alloca *)
(fun () ->
let wv = Core.alloc_state a m in
let b = Core.alloc_state a m in
wv, b)
(* create_in *)
(fun () r ->
let wv = B.malloc r (Core.zero_element a m) U32.(4ul *^ Core.row_len a m) in
let b = B.malloc r (Core.zero_element a m) U32.(4ul *^ Core.row_len a m) in
wv, b)
(* free *)
(fun _ acc ->
match acc with wv, b ->
B.free (state_to_lbuffer wv);
B.free (state_to_lbuffer b))
(* copy *)
(fun _ src dst ->
match src with src_wv, src_b ->
match dst with src_wv, dst_b ->
B.blit (state_to_lbuffer src_b) 0ul (state_to_lbuffer dst_b) 0ul
U32.(4ul *^ Core.row_len a m))
/// Stateful key
/// ============ | false | false | Hacl.Streaming.Blake2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val key_size : a: Hacl.Streaming.Blake2.alg -> Type0 | [] | Hacl.Streaming.Blake2.key_size | {
"file_name": "code/streaming/Hacl.Streaming.Blake2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Hacl.Streaming.Blake2.alg -> Type0 | {
"end_col": 53,
"end_line": 144,
"start_col": 25,
"start_line": 144
} |
|
Prims.Tot | val get_state_p (#a: alg) (#m: m_spec) (s: s a m) : Tot (Core.state_p a m) | [
{
"abbrev": true,
"full_module": "Hacl.Blake2b_32",
"short_module": "Blake2b32"
},
{
"abbrev": true,
"full_module": "Hacl.Blake2s_32",
"short_module": "Blake2s32"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2.Generic",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Blake2.Core",
"short_module": "Core"
},
{
"abbrev": true,
"full_module": "Spec.Blake2",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Interface",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Functor",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let get_state_p (#a : alg) (#m : m_spec) (s : s a m) : Tot (Core.state_p a m) =
match s with _, p -> p | val get_state_p (#a: alg) (#m: m_spec) (s: s a m) : Tot (Core.state_p a m)
let get_state_p (#a: alg) (#m: m_spec) (s: s a m) : Tot (Core.state_p a m) = | false | null | false | match s with | _, p -> p | {
"checked_file": "Hacl.Streaming.Blake2.fst.checked",
"dependencies": [
"Spec.Blake2.Alternative.fsti.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Interface.fsti.checked",
"Hacl.Streaming.Functor.fsti.checked",
"Hacl.Impl.Blake2.Generic.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Blake2s_32.fst.checked",
"Hacl.Blake2b_32.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt128.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Streaming.Blake2.fst"
} | [
"total"
] | [
"Hacl.Streaming.Blake2.alg",
"Hacl.Streaming.Blake2.m_spec",
"Hacl.Streaming.Blake2.s",
"Hacl.Impl.Blake2.Core.state_p"
] | [] | module Hacl.Streaming.Blake2
module HS = FStar.HyperStack
module B = LowStar.Buffer
module G = FStar.Ghost
module S = FStar.Seq
module LS = Lib.Sequence
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module U128 = FStar.UInt128
module F = Hacl.Streaming.Functor
module I = Hacl.Streaming.Interface
module ST = FStar.HyperStack.ST
open FStar.Mul
module Loops = Lib.LoopCombinators
/// Opening a bunch of modules for Blake2
/// =====================================
inline_for_extraction noextract
let uint8 = Lib.IntTypes.uint8
inline_for_extraction noextract
let uint32 = Lib.IntTypes.uint32
unfold noextract
let size_nat = Lib.IntTypes.size_nat
unfold noextract
let max_key = Spec.Blake2.max_key
unfold noextract
let lbytes = Lib.ByteSequence.lbytes
module Spec = Spec.Blake2
module Core = Hacl.Impl.Blake2.Core
open Hacl.Impl.Blake2.Generic
module Blake2s32 = Hacl.Blake2s_32
module Blake2b32 = Hacl.Blake2b_32
/// An instance of the stateful type class for blake2
/// =================================================
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50"
inline_for_extraction noextract
let index = unit
inline_for_extraction noextract
let alg = Spec.alg
inline_for_extraction noextract
let m_spec = Core.m_spec
/// The stateful state: (wv, hash)
inline_for_extraction noextract
let s (a : alg) (m : m_spec) = Core.(state_p a m & state_p a m)
inline_for_extraction noextract
let t (a : alg) = Spec.state a
(* In the internal state, we keep wv, the working vector. It's essentially
temporary scratch space that the Blake2 implementation expects to receive. (Why
is the implementation not performing its own stack allocations? Don't know!) *)
inline_for_extraction noextract
let get_wv (#a : alg) (#m : m_spec) (s : s a m) : Tot (Core.state_p a m) =
match s with wv, _ -> wv
inline_for_extraction noextract | false | false | Hacl.Streaming.Blake2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val get_state_p (#a: alg) (#m: m_spec) (s: s a m) : Tot (Core.state_p a m) | [] | Hacl.Streaming.Blake2.get_state_p | {
"file_name": "code/streaming/Hacl.Streaming.Blake2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Streaming.Blake2.s a m -> Hacl.Impl.Blake2.Core.state_p a m | {
"end_col": 24,
"end_line": 73,
"start_col": 2,
"start_line": 73
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Interface",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Functor",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let max_key = Spec.Blake2.max_key | let max_key = | false | null | false | Spec.Blake2.max_key | {
"checked_file": "Hacl.Streaming.Blake2.fst.checked",
"dependencies": [
"Spec.Blake2.Alternative.fsti.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Interface.fsti.checked",
"Hacl.Streaming.Functor.fsti.checked",
"Hacl.Impl.Blake2.Generic.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Blake2s_32.fst.checked",
"Hacl.Blake2b_32.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt128.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Streaming.Blake2.fst"
} | [
"total"
] | [
"Spec.Blake2.max_key"
] | [] | module Hacl.Streaming.Blake2
module HS = FStar.HyperStack
module B = LowStar.Buffer
module G = FStar.Ghost
module S = FStar.Seq
module LS = Lib.Sequence
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module U128 = FStar.UInt128
module F = Hacl.Streaming.Functor
module I = Hacl.Streaming.Interface
module ST = FStar.HyperStack.ST
open FStar.Mul
module Loops = Lib.LoopCombinators
/// Opening a bunch of modules for Blake2
/// =====================================
inline_for_extraction noextract
let uint8 = Lib.IntTypes.uint8
inline_for_extraction noextract
let uint32 = Lib.IntTypes.uint32
unfold noextract
let size_nat = Lib.IntTypes.size_nat | false | false | Hacl.Streaming.Blake2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val max_key : a: Spec.Blake2.alg -> Prims.int | [] | Hacl.Streaming.Blake2.max_key | {
"file_name": "code/streaming/Hacl.Streaming.Blake2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.Blake2.alg -> Prims.int | {
"end_col": 33,
"end_line": 32,
"start_col": 14,
"start_line": 32
} |
|
Prims.GTot | val state_v (#a: alg) (#m: m_spec) (h: HS.mem) (s: s a m) : GTot (Spec.state a) | [
{
"abbrev": true,
"full_module": "Hacl.Blake2b_32",
"short_module": "Blake2b32"
},
{
"abbrev": true,
"full_module": "Hacl.Blake2s_32",
"short_module": "Blake2s32"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2.Generic",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Blake2.Core",
"short_module": "Core"
},
{
"abbrev": true,
"full_module": "Spec.Blake2",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Interface",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Functor",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let state_v (#a : alg) (#m : m_spec) (h : HS.mem) (s : s a m) : GTot (Spec.state a) =
Core.state_v h (get_state_p s) | val state_v (#a: alg) (#m: m_spec) (h: HS.mem) (s: s a m) : GTot (Spec.state a)
let state_v (#a: alg) (#m: m_spec) (h: HS.mem) (s: s a m) : GTot (Spec.state a) = | false | null | false | Core.state_v h (get_state_p s) | {
"checked_file": "Hacl.Streaming.Blake2.fst.checked",
"dependencies": [
"Spec.Blake2.Alternative.fsti.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Interface.fsti.checked",
"Hacl.Streaming.Functor.fsti.checked",
"Hacl.Impl.Blake2.Generic.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Blake2s_32.fst.checked",
"Hacl.Blake2b_32.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt128.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Streaming.Blake2.fst"
} | [
"sometrivial"
] | [
"Hacl.Streaming.Blake2.alg",
"Hacl.Streaming.Blake2.m_spec",
"FStar.Monotonic.HyperStack.mem",
"Hacl.Streaming.Blake2.s",
"Hacl.Impl.Blake2.Core.state_v",
"Hacl.Streaming.Blake2.get_state_p",
"Spec.Blake2.state"
] | [] | module Hacl.Streaming.Blake2
module HS = FStar.HyperStack
module B = LowStar.Buffer
module G = FStar.Ghost
module S = FStar.Seq
module LS = Lib.Sequence
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module U128 = FStar.UInt128
module F = Hacl.Streaming.Functor
module I = Hacl.Streaming.Interface
module ST = FStar.HyperStack.ST
open FStar.Mul
module Loops = Lib.LoopCombinators
/// Opening a bunch of modules for Blake2
/// =====================================
inline_for_extraction noextract
let uint8 = Lib.IntTypes.uint8
inline_for_extraction noextract
let uint32 = Lib.IntTypes.uint32
unfold noextract
let size_nat = Lib.IntTypes.size_nat
unfold noextract
let max_key = Spec.Blake2.max_key
unfold noextract
let lbytes = Lib.ByteSequence.lbytes
module Spec = Spec.Blake2
module Core = Hacl.Impl.Blake2.Core
open Hacl.Impl.Blake2.Generic
module Blake2s32 = Hacl.Blake2s_32
module Blake2b32 = Hacl.Blake2b_32
/// An instance of the stateful type class for blake2
/// =================================================
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50"
inline_for_extraction noextract
let index = unit
inline_for_extraction noextract
let alg = Spec.alg
inline_for_extraction noextract
let m_spec = Core.m_spec
/// The stateful state: (wv, hash)
inline_for_extraction noextract
let s (a : alg) (m : m_spec) = Core.(state_p a m & state_p a m)
inline_for_extraction noextract
let t (a : alg) = Spec.state a
(* In the internal state, we keep wv, the working vector. It's essentially
temporary scratch space that the Blake2 implementation expects to receive. (Why
is the implementation not performing its own stack allocations? Don't know!) *)
inline_for_extraction noextract
let get_wv (#a : alg) (#m : m_spec) (s : s a m) : Tot (Core.state_p a m) =
match s with wv, _ -> wv
inline_for_extraction noextract
let get_state_p (#a : alg) (#m : m_spec) (s : s a m) : Tot (Core.state_p a m) =
match s with _, p -> p
(* But the working vector is not reflected in the state at all -- it doesn't
have meaningful specification contents. *)
inline_for_extraction noextract | false | false | Hacl.Streaming.Blake2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val state_v (#a: alg) (#m: m_spec) (h: HS.mem) (s: s a m) : GTot (Spec.state a) | [] | Hacl.Streaming.Blake2.state_v | {
"file_name": "code/streaming/Hacl.Streaming.Blake2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> s: Hacl.Streaming.Blake2.s a m
-> Prims.GTot (Spec.Blake2.state a) | {
"end_col": 32,
"end_line": 79,
"start_col": 2,
"start_line": 79
} |
Prims.GTot | val s_v (#a: alg) (#m: m_spec) (h: HS.mem) (s: s a m) : GTot (t a) | [
{
"abbrev": true,
"full_module": "Hacl.Blake2b_32",
"short_module": "Blake2b32"
},
{
"abbrev": true,
"full_module": "Hacl.Blake2s_32",
"short_module": "Blake2s32"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2.Generic",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Blake2.Core",
"short_module": "Core"
},
{
"abbrev": true,
"full_module": "Spec.Blake2",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Interface",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Functor",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let s_v (#a : alg) (#m : m_spec) (h : HS.mem) (s : s a m) : GTot (t a) =
state_v h s | val s_v (#a: alg) (#m: m_spec) (h: HS.mem) (s: s a m) : GTot (t a)
let s_v (#a: alg) (#m: m_spec) (h: HS.mem) (s: s a m) : GTot (t a) = | false | null | false | state_v h s | {
"checked_file": "Hacl.Streaming.Blake2.fst.checked",
"dependencies": [
"Spec.Blake2.Alternative.fsti.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Interface.fsti.checked",
"Hacl.Streaming.Functor.fsti.checked",
"Hacl.Impl.Blake2.Generic.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Blake2s_32.fst.checked",
"Hacl.Blake2b_32.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt128.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Streaming.Blake2.fst"
} | [
"sometrivial"
] | [
"Hacl.Streaming.Blake2.alg",
"Hacl.Streaming.Blake2.m_spec",
"FStar.Monotonic.HyperStack.mem",
"Hacl.Streaming.Blake2.s",
"Hacl.Streaming.Blake2.state_v",
"Hacl.Streaming.Blake2.t"
] | [] | module Hacl.Streaming.Blake2
module HS = FStar.HyperStack
module B = LowStar.Buffer
module G = FStar.Ghost
module S = FStar.Seq
module LS = Lib.Sequence
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module U128 = FStar.UInt128
module F = Hacl.Streaming.Functor
module I = Hacl.Streaming.Interface
module ST = FStar.HyperStack.ST
open FStar.Mul
module Loops = Lib.LoopCombinators
/// Opening a bunch of modules for Blake2
/// =====================================
inline_for_extraction noextract
let uint8 = Lib.IntTypes.uint8
inline_for_extraction noextract
let uint32 = Lib.IntTypes.uint32
unfold noextract
let size_nat = Lib.IntTypes.size_nat
unfold noextract
let max_key = Spec.Blake2.max_key
unfold noextract
let lbytes = Lib.ByteSequence.lbytes
module Spec = Spec.Blake2
module Core = Hacl.Impl.Blake2.Core
open Hacl.Impl.Blake2.Generic
module Blake2s32 = Hacl.Blake2s_32
module Blake2b32 = Hacl.Blake2b_32
/// An instance of the stateful type class for blake2
/// =================================================
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50"
inline_for_extraction noextract
let index = unit
inline_for_extraction noextract
let alg = Spec.alg
inline_for_extraction noextract
let m_spec = Core.m_spec
/// The stateful state: (wv, hash)
inline_for_extraction noextract
let s (a : alg) (m : m_spec) = Core.(state_p a m & state_p a m)
inline_for_extraction noextract
let t (a : alg) = Spec.state a
(* In the internal state, we keep wv, the working vector. It's essentially
temporary scratch space that the Blake2 implementation expects to receive. (Why
is the implementation not performing its own stack allocations? Don't know!) *)
inline_for_extraction noextract
let get_wv (#a : alg) (#m : m_spec) (s : s a m) : Tot (Core.state_p a m) =
match s with wv, _ -> wv
inline_for_extraction noextract
let get_state_p (#a : alg) (#m : m_spec) (s : s a m) : Tot (Core.state_p a m) =
match s with _, p -> p
(* But the working vector is not reflected in the state at all -- it doesn't
have meaningful specification contents. *)
inline_for_extraction noextract
let state_v (#a : alg) (#m : m_spec) (h : HS.mem) (s : s a m) : GTot (Spec.state a) =
Core.state_v h (get_state_p s)
inline_for_extraction noextract | false | false | Hacl.Streaming.Blake2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val s_v (#a: alg) (#m: m_spec) (h: HS.mem) (s: s a m) : GTot (t a) | [] | Hacl.Streaming.Blake2.s_v | {
"file_name": "code/streaming/Hacl.Streaming.Blake2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> s: Hacl.Streaming.Blake2.s a m
-> Prims.GTot (Hacl.Streaming.Blake2.t a) | {
"end_col": 13,
"end_line": 83,
"start_col": 2,
"start_line": 83
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Blake2b_32",
"short_module": "Blake2b32"
},
{
"abbrev": true,
"full_module": "Hacl.Blake2s_32",
"short_module": "Blake2s32"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2.Generic",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Blake2.Core",
"short_module": "Core"
},
{
"abbrev": true,
"full_module": "Spec.Blake2",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Interface",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Functor",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let s (a : alg) (m : m_spec) = Core.(state_p a m & state_p a m) | let s (a: alg) (m: m_spec) = | false | null | false | let open Core in state_p a m & state_p a m | {
"checked_file": "Hacl.Streaming.Blake2.fst.checked",
"dependencies": [
"Spec.Blake2.Alternative.fsti.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Interface.fsti.checked",
"Hacl.Streaming.Functor.fsti.checked",
"Hacl.Impl.Blake2.Generic.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Blake2s_32.fst.checked",
"Hacl.Blake2b_32.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt128.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Streaming.Blake2.fst"
} | [
"total"
] | [
"Hacl.Streaming.Blake2.alg",
"Hacl.Streaming.Blake2.m_spec",
"FStar.Pervasives.Native.tuple2",
"Hacl.Impl.Blake2.Core.state_p"
] | [] | module Hacl.Streaming.Blake2
module HS = FStar.HyperStack
module B = LowStar.Buffer
module G = FStar.Ghost
module S = FStar.Seq
module LS = Lib.Sequence
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module U128 = FStar.UInt128
module F = Hacl.Streaming.Functor
module I = Hacl.Streaming.Interface
module ST = FStar.HyperStack.ST
open FStar.Mul
module Loops = Lib.LoopCombinators
/// Opening a bunch of modules for Blake2
/// =====================================
inline_for_extraction noextract
let uint8 = Lib.IntTypes.uint8
inline_for_extraction noextract
let uint32 = Lib.IntTypes.uint32
unfold noextract
let size_nat = Lib.IntTypes.size_nat
unfold noextract
let max_key = Spec.Blake2.max_key
unfold noextract
let lbytes = Lib.ByteSequence.lbytes
module Spec = Spec.Blake2
module Core = Hacl.Impl.Blake2.Core
open Hacl.Impl.Blake2.Generic
module Blake2s32 = Hacl.Blake2s_32
module Blake2b32 = Hacl.Blake2b_32
/// An instance of the stateful type class for blake2
/// =================================================
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50"
inline_for_extraction noextract
let index = unit
inline_for_extraction noextract
let alg = Spec.alg
inline_for_extraction noextract
let m_spec = Core.m_spec
/// The stateful state: (wv, hash) | false | false | Hacl.Streaming.Blake2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val s : a: Hacl.Streaming.Blake2.alg -> m: Hacl.Streaming.Blake2.m_spec -> Type0 | [] | Hacl.Streaming.Blake2.s | {
"file_name": "code/streaming/Hacl.Streaming.Blake2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Hacl.Streaming.Blake2.alg -> m: Hacl.Streaming.Blake2.m_spec -> Type0 | {
"end_col": 63,
"end_line": 59,
"start_col": 31,
"start_line": 59
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Blake2b_32",
"short_module": "Blake2b32"
},
{
"abbrev": true,
"full_module": "Hacl.Blake2s_32",
"short_module": "Blake2s32"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2.Generic",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Blake2.Core",
"short_module": "Core"
},
{
"abbrev": true,
"full_module": "Spec.Blake2",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Interface",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Functor",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let k = stateful_key | let k = | false | null | false | stateful_key | {
"checked_file": "Hacl.Streaming.Blake2.fst.checked",
"dependencies": [
"Spec.Blake2.Alternative.fsti.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Interface.fsti.checked",
"Hacl.Streaming.Functor.fsti.checked",
"Hacl.Impl.Blake2.Generic.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Blake2s_32.fst.checked",
"Hacl.Blake2b_32.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt128.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Streaming.Blake2.fst"
} | [
"total"
] | [
"Hacl.Streaming.Blake2.stateful_key"
] | [] | module Hacl.Streaming.Blake2
module HS = FStar.HyperStack
module B = LowStar.Buffer
module G = FStar.Ghost
module S = FStar.Seq
module LS = Lib.Sequence
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module U128 = FStar.UInt128
module F = Hacl.Streaming.Functor
module I = Hacl.Streaming.Interface
module ST = FStar.HyperStack.ST
open FStar.Mul
module Loops = Lib.LoopCombinators
/// Opening a bunch of modules for Blake2
/// =====================================
inline_for_extraction noextract
let uint8 = Lib.IntTypes.uint8
inline_for_extraction noextract
let uint32 = Lib.IntTypes.uint32
unfold noextract
let size_nat = Lib.IntTypes.size_nat
unfold noextract
let max_key = Spec.Blake2.max_key
unfold noextract
let lbytes = Lib.ByteSequence.lbytes
module Spec = Spec.Blake2
module Core = Hacl.Impl.Blake2.Core
open Hacl.Impl.Blake2.Generic
module Blake2s32 = Hacl.Blake2s_32
module Blake2b32 = Hacl.Blake2b_32
/// An instance of the stateful type class for blake2
/// =================================================
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50"
inline_for_extraction noextract
let index = unit
inline_for_extraction noextract
let alg = Spec.alg
inline_for_extraction noextract
let m_spec = Core.m_spec
/// The stateful state: (wv, hash)
inline_for_extraction noextract
let s (a : alg) (m : m_spec) = Core.(state_p a m & state_p a m)
inline_for_extraction noextract
let t (a : alg) = Spec.state a
(* In the internal state, we keep wv, the working vector. It's essentially
temporary scratch space that the Blake2 implementation expects to receive. (Why
is the implementation not performing its own stack allocations? Don't know!) *)
inline_for_extraction noextract
let get_wv (#a : alg) (#m : m_spec) (s : s a m) : Tot (Core.state_p a m) =
match s with wv, _ -> wv
inline_for_extraction noextract
let get_state_p (#a : alg) (#m : m_spec) (s : s a m) : Tot (Core.state_p a m) =
match s with _, p -> p
(* But the working vector is not reflected in the state at all -- it doesn't
have meaningful specification contents. *)
inline_for_extraction noextract
let state_v (#a : alg) (#m : m_spec) (h : HS.mem) (s : s a m) : GTot (Spec.state a) =
Core.state_v h (get_state_p s)
inline_for_extraction noextract
let s_v (#a : alg) (#m : m_spec) (h : HS.mem) (s : s a m) : GTot (t a) =
state_v h s
/// Small helper which facilitates inferencing implicit arguments for buffer
/// operations
inline_for_extraction noextract
let state_to_lbuffer (#a : alg) (#m : m_spec) (s : Core.state_p a m) :
B.lbuffer (Core.element_t a m) (4 * U32.v (Core.row_len a m)) =
s
inline_for_extraction noextract
let stateful_blake2 (a : alg) (m : m_spec) : I.stateful unit =
I.Stateful
(fun () -> s a m) (* s *)
(* footprint *)
(fun #_ _ acc ->
let wv, b = acc in
B.loc_union
(B.loc_addr_of_buffer (state_to_lbuffer wv))
(B.loc_addr_of_buffer (state_to_lbuffer b)))
(* freeable *)
(fun #_ _ acc ->
let wv, b = acc in
B.freeable (state_to_lbuffer wv) /\
B.freeable (state_to_lbuffer b))
(* invariant *)
(fun #_ h acc ->
let wv, b = acc in
B.live h (state_to_lbuffer wv) /\
B.live h (state_to_lbuffer b) /\
B.disjoint (state_to_lbuffer wv) (state_to_lbuffer b))
(fun () -> t a) (* t *)
(fun () h acc -> s_v h acc) (* v *)
(fun #_ h acc -> let wv, b = acc in ()) (* invariant_loc_in_footprint *)
(fun #_ l acc h0 h1 -> let wv, b = acc in ()) (* frame_invariant *)
(fun #_ _ _ _ _ -> ()) (* frame_freeable *)
(* alloca *)
(fun () ->
let wv = Core.alloc_state a m in
let b = Core.alloc_state a m in
wv, b)
(* create_in *)
(fun () r ->
let wv = B.malloc r (Core.zero_element a m) U32.(4ul *^ Core.row_len a m) in
let b = B.malloc r (Core.zero_element a m) U32.(4ul *^ Core.row_len a m) in
wv, b)
(* free *)
(fun _ acc ->
match acc with wv, b ->
B.free (state_to_lbuffer wv);
B.free (state_to_lbuffer b))
(* copy *)
(fun _ src dst ->
match src with src_wv, src_b ->
match dst with src_wv, dst_b ->
B.blit (state_to_lbuffer src_b) 0ul (state_to_lbuffer dst_b) 0ul
U32.(4ul *^ Core.row_len a m))
/// Stateful key
/// ============
inline_for_extraction noextract
let key_size (a : alg) = kk:nat{kk <= Spec.max_key a}
inline_for_extraction noextract
let key_size_t (a : alg) =
key_size:U32.t{U32.v key_size <= Spec.max_key a}
/// Defining stateful keys
inline_for_extraction noextract
let stateful_key_t (a : alg) (key_size : key_size a) : Type =
if key_size = 0 then unit else b:B.buffer uint8 { B.length b == key_size}
inline_for_extraction noextract
let buffer_to_stateful_key_t (a : alg) (kk : key_size a{kk > 0})
(k : B.buffer uint8 { B.length k == kk }) :
Tot (stateful_key_t a kk) =
k
inline_for_extraction noextract
let unit_to_stateful_key_t (a : alg) :
Tot (stateful_key_t a 0) =
()
/// The ``has_key`` parameter is meta
/// TODO: this definition could be moved to Hacl.Streaming.Interface, it could
/// be pretty useful in other situations as it generalizes ``stateful_buffer`` in
/// the case the length is zero. Note that rather than being unit, the type could
/// be buffer too (and we would use null whenever needed).
inline_for_extraction noextract
let stateful_key (a : alg) (kk : key_size a) :
I.stateful unit =
I.Stateful
(fun _ -> stateful_key_t a kk)
(* footprint *)
(fun #_ h s -> if kk = 0 then B.loc_none else B.loc_addr_of_buffer (s <: B.buffer uint8))
(* freeable *)
(fun #_ h s -> if kk = 0 then True else B.freeable (s <: B.buffer uint8))
(* invariant *)
(fun #_ h s ->
if kk = 0 then True
else B.live h (s <: B.buffer uint8))
(fun _ -> s:S.seq uint8 { S.length s == kk })
(fun _ h s -> if kk = 0 then Seq.empty else B.as_seq h (s <: B.buffer uint8))
(fun #_ h s -> ()) (* invariant_loc_in_footprint *)
(fun #_ l s h0 h1 -> ()) (* frame_invariant *)
(fun #_ l s h0 h1 -> ()) (* frame_freeable *)
(* alloca *)
(fun () ->
if kk > 0 then
buffer_to_stateful_key_t a kk (B.alloca (Lib.IntTypes.u8 0) (U32.uint_to_t kk))
else unit_to_stateful_key_t a)
(* create_in *)
(fun () r ->
if kk > 0 then
buffer_to_stateful_key_t a kk (B.malloc r (Lib.IntTypes.u8 0) (U32.uint_to_t kk))
else unit_to_stateful_key_t a)
(* free *)
(fun _ s -> if kk > 0 then B.free (s <: B.buffer uint8) else ())
(* copy *)
(fun _ s_src s_dst ->
if kk > 0 then
B.blit (s_src <: B.buffer uint8) 0ul
(s_dst <: B.buffer uint8) 0ul (U32.uint_to_t kk)
else ())
inline_for_extraction noextract
let stateful_key_to_buffer (#a : alg) (#kk : key_size a)
(key : stateful_key_t a kk) :
b:B.buffer uint8 { B.length b = kk } =
if kk = 0 then B.null #uint8 else key | false | false | Hacl.Streaming.Blake2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val k : a: Hacl.Streaming.Blake2.alg -> kk: Hacl.Streaming.Blake2.key_size a
-> Hacl.Streaming.Interface.stateful Prims.unit | [] | Hacl.Streaming.Blake2.k | {
"file_name": "code/streaming/Hacl.Streaming.Blake2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Hacl.Streaming.Blake2.alg -> kk: Hacl.Streaming.Blake2.key_size a
-> Hacl.Streaming.Interface.stateful Prims.unit | {
"end_col": 20,
"end_line": 219,
"start_col": 8,
"start_line": 219
} |
|
Prims.Tot | val block_len (a: alg) : U32.t | [
{
"abbrev": true,
"full_module": "Hacl.Blake2b_32",
"short_module": "Blake2b32"
},
{
"abbrev": true,
"full_module": "Hacl.Blake2s_32",
"short_module": "Blake2s32"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2.Generic",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Blake2.Core",
"short_module": "Core"
},
{
"abbrev": true,
"full_module": "Spec.Blake2",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Interface",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Functor",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let block_len (a : alg) : U32.t = Core.size_block a | val block_len (a: alg) : U32.t
let block_len (a: alg) : U32.t = | false | null | false | Core.size_block a | {
"checked_file": "Hacl.Streaming.Blake2.fst.checked",
"dependencies": [
"Spec.Blake2.Alternative.fsti.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Interface.fsti.checked",
"Hacl.Streaming.Functor.fsti.checked",
"Hacl.Impl.Blake2.Generic.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Blake2s_32.fst.checked",
"Hacl.Blake2b_32.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt128.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Streaming.Blake2.fst"
} | [
"total"
] | [
"Hacl.Streaming.Blake2.alg",
"Hacl.Impl.Blake2.Core.size_block",
"FStar.UInt32.t"
] | [] | module Hacl.Streaming.Blake2
module HS = FStar.HyperStack
module B = LowStar.Buffer
module G = FStar.Ghost
module S = FStar.Seq
module LS = Lib.Sequence
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module U128 = FStar.UInt128
module F = Hacl.Streaming.Functor
module I = Hacl.Streaming.Interface
module ST = FStar.HyperStack.ST
open FStar.Mul
module Loops = Lib.LoopCombinators
/// Opening a bunch of modules for Blake2
/// =====================================
inline_for_extraction noextract
let uint8 = Lib.IntTypes.uint8
inline_for_extraction noextract
let uint32 = Lib.IntTypes.uint32
unfold noextract
let size_nat = Lib.IntTypes.size_nat
unfold noextract
let max_key = Spec.Blake2.max_key
unfold noextract
let lbytes = Lib.ByteSequence.lbytes
module Spec = Spec.Blake2
module Core = Hacl.Impl.Blake2.Core
open Hacl.Impl.Blake2.Generic
module Blake2s32 = Hacl.Blake2s_32
module Blake2b32 = Hacl.Blake2b_32
/// An instance of the stateful type class for blake2
/// =================================================
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50"
inline_for_extraction noextract
let index = unit
inline_for_extraction noextract
let alg = Spec.alg
inline_for_extraction noextract
let m_spec = Core.m_spec
/// The stateful state: (wv, hash)
inline_for_extraction noextract
let s (a : alg) (m : m_spec) = Core.(state_p a m & state_p a m)
inline_for_extraction noextract
let t (a : alg) = Spec.state a
(* In the internal state, we keep wv, the working vector. It's essentially
temporary scratch space that the Blake2 implementation expects to receive. (Why
is the implementation not performing its own stack allocations? Don't know!) *)
inline_for_extraction noextract
let get_wv (#a : alg) (#m : m_spec) (s : s a m) : Tot (Core.state_p a m) =
match s with wv, _ -> wv
inline_for_extraction noextract
let get_state_p (#a : alg) (#m : m_spec) (s : s a m) : Tot (Core.state_p a m) =
match s with _, p -> p
(* But the working vector is not reflected in the state at all -- it doesn't
have meaningful specification contents. *)
inline_for_extraction noextract
let state_v (#a : alg) (#m : m_spec) (h : HS.mem) (s : s a m) : GTot (Spec.state a) =
Core.state_v h (get_state_p s)
inline_for_extraction noextract
let s_v (#a : alg) (#m : m_spec) (h : HS.mem) (s : s a m) : GTot (t a) =
state_v h s
/// Small helper which facilitates inferencing implicit arguments for buffer
/// operations
inline_for_extraction noextract
let state_to_lbuffer (#a : alg) (#m : m_spec) (s : Core.state_p a m) :
B.lbuffer (Core.element_t a m) (4 * U32.v (Core.row_len a m)) =
s
inline_for_extraction noextract
let stateful_blake2 (a : alg) (m : m_spec) : I.stateful unit =
I.Stateful
(fun () -> s a m) (* s *)
(* footprint *)
(fun #_ _ acc ->
let wv, b = acc in
B.loc_union
(B.loc_addr_of_buffer (state_to_lbuffer wv))
(B.loc_addr_of_buffer (state_to_lbuffer b)))
(* freeable *)
(fun #_ _ acc ->
let wv, b = acc in
B.freeable (state_to_lbuffer wv) /\
B.freeable (state_to_lbuffer b))
(* invariant *)
(fun #_ h acc ->
let wv, b = acc in
B.live h (state_to_lbuffer wv) /\
B.live h (state_to_lbuffer b) /\
B.disjoint (state_to_lbuffer wv) (state_to_lbuffer b))
(fun () -> t a) (* t *)
(fun () h acc -> s_v h acc) (* v *)
(fun #_ h acc -> let wv, b = acc in ()) (* invariant_loc_in_footprint *)
(fun #_ l acc h0 h1 -> let wv, b = acc in ()) (* frame_invariant *)
(fun #_ _ _ _ _ -> ()) (* frame_freeable *)
(* alloca *)
(fun () ->
let wv = Core.alloc_state a m in
let b = Core.alloc_state a m in
wv, b)
(* create_in *)
(fun () r ->
let wv = B.malloc r (Core.zero_element a m) U32.(4ul *^ Core.row_len a m) in
let b = B.malloc r (Core.zero_element a m) U32.(4ul *^ Core.row_len a m) in
wv, b)
(* free *)
(fun _ acc ->
match acc with wv, b ->
B.free (state_to_lbuffer wv);
B.free (state_to_lbuffer b))
(* copy *)
(fun _ src dst ->
match src with src_wv, src_b ->
match dst with src_wv, dst_b ->
B.blit (state_to_lbuffer src_b) 0ul (state_to_lbuffer dst_b) 0ul
U32.(4ul *^ Core.row_len a m))
/// Stateful key
/// ============
inline_for_extraction noextract
let key_size (a : alg) = kk:nat{kk <= Spec.max_key a}
inline_for_extraction noextract
let key_size_t (a : alg) =
key_size:U32.t{U32.v key_size <= Spec.max_key a}
/// Defining stateful keys
inline_for_extraction noextract
let stateful_key_t (a : alg) (key_size : key_size a) : Type =
if key_size = 0 then unit else b:B.buffer uint8 { B.length b == key_size}
inline_for_extraction noextract
let buffer_to_stateful_key_t (a : alg) (kk : key_size a{kk > 0})
(k : B.buffer uint8 { B.length k == kk }) :
Tot (stateful_key_t a kk) =
k
inline_for_extraction noextract
let unit_to_stateful_key_t (a : alg) :
Tot (stateful_key_t a 0) =
()
/// The ``has_key`` parameter is meta
/// TODO: this definition could be moved to Hacl.Streaming.Interface, it could
/// be pretty useful in other situations as it generalizes ``stateful_buffer`` in
/// the case the length is zero. Note that rather than being unit, the type could
/// be buffer too (and we would use null whenever needed).
inline_for_extraction noextract
let stateful_key (a : alg) (kk : key_size a) :
I.stateful unit =
I.Stateful
(fun _ -> stateful_key_t a kk)
(* footprint *)
(fun #_ h s -> if kk = 0 then B.loc_none else B.loc_addr_of_buffer (s <: B.buffer uint8))
(* freeable *)
(fun #_ h s -> if kk = 0 then True else B.freeable (s <: B.buffer uint8))
(* invariant *)
(fun #_ h s ->
if kk = 0 then True
else B.live h (s <: B.buffer uint8))
(fun _ -> s:S.seq uint8 { S.length s == kk })
(fun _ h s -> if kk = 0 then Seq.empty else B.as_seq h (s <: B.buffer uint8))
(fun #_ h s -> ()) (* invariant_loc_in_footprint *)
(fun #_ l s h0 h1 -> ()) (* frame_invariant *)
(fun #_ l s h0 h1 -> ()) (* frame_freeable *)
(* alloca *)
(fun () ->
if kk > 0 then
buffer_to_stateful_key_t a kk (B.alloca (Lib.IntTypes.u8 0) (U32.uint_to_t kk))
else unit_to_stateful_key_t a)
(* create_in *)
(fun () r ->
if kk > 0 then
buffer_to_stateful_key_t a kk (B.malloc r (Lib.IntTypes.u8 0) (U32.uint_to_t kk))
else unit_to_stateful_key_t a)
(* free *)
(fun _ s -> if kk > 0 then B.free (s <: B.buffer uint8) else ())
(* copy *)
(fun _ s_src s_dst ->
if kk > 0 then
B.blit (s_src <: B.buffer uint8) 0ul
(s_dst <: B.buffer uint8) 0ul (U32.uint_to_t kk)
else ())
inline_for_extraction noextract
let stateful_key_to_buffer (#a : alg) (#kk : key_size a)
(key : stateful_key_t a kk) :
b:B.buffer uint8 { B.length b = kk } =
if kk = 0 then B.null #uint8 else key
inline_for_extraction noextract
let k = stateful_key
/// Actual functor instantiation
/// ============================
/// Small helpers
/// -------------
noextract
let max_input_length (a : alg) : n:nat { n <= Spec.max_limb a /\ n > Spec.size_block a } =
assert_norm (pow2 64 < pow2 128);
pow2 64 - 1
noextract inline_for_extraction
let max_input_len (a: alg): (x:U64.t { U64.v x == max_input_length a }) = 0xffffffffffffffffUL
inline_for_extraction noextract
let block (a : alg) = (block: S.seq uint8 { S.length block = Spec.size_block a }) | false | false | Hacl.Streaming.Blake2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val block_len (a: alg) : U32.t | [] | Hacl.Streaming.Blake2.block_len | {
"file_name": "code/streaming/Hacl.Streaming.Blake2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Hacl.Streaming.Blake2.alg -> FStar.UInt32.t | {
"end_col": 51,
"end_line": 239,
"start_col": 34,
"start_line": 239
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Blake2b_32",
"short_module": "Blake2b32"
},
{
"abbrev": true,
"full_module": "Hacl.Blake2s_32",
"short_module": "Blake2s32"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2.Generic",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Blake2.Core",
"short_module": "Core"
},
{
"abbrev": true,
"full_module": "Spec.Blake2",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Interface",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Functor",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let blake2s_32_block_state = s Spec.Blake2S Core.M32 | let blake2s_32_block_state = | false | null | false | s Spec.Blake2S Core.M32 | {
"checked_file": "Hacl.Streaming.Blake2.fst.checked",
"dependencies": [
"Spec.Blake2.Alternative.fsti.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Interface.fsti.checked",
"Hacl.Streaming.Functor.fsti.checked",
"Hacl.Impl.Blake2.Generic.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Blake2s_32.fst.checked",
"Hacl.Blake2b_32.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt128.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Streaming.Blake2.fst"
} | [
"total"
] | [
"Hacl.Streaming.Blake2.s",
"Spec.Blake2.Blake2S",
"Hacl.Impl.Blake2.Core.M32"
] | [] | module Hacl.Streaming.Blake2
module HS = FStar.HyperStack
module B = LowStar.Buffer
module G = FStar.Ghost
module S = FStar.Seq
module LS = Lib.Sequence
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module U128 = FStar.UInt128
module F = Hacl.Streaming.Functor
module I = Hacl.Streaming.Interface
module ST = FStar.HyperStack.ST
open FStar.Mul
module Loops = Lib.LoopCombinators
/// Opening a bunch of modules for Blake2
/// =====================================
inline_for_extraction noextract
let uint8 = Lib.IntTypes.uint8
inline_for_extraction noextract
let uint32 = Lib.IntTypes.uint32
unfold noextract
let size_nat = Lib.IntTypes.size_nat
unfold noextract
let max_key = Spec.Blake2.max_key
unfold noextract
let lbytes = Lib.ByteSequence.lbytes
module Spec = Spec.Blake2
module Core = Hacl.Impl.Blake2.Core
open Hacl.Impl.Blake2.Generic
module Blake2s32 = Hacl.Blake2s_32
module Blake2b32 = Hacl.Blake2b_32
/// An instance of the stateful type class for blake2
/// =================================================
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50"
inline_for_extraction noextract
let index = unit
inline_for_extraction noextract
let alg = Spec.alg
inline_for_extraction noextract
let m_spec = Core.m_spec
/// The stateful state: (wv, hash)
inline_for_extraction noextract
let s (a : alg) (m : m_spec) = Core.(state_p a m & state_p a m)
inline_for_extraction noextract
let t (a : alg) = Spec.state a
(* In the internal state, we keep wv, the working vector. It's essentially
temporary scratch space that the Blake2 implementation expects to receive. (Why
is the implementation not performing its own stack allocations? Don't know!) *)
inline_for_extraction noextract
let get_wv (#a : alg) (#m : m_spec) (s : s a m) : Tot (Core.state_p a m) =
match s with wv, _ -> wv
inline_for_extraction noextract
let get_state_p (#a : alg) (#m : m_spec) (s : s a m) : Tot (Core.state_p a m) =
match s with _, p -> p
(* But the working vector is not reflected in the state at all -- it doesn't
have meaningful specification contents. *)
inline_for_extraction noextract
let state_v (#a : alg) (#m : m_spec) (h : HS.mem) (s : s a m) : GTot (Spec.state a) =
Core.state_v h (get_state_p s)
inline_for_extraction noextract
let s_v (#a : alg) (#m : m_spec) (h : HS.mem) (s : s a m) : GTot (t a) =
state_v h s
/// Small helper which facilitates inferencing implicit arguments for buffer
/// operations
inline_for_extraction noextract
let state_to_lbuffer (#a : alg) (#m : m_spec) (s : Core.state_p a m) :
B.lbuffer (Core.element_t a m) (4 * U32.v (Core.row_len a m)) =
s
inline_for_extraction noextract
let stateful_blake2 (a : alg) (m : m_spec) : I.stateful unit =
I.Stateful
(fun () -> s a m) (* s *)
(* footprint *)
(fun #_ _ acc ->
let wv, b = acc in
B.loc_union
(B.loc_addr_of_buffer (state_to_lbuffer wv))
(B.loc_addr_of_buffer (state_to_lbuffer b)))
(* freeable *)
(fun #_ _ acc ->
let wv, b = acc in
B.freeable (state_to_lbuffer wv) /\
B.freeable (state_to_lbuffer b))
(* invariant *)
(fun #_ h acc ->
let wv, b = acc in
B.live h (state_to_lbuffer wv) /\
B.live h (state_to_lbuffer b) /\
B.disjoint (state_to_lbuffer wv) (state_to_lbuffer b))
(fun () -> t a) (* t *)
(fun () h acc -> s_v h acc) (* v *)
(fun #_ h acc -> let wv, b = acc in ()) (* invariant_loc_in_footprint *)
(fun #_ l acc h0 h1 -> let wv, b = acc in ()) (* frame_invariant *)
(fun #_ _ _ _ _ -> ()) (* frame_freeable *)
(* alloca *)
(fun () ->
let wv = Core.alloc_state a m in
let b = Core.alloc_state a m in
wv, b)
(* create_in *)
(fun () r ->
let wv = B.malloc r (Core.zero_element a m) U32.(4ul *^ Core.row_len a m) in
let b = B.malloc r (Core.zero_element a m) U32.(4ul *^ Core.row_len a m) in
wv, b)
(* free *)
(fun _ acc ->
match acc with wv, b ->
B.free (state_to_lbuffer wv);
B.free (state_to_lbuffer b))
(* copy *)
(fun _ src dst ->
match src with src_wv, src_b ->
match dst with src_wv, dst_b ->
B.blit (state_to_lbuffer src_b) 0ul (state_to_lbuffer dst_b) 0ul
U32.(4ul *^ Core.row_len a m))
/// Stateful key
/// ============
inline_for_extraction noextract
let key_size (a : alg) = kk:nat{kk <= Spec.max_key a}
inline_for_extraction noextract
let key_size_t (a : alg) =
key_size:U32.t{U32.v key_size <= Spec.max_key a}
/// Defining stateful keys
inline_for_extraction noextract
let stateful_key_t (a : alg) (key_size : key_size a) : Type =
if key_size = 0 then unit else b:B.buffer uint8 { B.length b == key_size}
inline_for_extraction noextract
let buffer_to_stateful_key_t (a : alg) (kk : key_size a{kk > 0})
(k : B.buffer uint8 { B.length k == kk }) :
Tot (stateful_key_t a kk) =
k
inline_for_extraction noextract
let unit_to_stateful_key_t (a : alg) :
Tot (stateful_key_t a 0) =
()
/// The ``has_key`` parameter is meta
/// TODO: this definition could be moved to Hacl.Streaming.Interface, it could
/// be pretty useful in other situations as it generalizes ``stateful_buffer`` in
/// the case the length is zero. Note that rather than being unit, the type could
/// be buffer too (and we would use null whenever needed).
inline_for_extraction noextract
let stateful_key (a : alg) (kk : key_size a) :
I.stateful unit =
I.Stateful
(fun _ -> stateful_key_t a kk)
(* footprint *)
(fun #_ h s -> if kk = 0 then B.loc_none else B.loc_addr_of_buffer (s <: B.buffer uint8))
(* freeable *)
(fun #_ h s -> if kk = 0 then True else B.freeable (s <: B.buffer uint8))
(* invariant *)
(fun #_ h s ->
if kk = 0 then True
else B.live h (s <: B.buffer uint8))
(fun _ -> s:S.seq uint8 { S.length s == kk })
(fun _ h s -> if kk = 0 then Seq.empty else B.as_seq h (s <: B.buffer uint8))
(fun #_ h s -> ()) (* invariant_loc_in_footprint *)
(fun #_ l s h0 h1 -> ()) (* frame_invariant *)
(fun #_ l s h0 h1 -> ()) (* frame_freeable *)
(* alloca *)
(fun () ->
if kk > 0 then
buffer_to_stateful_key_t a kk (B.alloca (Lib.IntTypes.u8 0) (U32.uint_to_t kk))
else unit_to_stateful_key_t a)
(* create_in *)
(fun () r ->
if kk > 0 then
buffer_to_stateful_key_t a kk (B.malloc r (Lib.IntTypes.u8 0) (U32.uint_to_t kk))
else unit_to_stateful_key_t a)
(* free *)
(fun _ s -> if kk > 0 then B.free (s <: B.buffer uint8) else ())
(* copy *)
(fun _ s_src s_dst ->
if kk > 0 then
B.blit (s_src <: B.buffer uint8) 0ul
(s_dst <: B.buffer uint8) 0ul (U32.uint_to_t kk)
else ())
inline_for_extraction noextract
let stateful_key_to_buffer (#a : alg) (#kk : key_size a)
(key : stateful_key_t a kk) :
b:B.buffer uint8 { B.length b = kk } =
if kk = 0 then B.null #uint8 else key
inline_for_extraction noextract
let k = stateful_key
/// Actual functor instantiation
/// ============================
/// Small helpers
/// -------------
noextract
let max_input_length (a : alg) : n:nat { n <= Spec.max_limb a /\ n > Spec.size_block a } =
assert_norm (pow2 64 < pow2 128);
pow2 64 - 1
noextract inline_for_extraction
let max_input_len (a: alg): (x:U64.t { U64.v x == max_input_length a }) = 0xffffffffffffffffUL
inline_for_extraction noextract
let block (a : alg) = (block: S.seq uint8 { S.length block = Spec.size_block a })
inline_for_extraction noextract
let block_len (a : alg) : U32.t = Core.size_block a
inline_for_extraction noextract
let output_size (a : alg) : nat = Spec.max_output a
inline_for_extraction noextract
let output_len (a : alg) = U32.uint_to_t (output_size a)
/// From the functor-provided previous length (uint64, public) to a suitable
/// type for Blake2 (secret uint64/uint128)
inline_for_extraction noextract
let blake2_prevlen (a : alg)
(prevlen : U64.t{ U64.v prevlen <= max_input_length a}) :
x:Spec.limb_t a {
Lib.IntTypes.uint_v x = U64.v prevlen } =
let open Lib.IntTypes in
match a with
| Spec.Blake2S -> to_u64 #U64 #PUB prevlen
| Spec.Blake2B ->
[@inline_let] let x : uint64 = to_u64 #U64 #PUB prevlen in
Lib.IntTypes.cast U128 SEC x
/// Specs
/// -----
noextract
let init_s (a : alg) (kk : size_nat{kk <= max_key a}) :
Tot (t a) =
Spec.blake2_init_hash a kk (output_size a)
noextract
let update_multi_s (#a : alg) (acc : t a)
(prevlen : nat{prevlen % Spec.size_block a = 0})
(input : Seq.seq uint8{ prevlen + S.length input <= max_input_length a /\
S.length input % Spec.size_block a = 0 }) :
Tot (t a)
=
let nb = S.length input / U32.v (block_len a) in
Lib.LoopCombinators.repeati nb (Spec.blake2_update1 a prevlen input) acc
noextract
let update_last_s (#a : alg) (acc : t a)
(prevlen : nat{prevlen % Spec.size_block a = 0})
(input : Seq.seq uint8{ S.length input + prevlen <= max_input_length a /\
S.length input <= Spec.size_block a }) :
Tot (t a) =
Spec.blake2_update_last a prevlen (S.length input) input acc
noextract
let finish_s (#a : alg) (acc : t a) :
output : S.seq uint8 { S.length output = U32.v (output_len a) } =
Spec.blake2_finish a acc (U32.v (output_len a))
noextract
let spec_s (a : alg)
(kk : size_nat{kk <= max_key a})
(key : lbytes kk)
(input : S.seq uint8{if kk = 0 then S.length input <= max_input_length a else S.length input + Spec.size_block a <= max_input_length a}) =
Spec.blake2 a input kk key (output_size a)
/// Interlude for spec proofs
/// -------------------------
val update_multi_zero:
#a : alg ->
acc:t a ->
prevlen:nat{prevlen % Spec.size_block a = 0} ->
Lemma
(requires (prevlen <= max_input_length a))
(ensures (update_multi_s #a acc prevlen S.empty == acc))
let update_multi_zero #a acc prevlen =
Lib.LoopCombinators.eq_repeati0 (0 / U32.v (block_len a)) (Spec.blake2_update1 a prevlen S.empty) acc
#push-options "--z3cliopt smt.arith.nl=false"
val update_multi_associative:
#a : alg ->
acc: t a ->
prevlen1:nat ->
prevlen2:nat ->
input1:S.seq uint8 ->
input2:S.seq uint8 ->
Lemma
(requires (
(**) Math.Lemmas.pos_times_pos_is_pos Spec.size_block_w (Spec.size_word a);
prevlen1 % Spec.size_block a = 0 /\
S.length input1 % Spec.size_block a = 0 /\
S.length input2 % Spec.size_block a = 0 /\
prevlen1 + S.length input1 + S.length input2 <= max_input_length a /\
prevlen2 = prevlen1 + S.length input1))
(ensures (
let input = S.append input1 input2 in
S.length input % Spec.size_block a = 0 /\
prevlen2 % Spec.size_block a = 0 /\
update_multi_s (update_multi_s acc prevlen1 input1) prevlen2 input2 ==
update_multi_s acc prevlen1 input))
#pop-options
#push-options "--z3rlimit 400"
let update_multi_associative #a acc prevlen1 prevlen2 input1 input2 =
let input = S.append input1 input2 in
let nb = S.length input / U32.v (block_len a) in
let nb1 = S.length input1 / U32.v (block_len a) in
let nb2 = S.length input2 / U32.v (block_len a) in
let f = Spec.blake2_update1 a prevlen1 input in
let f1 = Spec.blake2_update1 a prevlen1 input1 in
let f2 = Spec.blake2_update1 a prevlen2 input2 in
let aux1 (i:nat{i < nb1}) (acc:t a) : Lemma (f i acc == f1 i acc)
= assert (Spec.get_blocki a input i `Seq.equal` Spec.get_blocki a input1 i)
in
let aux2 (i:nat{i < nb2}) (acc:t a) : Lemma (f2 i acc == f (i + nb1) acc)
= assert (Spec.get_blocki a input2 i `Seq.equal` Spec.get_blocki a input (i + nb1))
in
let open Lib.LoopCombinators in
let open Lib.Sequence.Lemmas in
calc (==) {
update_multi_s (update_multi_s acc prevlen1 input1) prevlen2 input2;
(==) { }
repeati nb2 f2 (repeati nb1 f1 acc);
(==) {
Classical.forall_intro_2 aux1;
repeati_extensionality nb1 f1 f acc
}
repeati nb2 f2 (repeati nb1 f acc);
(==) {
repeati_def nb1 f acc;
repeati_def nb2 f2 (repeat_right 0 nb1 (fixed_a (t a)) f acc)
}
repeat_right 0 nb2 (fixed_a (t a)) f2 (repeat_right 0 nb1 (fixed_a (t a)) f acc);
(==) {
Classical.forall_intro_2 aux2;
repeat_gen_right_extensionality nb2 nb1 (fixed_a (t a)) (fixed_a (t a)) f2 f (repeat_right 0 nb1 (fixed_a (t a)) f acc)
}
repeat_right nb1 (nb1 + nb2) (fixed_a (t a)) f (repeat_right 0 nb1 (fixed_a (t a)) f acc);
(==) { repeat_right_plus 0 nb1 nb (fixed_a (t a)) f acc; repeati_def nb f acc }
repeati nb f acc;
(==) { }
update_multi_s acc prevlen1 input;
}
#pop-options
/// A helper function: the hash incremental function defined with the functions
/// locally defined (with a signature adapted to the functor).
noextract
val blake2_hash_incremental_s :
a : alg ->
kk: size_nat{kk <= max_key a} ->
k: lbytes kk ->
input:S.seq uint8 { if kk = 0 then S.length input <= max_input_length a else S.length input + (Spec.size_block a) <= max_input_length a } ->
output:S.seq uint8 { S.length output = output_size a }
#push-options "--z3cliopt smt.arith.nl=false"
let blake2_hash_incremental_s a kk k input0 =
let key_block = if kk > 0 then Spec.blake2_key_block a kk k else S.empty in
let key_block_len = S.length key_block in
let input = Seq.append key_block input0 in
assert (key_block_len = (if kk = 0 then 0 else Spec.size_block a));
(**) Math.Lemmas.modulo_lemma 0 (U32.v (block_len a));
let bs, l = Lib.UpdateMulti.split_at_last_lazy (U32.v (block_len a)) input in
let acc1 = init_s a kk in
let acc2 = update_multi_s #a acc1 0 bs in
let acc3 = update_last_s #a acc2 (S.length bs) l in
let acc4 = finish_s #a acc3 in
acc4
#pop-options
#push-options "--z3cliopt smt.arith.nl=false"
val repeati_split_at_eq :
a : alg ->
s : t a ->
input:S.seq uint8 { S.length input <= max_input_length a } ->
Lemma(
let n_blocks, l_last = Spec.split a (S.length input) in
let blocks, last = Lib.UpdateMulti.split_at_last_lazy (U32.v (block_len a)) input in
n_blocks = Lib.Sequence.length blocks / Spec.size_block a /\ // This is necessary for type-checking
Lib.LoopCombinators.repeati n_blocks (Spec.blake2_update1 a 0 input) s ==
Lib.LoopCombinators.repeati n_blocks (Spec.blake2_update1 a 0 blocks) s)
#pop-options
#push-options "--z3cliopt smt.arith.nl=false"
let repeati_split_at_eq a s input =
let n_blocks, l_last = Spec.split a (S.length input) in
let blocks, last = Lib.UpdateMulti.split_at_last_lazy (U32.v (block_len a)) input in
let f = Spec.blake2_update1 a 0 input in
let g = Spec.blake2_update1 a 0 blocks in
let s1 = Lib.LoopCombinators.repeati n_blocks f s in
assert (Lib.Sequence.length blocks = n_blocks * Spec.size_block a);
Math.Lemmas.cancel_mul_div n_blocks (Spec.size_block a);
assert (n_blocks = Lib.Sequence.length blocks / Spec.size_block a);
assert (Lib.Sequence.length blocks <= max_input_length a);
let s2 = Lib.LoopCombinators.repeati n_blocks g s in
assert (input `Seq.equal` Seq.append blocks last);
assert (S.length input = S.length blocks + S.length last);
introduce forall (i:nat{i < n_blocks}). (Spec.get_blocki a input i) `S.equal` (Spec.get_blocki a blocks i)
with
begin
let b0 = Spec.get_blocki a input i in
let b1 = Spec.get_blocki a blocks i in
assert (S.length blocks = n_blocks * Spec.size_block a);
Math.Lemmas.lemma_mult_le_right (Spec.size_block a) (i + 1) n_blocks;
assert ((i + 1) * Spec.size_block a <= S.length blocks);
Math.Lemmas.lemma_mult_le_right (Spec.size_block a) i n_blocks;
assert (i * Spec.size_block a <= S.length blocks);
Math.Lemmas.distributivity_add_left i 1 (Spec.size_block a);
assert ((i + 1) * Spec.size_block a = i * Spec.size_block a + Spec.size_block a);
introduce forall (j: nat{j < Spec.size_block a}). S.index b0 j == S.index b1 j
with
begin
assert (i * Spec.size_block a + j < i * Spec.size_block a + Spec.size_block a);
Math.Lemmas.nat_times_nat_is_nat i (Spec.size_block a);
S.lemma_index_slice input (i * Spec.size_block a) ((i + 1) * Spec.size_block a) j;
assert (S.index b0 j == S.index input (j + (i * Spec.size_block a)))
end
end;
assert (forall (i:nat{i < n_blocks}) acc. f i acc == g i acc);
Lib.Sequence.Lemmas.repeati_extensionality n_blocks f g s
#pop-options
val spec_is_incremental :
a : alg ->
kk: size_nat{kk <= max_key a} ->
k: lbytes kk ->
input:S.seq uint8 { if kk = 0 then S.length input <= max_input_length a else S.length input + (Spec.size_block a) <= max_input_length a } ->
Lemma(
blake2_hash_incremental_s a kk k input ==
Spec.blake2 a input kk k (output_size a))
#restart-solver
#push-options "--z3cliopt smt.arith.nl=false"
let spec_is_incremental a kk k input0 =
let key_block = if kk > 0 then Spec.blake2_key_block a kk k else S.empty in
let key_block_len = S.length key_block in
let input = Seq.append key_block input0 in
let n_blocks, l_last = Spec.split a (S.length input) in
let blocks, last = Lib.UpdateMulti.split_at_last_lazy (U32.v (block_len a)) input in
let s = init_s a kk in
repeati_split_at_eq a s input;
let f = Spec.blake2_update1 a 0 input in
let g = Spec.blake2_update1 a 0 blocks in
let s1 = Lib.LoopCombinators.repeati n_blocks f s in
let s2 = Lib.LoopCombinators.repeati n_blocks g s in
assert (s1 == s2);
S.lemma_eq_intro (S.slice input (S.length input - l_last) (S.length input)) last;
S.lemma_eq_intro (S.slice last (S.length last - l_last) (S.length last)) last;
Spec.Blake2.Alternative.lemma_spec_equivalence_update a kk k input0 s;
assert (U32.v (output_len a) = output_size a)
#pop-options
inline_for_extraction noextract
val init_key_block (a : alg) (kk : key_size a) (k : stateful_key_t a kk)
(buf_: B.buffer uint8 { B.length buf_ = Spec.size_block a }) :
ST.Stack unit
(requires fun h0 ->
let key = stateful_key a kk in
key.invariant h0 k /\
B.live h0 buf_ /\
B.(loc_disjoint (loc_buffer buf_) (key.footprint h0 k)))
(ensures fun h0 _ h1 ->
B.(modifies (loc_buffer buf_) h0 h1) /\
begin
let k = (stateful_key a kk).v () h0 k in
let input_length = if kk > 0 then Spec.size_block a else 0 in
let input = if kk > 0 then Spec.blake2_key_block a kk k else S.empty in
S.equal (S.slice (B.as_seq h1 buf_) 0 input_length) input
end)
let init_key_block a kk k buf_ =
if kk = 0 then ()
else
begin
(**) let h0 = ST.get () in
(* Set the end of the buffer to 0 *)
[@inline_let] let sub_b_len = U32.(block_len a -^ U32.uint_to_t kk) in
let sub_b = B.sub buf_ (U32.uint_to_t kk) sub_b_len in
B.fill sub_b (Lib.IntTypes.u8 0) sub_b_len;
(**) let h1 = ST.get () in
(**) assert(S.slice (B.as_seq h1 buf_) kk (Spec.size_block a) `S.equal` B.as_seq h1 sub_b);
(* Copy the key at the beginning of the buffer *)
Lib.Buffer.update_sub #Lib.Buffer.MUT #uint8 #(U32.uint_to_t (Spec.size_block a))
buf_ 0ul (U32.uint_to_t kk) (stateful_key_to_buffer k);
(**) let h2 = ST.get () in
(**) begin
(**) let k : LS.lseq uint8 kk = (stateful_key a kk).v () h0 k in
(**) let buf_v1 : LS.lseq uint8 (Spec.size_block a) = B.as_seq h1 buf_ in
(**) let buf_v2 : LS.lseq uint8 (Spec.size_block a) = B.as_seq h2 buf_ in
(* Prove that [buf_] is equal to [key @ create ... 0] *)
(**) assert(buf_v2 `S.equal` LS.update_sub buf_v1 0 kk k);
(**) let zeroed : LS.lseq uint8 (Spec.size_block a - kk) = S.create (Spec.size_block a - kk) (Lib.IntTypes.u8 0) in
(**) assert(B.as_seq h1 sub_b `S.equal` zeroed);
(**) let key_and_zeroed : LS.lseq uint8 (Spec.size_block a) = Seq.append k zeroed in
(**) assert(S.equal (S.slice key_and_zeroed 0 kk) k);
(**) assert(S.equal (S.slice key_and_zeroed kk (Spec.size_block a)) zeroed);
(**) LS.lemma_update_sub #uint8 #(Spec.size_block a) buf_v1 0 kk k key_and_zeroed;
(**) assert(buf_v2 `S.equal` key_and_zeroed);
(* Prove that the initial input is equal to [key @ create ... 0] *)
(**) let input = Spec.blake2_key_block a kk k in
(**) let key_block0: LS.lseq uint8 (Spec.size_block a) = S.create (Spec.size_block a) (Lib.IntTypes.u8 0) in
(**) assert(input `S.equal` LS.update_sub key_block0 0 kk k);
(**) assert(Seq.equal (LS.sub key_and_zeroed 0 kk) k);
(**) assert(Seq.equal (LS.sub key_and_zeroed kk (Spec.size_block a - kk))
(LS.sub key_block0 kk (Spec.size_block a - kk)));
(**) LS.lemma_update_sub #uint8 #(Spec.size_block a) key_block0 0 kk k key_and_zeroed;
(**) assert(input `S.equal` key_and_zeroed)
(**) end
end
/// Runtime
/// -------
#push-options "--ifuel 1"// --z3cliopt smt.arith.nl=false"
inline_for_extraction noextract
let blake2 (a : alg)
(m : valid_m_spec a)
(kk : key_size a)
(init : blake2_init_st a m)
(update_multi : blake2_update_multi_st a m)
(update_last : blake2_update_last_st a m)
(finish : blake2_finish_st a m) :
I.block unit =
I.Block
I.Erased (* key management *)
(stateful_blake2 a m) (* state *)
(stateful_key a kk) (* key *)
unit (* output_length_t *)
(fun () -> max_input_len a) (* max_input_length *)
(fun () () -> output_size a) (* output_len *)
(fun () -> block_len a) (* block_len *)
(fun () -> block_len a) (* blocks_state_len *)
(fun () -> if kk > 0 then block_len a else 0ul) (* init_input_len *)
(fun () k -> if kk > 0 then Spec.blake2_key_block a kk k else S.empty)
(fun () _k -> init_s a kk) (* init_s *)
(fun () acc prevlen input -> update_multi_s acc prevlen input) (* update_multi_s *)
(fun () acc prevlen input -> update_last_s acc prevlen input) (* update_last_s *)
(fun () _k acc _ -> finish_s #a acc) (* finish_s *)
(fun () k input l -> spec_s a kk k input) (* spec_s *)
(* update_multi_zero *)
(fun () acc prevlen -> update_multi_zero #a acc prevlen)
(* update_multi_associative *)
(fun () acc prevlen1 prevlen2 input1 input2 ->
update_multi_associative acc prevlen1 prevlen2 input1 input2)
(fun () k input _ ->
spec_is_incremental a kk k input) (* spec_is_incremental *)
(fun _ acc -> ()) (* index_of_state *)
(* init *)
(fun _ key buf_ acc ->
[@inline_let] let wv = get_wv acc in
[@inline_let] let h = get_state_p acc in
init_key_block a kk key buf_;
init h (Lib.IntTypes.size kk) (output_len a))
(* update_multi *)
(fun _ acc prevlen blocks len ->
let wv, hash = acc in
let nb = len `U32.div` Core.size_block a in
update_multi #len wv hash (blake2_prevlen a prevlen) blocks nb)
(* update_last *)
(fun _ acc prevlen last last_len ->
let wv, hash = acc in
update_last #last_len wv hash (blake2_prevlen a prevlen) last_len last)
(* finish *)
(fun _ k acc dst _ ->
[@inline_let] let wv = get_wv acc in
[@inline_let] let h = get_state_p acc in
finish (output_len a) dst h)
#pop-options
/// Introducing intermediate definitions for the instantiation
inline_for_extraction noextract
let blake2s_32 kk =
blake2 Spec.Blake2S Core.M32 kk Blake2s32.blake2s_init Blake2s32.blake2s_update_multi
Blake2s32.blake2s_update_last Blake2s32.blake2s_finish
inline_for_extraction noextract
let blake2b_32 kk =
blake2 Spec.Blake2B Core.M32 kk Blake2b32.blake2b_init Blake2b32.blake2b_update_multi
Blake2b32.blake2b_update_last Blake2b32.blake2b_finish
inline_for_extraction noextract
let empty_key a = I.optional_key () I.Erased (stateful_key a 0)
/// Type abbreviations - makes KaRaMeL use pretty names in the generated code | false | false | Hacl.Streaming.Blake2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val blake2s_32_block_state : Type0 | [] | Hacl.Streaming.Blake2.blake2s_32_block_state | {
"file_name": "code/streaming/Hacl.Streaming.Blake2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 52,
"end_line": 637,
"start_col": 29,
"start_line": 637
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Blake2b_32",
"short_module": "Blake2b32"
},
{
"abbrev": true,
"full_module": "Hacl.Blake2s_32",
"short_module": "Blake2s32"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2.Generic",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Blake2.Core",
"short_module": "Core"
},
{
"abbrev": true,
"full_module": "Spec.Blake2",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Interface",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Functor",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let t (a : alg) = Spec.state a | let t (a: alg) = | false | null | false | Spec.state a | {
"checked_file": "Hacl.Streaming.Blake2.fst.checked",
"dependencies": [
"Spec.Blake2.Alternative.fsti.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Interface.fsti.checked",
"Hacl.Streaming.Functor.fsti.checked",
"Hacl.Impl.Blake2.Generic.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Blake2s_32.fst.checked",
"Hacl.Blake2b_32.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt128.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Streaming.Blake2.fst"
} | [
"total"
] | [
"Hacl.Streaming.Blake2.alg",
"Spec.Blake2.state"
] | [] | module Hacl.Streaming.Blake2
module HS = FStar.HyperStack
module B = LowStar.Buffer
module G = FStar.Ghost
module S = FStar.Seq
module LS = Lib.Sequence
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module U128 = FStar.UInt128
module F = Hacl.Streaming.Functor
module I = Hacl.Streaming.Interface
module ST = FStar.HyperStack.ST
open FStar.Mul
module Loops = Lib.LoopCombinators
/// Opening a bunch of modules for Blake2
/// =====================================
inline_for_extraction noextract
let uint8 = Lib.IntTypes.uint8
inline_for_extraction noextract
let uint32 = Lib.IntTypes.uint32
unfold noextract
let size_nat = Lib.IntTypes.size_nat
unfold noextract
let max_key = Spec.Blake2.max_key
unfold noextract
let lbytes = Lib.ByteSequence.lbytes
module Spec = Spec.Blake2
module Core = Hacl.Impl.Blake2.Core
open Hacl.Impl.Blake2.Generic
module Blake2s32 = Hacl.Blake2s_32
module Blake2b32 = Hacl.Blake2b_32
/// An instance of the stateful type class for blake2
/// =================================================
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50"
inline_for_extraction noextract
let index = unit
inline_for_extraction noextract
let alg = Spec.alg
inline_for_extraction noextract
let m_spec = Core.m_spec
/// The stateful state: (wv, hash)
inline_for_extraction noextract
let s (a : alg) (m : m_spec) = Core.(state_p a m & state_p a m) | false | false | Hacl.Streaming.Blake2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val t : a: Hacl.Streaming.Blake2.alg -> Type0 | [] | Hacl.Streaming.Blake2.t | {
"file_name": "code/streaming/Hacl.Streaming.Blake2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Hacl.Streaming.Blake2.alg -> Type0 | {
"end_col": 30,
"end_line": 62,
"start_col": 18,
"start_line": 62
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Blake2b_32",
"short_module": "Blake2b32"
},
{
"abbrev": true,
"full_module": "Hacl.Blake2s_32",
"short_module": "Blake2s32"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2.Generic",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Blake2.Core",
"short_module": "Core"
},
{
"abbrev": true,
"full_module": "Spec.Blake2",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Interface",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Functor",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let blake2b_32_block_state = s Spec.Blake2B Core.M32 | let blake2b_32_block_state = | false | null | false | s Spec.Blake2B Core.M32 | {
"checked_file": "Hacl.Streaming.Blake2.fst.checked",
"dependencies": [
"Spec.Blake2.Alternative.fsti.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Interface.fsti.checked",
"Hacl.Streaming.Functor.fsti.checked",
"Hacl.Impl.Blake2.Generic.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Blake2s_32.fst.checked",
"Hacl.Blake2b_32.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt128.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Streaming.Blake2.fst"
} | [
"total"
] | [
"Hacl.Streaming.Blake2.s",
"Spec.Blake2.Blake2B",
"Hacl.Impl.Blake2.Core.M32"
] | [] | module Hacl.Streaming.Blake2
module HS = FStar.HyperStack
module B = LowStar.Buffer
module G = FStar.Ghost
module S = FStar.Seq
module LS = Lib.Sequence
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module U128 = FStar.UInt128
module F = Hacl.Streaming.Functor
module I = Hacl.Streaming.Interface
module ST = FStar.HyperStack.ST
open FStar.Mul
module Loops = Lib.LoopCombinators
/// Opening a bunch of modules for Blake2
/// =====================================
inline_for_extraction noextract
let uint8 = Lib.IntTypes.uint8
inline_for_extraction noextract
let uint32 = Lib.IntTypes.uint32
unfold noextract
let size_nat = Lib.IntTypes.size_nat
unfold noextract
let max_key = Spec.Blake2.max_key
unfold noextract
let lbytes = Lib.ByteSequence.lbytes
module Spec = Spec.Blake2
module Core = Hacl.Impl.Blake2.Core
open Hacl.Impl.Blake2.Generic
module Blake2s32 = Hacl.Blake2s_32
module Blake2b32 = Hacl.Blake2b_32
/// An instance of the stateful type class for blake2
/// =================================================
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50"
inline_for_extraction noextract
let index = unit
inline_for_extraction noextract
let alg = Spec.alg
inline_for_extraction noextract
let m_spec = Core.m_spec
/// The stateful state: (wv, hash)
inline_for_extraction noextract
let s (a : alg) (m : m_spec) = Core.(state_p a m & state_p a m)
inline_for_extraction noextract
let t (a : alg) = Spec.state a
(* In the internal state, we keep wv, the working vector. It's essentially
temporary scratch space that the Blake2 implementation expects to receive. (Why
is the implementation not performing its own stack allocations? Don't know!) *)
inline_for_extraction noextract
let get_wv (#a : alg) (#m : m_spec) (s : s a m) : Tot (Core.state_p a m) =
match s with wv, _ -> wv
inline_for_extraction noextract
let get_state_p (#a : alg) (#m : m_spec) (s : s a m) : Tot (Core.state_p a m) =
match s with _, p -> p
(* But the working vector is not reflected in the state at all -- it doesn't
have meaningful specification contents. *)
inline_for_extraction noextract
let state_v (#a : alg) (#m : m_spec) (h : HS.mem) (s : s a m) : GTot (Spec.state a) =
Core.state_v h (get_state_p s)
inline_for_extraction noextract
let s_v (#a : alg) (#m : m_spec) (h : HS.mem) (s : s a m) : GTot (t a) =
state_v h s
/// Small helper which facilitates inferencing implicit arguments for buffer
/// operations
inline_for_extraction noextract
let state_to_lbuffer (#a : alg) (#m : m_spec) (s : Core.state_p a m) :
B.lbuffer (Core.element_t a m) (4 * U32.v (Core.row_len a m)) =
s
inline_for_extraction noextract
let stateful_blake2 (a : alg) (m : m_spec) : I.stateful unit =
I.Stateful
(fun () -> s a m) (* s *)
(* footprint *)
(fun #_ _ acc ->
let wv, b = acc in
B.loc_union
(B.loc_addr_of_buffer (state_to_lbuffer wv))
(B.loc_addr_of_buffer (state_to_lbuffer b)))
(* freeable *)
(fun #_ _ acc ->
let wv, b = acc in
B.freeable (state_to_lbuffer wv) /\
B.freeable (state_to_lbuffer b))
(* invariant *)
(fun #_ h acc ->
let wv, b = acc in
B.live h (state_to_lbuffer wv) /\
B.live h (state_to_lbuffer b) /\
B.disjoint (state_to_lbuffer wv) (state_to_lbuffer b))
(fun () -> t a) (* t *)
(fun () h acc -> s_v h acc) (* v *)
(fun #_ h acc -> let wv, b = acc in ()) (* invariant_loc_in_footprint *)
(fun #_ l acc h0 h1 -> let wv, b = acc in ()) (* frame_invariant *)
(fun #_ _ _ _ _ -> ()) (* frame_freeable *)
(* alloca *)
(fun () ->
let wv = Core.alloc_state a m in
let b = Core.alloc_state a m in
wv, b)
(* create_in *)
(fun () r ->
let wv = B.malloc r (Core.zero_element a m) U32.(4ul *^ Core.row_len a m) in
let b = B.malloc r (Core.zero_element a m) U32.(4ul *^ Core.row_len a m) in
wv, b)
(* free *)
(fun _ acc ->
match acc with wv, b ->
B.free (state_to_lbuffer wv);
B.free (state_to_lbuffer b))
(* copy *)
(fun _ src dst ->
match src with src_wv, src_b ->
match dst with src_wv, dst_b ->
B.blit (state_to_lbuffer src_b) 0ul (state_to_lbuffer dst_b) 0ul
U32.(4ul *^ Core.row_len a m))
/// Stateful key
/// ============
inline_for_extraction noextract
let key_size (a : alg) = kk:nat{kk <= Spec.max_key a}
inline_for_extraction noextract
let key_size_t (a : alg) =
key_size:U32.t{U32.v key_size <= Spec.max_key a}
/// Defining stateful keys
inline_for_extraction noextract
let stateful_key_t (a : alg) (key_size : key_size a) : Type =
if key_size = 0 then unit else b:B.buffer uint8 { B.length b == key_size}
inline_for_extraction noextract
let buffer_to_stateful_key_t (a : alg) (kk : key_size a{kk > 0})
(k : B.buffer uint8 { B.length k == kk }) :
Tot (stateful_key_t a kk) =
k
inline_for_extraction noextract
let unit_to_stateful_key_t (a : alg) :
Tot (stateful_key_t a 0) =
()
/// The ``has_key`` parameter is meta
/// TODO: this definition could be moved to Hacl.Streaming.Interface, it could
/// be pretty useful in other situations as it generalizes ``stateful_buffer`` in
/// the case the length is zero. Note that rather than being unit, the type could
/// be buffer too (and we would use null whenever needed).
inline_for_extraction noextract
let stateful_key (a : alg) (kk : key_size a) :
I.stateful unit =
I.Stateful
(fun _ -> stateful_key_t a kk)
(* footprint *)
(fun #_ h s -> if kk = 0 then B.loc_none else B.loc_addr_of_buffer (s <: B.buffer uint8))
(* freeable *)
(fun #_ h s -> if kk = 0 then True else B.freeable (s <: B.buffer uint8))
(* invariant *)
(fun #_ h s ->
if kk = 0 then True
else B.live h (s <: B.buffer uint8))
(fun _ -> s:S.seq uint8 { S.length s == kk })
(fun _ h s -> if kk = 0 then Seq.empty else B.as_seq h (s <: B.buffer uint8))
(fun #_ h s -> ()) (* invariant_loc_in_footprint *)
(fun #_ l s h0 h1 -> ()) (* frame_invariant *)
(fun #_ l s h0 h1 -> ()) (* frame_freeable *)
(* alloca *)
(fun () ->
if kk > 0 then
buffer_to_stateful_key_t a kk (B.alloca (Lib.IntTypes.u8 0) (U32.uint_to_t kk))
else unit_to_stateful_key_t a)
(* create_in *)
(fun () r ->
if kk > 0 then
buffer_to_stateful_key_t a kk (B.malloc r (Lib.IntTypes.u8 0) (U32.uint_to_t kk))
else unit_to_stateful_key_t a)
(* free *)
(fun _ s -> if kk > 0 then B.free (s <: B.buffer uint8) else ())
(* copy *)
(fun _ s_src s_dst ->
if kk > 0 then
B.blit (s_src <: B.buffer uint8) 0ul
(s_dst <: B.buffer uint8) 0ul (U32.uint_to_t kk)
else ())
inline_for_extraction noextract
let stateful_key_to_buffer (#a : alg) (#kk : key_size a)
(key : stateful_key_t a kk) :
b:B.buffer uint8 { B.length b = kk } =
if kk = 0 then B.null #uint8 else key
inline_for_extraction noextract
let k = stateful_key
/// Actual functor instantiation
/// ============================
/// Small helpers
/// -------------
noextract
let max_input_length (a : alg) : n:nat { n <= Spec.max_limb a /\ n > Spec.size_block a } =
assert_norm (pow2 64 < pow2 128);
pow2 64 - 1
noextract inline_for_extraction
let max_input_len (a: alg): (x:U64.t { U64.v x == max_input_length a }) = 0xffffffffffffffffUL
inline_for_extraction noextract
let block (a : alg) = (block: S.seq uint8 { S.length block = Spec.size_block a })
inline_for_extraction noextract
let block_len (a : alg) : U32.t = Core.size_block a
inline_for_extraction noextract
let output_size (a : alg) : nat = Spec.max_output a
inline_for_extraction noextract
let output_len (a : alg) = U32.uint_to_t (output_size a)
/// From the functor-provided previous length (uint64, public) to a suitable
/// type for Blake2 (secret uint64/uint128)
inline_for_extraction noextract
let blake2_prevlen (a : alg)
(prevlen : U64.t{ U64.v prevlen <= max_input_length a}) :
x:Spec.limb_t a {
Lib.IntTypes.uint_v x = U64.v prevlen } =
let open Lib.IntTypes in
match a with
| Spec.Blake2S -> to_u64 #U64 #PUB prevlen
| Spec.Blake2B ->
[@inline_let] let x : uint64 = to_u64 #U64 #PUB prevlen in
Lib.IntTypes.cast U128 SEC x
/// Specs
/// -----
noextract
let init_s (a : alg) (kk : size_nat{kk <= max_key a}) :
Tot (t a) =
Spec.blake2_init_hash a kk (output_size a)
noextract
let update_multi_s (#a : alg) (acc : t a)
(prevlen : nat{prevlen % Spec.size_block a = 0})
(input : Seq.seq uint8{ prevlen + S.length input <= max_input_length a /\
S.length input % Spec.size_block a = 0 }) :
Tot (t a)
=
let nb = S.length input / U32.v (block_len a) in
Lib.LoopCombinators.repeati nb (Spec.blake2_update1 a prevlen input) acc
noextract
let update_last_s (#a : alg) (acc : t a)
(prevlen : nat{prevlen % Spec.size_block a = 0})
(input : Seq.seq uint8{ S.length input + prevlen <= max_input_length a /\
S.length input <= Spec.size_block a }) :
Tot (t a) =
Spec.blake2_update_last a prevlen (S.length input) input acc
noextract
let finish_s (#a : alg) (acc : t a) :
output : S.seq uint8 { S.length output = U32.v (output_len a) } =
Spec.blake2_finish a acc (U32.v (output_len a))
noextract
let spec_s (a : alg)
(kk : size_nat{kk <= max_key a})
(key : lbytes kk)
(input : S.seq uint8{if kk = 0 then S.length input <= max_input_length a else S.length input + Spec.size_block a <= max_input_length a}) =
Spec.blake2 a input kk key (output_size a)
/// Interlude for spec proofs
/// -------------------------
val update_multi_zero:
#a : alg ->
acc:t a ->
prevlen:nat{prevlen % Spec.size_block a = 0} ->
Lemma
(requires (prevlen <= max_input_length a))
(ensures (update_multi_s #a acc prevlen S.empty == acc))
let update_multi_zero #a acc prevlen =
Lib.LoopCombinators.eq_repeati0 (0 / U32.v (block_len a)) (Spec.blake2_update1 a prevlen S.empty) acc
#push-options "--z3cliopt smt.arith.nl=false"
val update_multi_associative:
#a : alg ->
acc: t a ->
prevlen1:nat ->
prevlen2:nat ->
input1:S.seq uint8 ->
input2:S.seq uint8 ->
Lemma
(requires (
(**) Math.Lemmas.pos_times_pos_is_pos Spec.size_block_w (Spec.size_word a);
prevlen1 % Spec.size_block a = 0 /\
S.length input1 % Spec.size_block a = 0 /\
S.length input2 % Spec.size_block a = 0 /\
prevlen1 + S.length input1 + S.length input2 <= max_input_length a /\
prevlen2 = prevlen1 + S.length input1))
(ensures (
let input = S.append input1 input2 in
S.length input % Spec.size_block a = 0 /\
prevlen2 % Spec.size_block a = 0 /\
update_multi_s (update_multi_s acc prevlen1 input1) prevlen2 input2 ==
update_multi_s acc prevlen1 input))
#pop-options
#push-options "--z3rlimit 400"
let update_multi_associative #a acc prevlen1 prevlen2 input1 input2 =
let input = S.append input1 input2 in
let nb = S.length input / U32.v (block_len a) in
let nb1 = S.length input1 / U32.v (block_len a) in
let nb2 = S.length input2 / U32.v (block_len a) in
let f = Spec.blake2_update1 a prevlen1 input in
let f1 = Spec.blake2_update1 a prevlen1 input1 in
let f2 = Spec.blake2_update1 a prevlen2 input2 in
let aux1 (i:nat{i < nb1}) (acc:t a) : Lemma (f i acc == f1 i acc)
= assert (Spec.get_blocki a input i `Seq.equal` Spec.get_blocki a input1 i)
in
let aux2 (i:nat{i < nb2}) (acc:t a) : Lemma (f2 i acc == f (i + nb1) acc)
= assert (Spec.get_blocki a input2 i `Seq.equal` Spec.get_blocki a input (i + nb1))
in
let open Lib.LoopCombinators in
let open Lib.Sequence.Lemmas in
calc (==) {
update_multi_s (update_multi_s acc prevlen1 input1) prevlen2 input2;
(==) { }
repeati nb2 f2 (repeati nb1 f1 acc);
(==) {
Classical.forall_intro_2 aux1;
repeati_extensionality nb1 f1 f acc
}
repeati nb2 f2 (repeati nb1 f acc);
(==) {
repeati_def nb1 f acc;
repeati_def nb2 f2 (repeat_right 0 nb1 (fixed_a (t a)) f acc)
}
repeat_right 0 nb2 (fixed_a (t a)) f2 (repeat_right 0 nb1 (fixed_a (t a)) f acc);
(==) {
Classical.forall_intro_2 aux2;
repeat_gen_right_extensionality nb2 nb1 (fixed_a (t a)) (fixed_a (t a)) f2 f (repeat_right 0 nb1 (fixed_a (t a)) f acc)
}
repeat_right nb1 (nb1 + nb2) (fixed_a (t a)) f (repeat_right 0 nb1 (fixed_a (t a)) f acc);
(==) { repeat_right_plus 0 nb1 nb (fixed_a (t a)) f acc; repeati_def nb f acc }
repeati nb f acc;
(==) { }
update_multi_s acc prevlen1 input;
}
#pop-options
/// A helper function: the hash incremental function defined with the functions
/// locally defined (with a signature adapted to the functor).
noextract
val blake2_hash_incremental_s :
a : alg ->
kk: size_nat{kk <= max_key a} ->
k: lbytes kk ->
input:S.seq uint8 { if kk = 0 then S.length input <= max_input_length a else S.length input + (Spec.size_block a) <= max_input_length a } ->
output:S.seq uint8 { S.length output = output_size a }
#push-options "--z3cliopt smt.arith.nl=false"
let blake2_hash_incremental_s a kk k input0 =
let key_block = if kk > 0 then Spec.blake2_key_block a kk k else S.empty in
let key_block_len = S.length key_block in
let input = Seq.append key_block input0 in
assert (key_block_len = (if kk = 0 then 0 else Spec.size_block a));
(**) Math.Lemmas.modulo_lemma 0 (U32.v (block_len a));
let bs, l = Lib.UpdateMulti.split_at_last_lazy (U32.v (block_len a)) input in
let acc1 = init_s a kk in
let acc2 = update_multi_s #a acc1 0 bs in
let acc3 = update_last_s #a acc2 (S.length bs) l in
let acc4 = finish_s #a acc3 in
acc4
#pop-options
#push-options "--z3cliopt smt.arith.nl=false"
val repeati_split_at_eq :
a : alg ->
s : t a ->
input:S.seq uint8 { S.length input <= max_input_length a } ->
Lemma(
let n_blocks, l_last = Spec.split a (S.length input) in
let blocks, last = Lib.UpdateMulti.split_at_last_lazy (U32.v (block_len a)) input in
n_blocks = Lib.Sequence.length blocks / Spec.size_block a /\ // This is necessary for type-checking
Lib.LoopCombinators.repeati n_blocks (Spec.blake2_update1 a 0 input) s ==
Lib.LoopCombinators.repeati n_blocks (Spec.blake2_update1 a 0 blocks) s)
#pop-options
#push-options "--z3cliopt smt.arith.nl=false"
let repeati_split_at_eq a s input =
let n_blocks, l_last = Spec.split a (S.length input) in
let blocks, last = Lib.UpdateMulti.split_at_last_lazy (U32.v (block_len a)) input in
let f = Spec.blake2_update1 a 0 input in
let g = Spec.blake2_update1 a 0 blocks in
let s1 = Lib.LoopCombinators.repeati n_blocks f s in
assert (Lib.Sequence.length blocks = n_blocks * Spec.size_block a);
Math.Lemmas.cancel_mul_div n_blocks (Spec.size_block a);
assert (n_blocks = Lib.Sequence.length blocks / Spec.size_block a);
assert (Lib.Sequence.length blocks <= max_input_length a);
let s2 = Lib.LoopCombinators.repeati n_blocks g s in
assert (input `Seq.equal` Seq.append blocks last);
assert (S.length input = S.length blocks + S.length last);
introduce forall (i:nat{i < n_blocks}). (Spec.get_blocki a input i) `S.equal` (Spec.get_blocki a blocks i)
with
begin
let b0 = Spec.get_blocki a input i in
let b1 = Spec.get_blocki a blocks i in
assert (S.length blocks = n_blocks * Spec.size_block a);
Math.Lemmas.lemma_mult_le_right (Spec.size_block a) (i + 1) n_blocks;
assert ((i + 1) * Spec.size_block a <= S.length blocks);
Math.Lemmas.lemma_mult_le_right (Spec.size_block a) i n_blocks;
assert (i * Spec.size_block a <= S.length blocks);
Math.Lemmas.distributivity_add_left i 1 (Spec.size_block a);
assert ((i + 1) * Spec.size_block a = i * Spec.size_block a + Spec.size_block a);
introduce forall (j: nat{j < Spec.size_block a}). S.index b0 j == S.index b1 j
with
begin
assert (i * Spec.size_block a + j < i * Spec.size_block a + Spec.size_block a);
Math.Lemmas.nat_times_nat_is_nat i (Spec.size_block a);
S.lemma_index_slice input (i * Spec.size_block a) ((i + 1) * Spec.size_block a) j;
assert (S.index b0 j == S.index input (j + (i * Spec.size_block a)))
end
end;
assert (forall (i:nat{i < n_blocks}) acc. f i acc == g i acc);
Lib.Sequence.Lemmas.repeati_extensionality n_blocks f g s
#pop-options
val spec_is_incremental :
a : alg ->
kk: size_nat{kk <= max_key a} ->
k: lbytes kk ->
input:S.seq uint8 { if kk = 0 then S.length input <= max_input_length a else S.length input + (Spec.size_block a) <= max_input_length a } ->
Lemma(
blake2_hash_incremental_s a kk k input ==
Spec.blake2 a input kk k (output_size a))
#restart-solver
#push-options "--z3cliopt smt.arith.nl=false"
let spec_is_incremental a kk k input0 =
let key_block = if kk > 0 then Spec.blake2_key_block a kk k else S.empty in
let key_block_len = S.length key_block in
let input = Seq.append key_block input0 in
let n_blocks, l_last = Spec.split a (S.length input) in
let blocks, last = Lib.UpdateMulti.split_at_last_lazy (U32.v (block_len a)) input in
let s = init_s a kk in
repeati_split_at_eq a s input;
let f = Spec.blake2_update1 a 0 input in
let g = Spec.blake2_update1 a 0 blocks in
let s1 = Lib.LoopCombinators.repeati n_blocks f s in
let s2 = Lib.LoopCombinators.repeati n_blocks g s in
assert (s1 == s2);
S.lemma_eq_intro (S.slice input (S.length input - l_last) (S.length input)) last;
S.lemma_eq_intro (S.slice last (S.length last - l_last) (S.length last)) last;
Spec.Blake2.Alternative.lemma_spec_equivalence_update a kk k input0 s;
assert (U32.v (output_len a) = output_size a)
#pop-options
inline_for_extraction noextract
val init_key_block (a : alg) (kk : key_size a) (k : stateful_key_t a kk)
(buf_: B.buffer uint8 { B.length buf_ = Spec.size_block a }) :
ST.Stack unit
(requires fun h0 ->
let key = stateful_key a kk in
key.invariant h0 k /\
B.live h0 buf_ /\
B.(loc_disjoint (loc_buffer buf_) (key.footprint h0 k)))
(ensures fun h0 _ h1 ->
B.(modifies (loc_buffer buf_) h0 h1) /\
begin
let k = (stateful_key a kk).v () h0 k in
let input_length = if kk > 0 then Spec.size_block a else 0 in
let input = if kk > 0 then Spec.blake2_key_block a kk k else S.empty in
S.equal (S.slice (B.as_seq h1 buf_) 0 input_length) input
end)
let init_key_block a kk k buf_ =
if kk = 0 then ()
else
begin
(**) let h0 = ST.get () in
(* Set the end of the buffer to 0 *)
[@inline_let] let sub_b_len = U32.(block_len a -^ U32.uint_to_t kk) in
let sub_b = B.sub buf_ (U32.uint_to_t kk) sub_b_len in
B.fill sub_b (Lib.IntTypes.u8 0) sub_b_len;
(**) let h1 = ST.get () in
(**) assert(S.slice (B.as_seq h1 buf_) kk (Spec.size_block a) `S.equal` B.as_seq h1 sub_b);
(* Copy the key at the beginning of the buffer *)
Lib.Buffer.update_sub #Lib.Buffer.MUT #uint8 #(U32.uint_to_t (Spec.size_block a))
buf_ 0ul (U32.uint_to_t kk) (stateful_key_to_buffer k);
(**) let h2 = ST.get () in
(**) begin
(**) let k : LS.lseq uint8 kk = (stateful_key a kk).v () h0 k in
(**) let buf_v1 : LS.lseq uint8 (Spec.size_block a) = B.as_seq h1 buf_ in
(**) let buf_v2 : LS.lseq uint8 (Spec.size_block a) = B.as_seq h2 buf_ in
(* Prove that [buf_] is equal to [key @ create ... 0] *)
(**) assert(buf_v2 `S.equal` LS.update_sub buf_v1 0 kk k);
(**) let zeroed : LS.lseq uint8 (Spec.size_block a - kk) = S.create (Spec.size_block a - kk) (Lib.IntTypes.u8 0) in
(**) assert(B.as_seq h1 sub_b `S.equal` zeroed);
(**) let key_and_zeroed : LS.lseq uint8 (Spec.size_block a) = Seq.append k zeroed in
(**) assert(S.equal (S.slice key_and_zeroed 0 kk) k);
(**) assert(S.equal (S.slice key_and_zeroed kk (Spec.size_block a)) zeroed);
(**) LS.lemma_update_sub #uint8 #(Spec.size_block a) buf_v1 0 kk k key_and_zeroed;
(**) assert(buf_v2 `S.equal` key_and_zeroed);
(* Prove that the initial input is equal to [key @ create ... 0] *)
(**) let input = Spec.blake2_key_block a kk k in
(**) let key_block0: LS.lseq uint8 (Spec.size_block a) = S.create (Spec.size_block a) (Lib.IntTypes.u8 0) in
(**) assert(input `S.equal` LS.update_sub key_block0 0 kk k);
(**) assert(Seq.equal (LS.sub key_and_zeroed 0 kk) k);
(**) assert(Seq.equal (LS.sub key_and_zeroed kk (Spec.size_block a - kk))
(LS.sub key_block0 kk (Spec.size_block a - kk)));
(**) LS.lemma_update_sub #uint8 #(Spec.size_block a) key_block0 0 kk k key_and_zeroed;
(**) assert(input `S.equal` key_and_zeroed)
(**) end
end
/// Runtime
/// -------
#push-options "--ifuel 1"// --z3cliopt smt.arith.nl=false"
inline_for_extraction noextract
let blake2 (a : alg)
(m : valid_m_spec a)
(kk : key_size a)
(init : blake2_init_st a m)
(update_multi : blake2_update_multi_st a m)
(update_last : blake2_update_last_st a m)
(finish : blake2_finish_st a m) :
I.block unit =
I.Block
I.Erased (* key management *)
(stateful_blake2 a m) (* state *)
(stateful_key a kk) (* key *)
unit (* output_length_t *)
(fun () -> max_input_len a) (* max_input_length *)
(fun () () -> output_size a) (* output_len *)
(fun () -> block_len a) (* block_len *)
(fun () -> block_len a) (* blocks_state_len *)
(fun () -> if kk > 0 then block_len a else 0ul) (* init_input_len *)
(fun () k -> if kk > 0 then Spec.blake2_key_block a kk k else S.empty)
(fun () _k -> init_s a kk) (* init_s *)
(fun () acc prevlen input -> update_multi_s acc prevlen input) (* update_multi_s *)
(fun () acc prevlen input -> update_last_s acc prevlen input) (* update_last_s *)
(fun () _k acc _ -> finish_s #a acc) (* finish_s *)
(fun () k input l -> spec_s a kk k input) (* spec_s *)
(* update_multi_zero *)
(fun () acc prevlen -> update_multi_zero #a acc prevlen)
(* update_multi_associative *)
(fun () acc prevlen1 prevlen2 input1 input2 ->
update_multi_associative acc prevlen1 prevlen2 input1 input2)
(fun () k input _ ->
spec_is_incremental a kk k input) (* spec_is_incremental *)
(fun _ acc -> ()) (* index_of_state *)
(* init *)
(fun _ key buf_ acc ->
[@inline_let] let wv = get_wv acc in
[@inline_let] let h = get_state_p acc in
init_key_block a kk key buf_;
init h (Lib.IntTypes.size kk) (output_len a))
(* update_multi *)
(fun _ acc prevlen blocks len ->
let wv, hash = acc in
let nb = len `U32.div` Core.size_block a in
update_multi #len wv hash (blake2_prevlen a prevlen) blocks nb)
(* update_last *)
(fun _ acc prevlen last last_len ->
let wv, hash = acc in
update_last #last_len wv hash (blake2_prevlen a prevlen) last_len last)
(* finish *)
(fun _ k acc dst _ ->
[@inline_let] let wv = get_wv acc in
[@inline_let] let h = get_state_p acc in
finish (output_len a) dst h)
#pop-options
/// Introducing intermediate definitions for the instantiation
inline_for_extraction noextract
let blake2s_32 kk =
blake2 Spec.Blake2S Core.M32 kk Blake2s32.blake2s_init Blake2s32.blake2s_update_multi
Blake2s32.blake2s_update_last Blake2s32.blake2s_finish
inline_for_extraction noextract
let blake2b_32 kk =
blake2 Spec.Blake2B Core.M32 kk Blake2b32.blake2b_init Blake2b32.blake2b_update_multi
Blake2b32.blake2b_update_last Blake2b32.blake2b_finish
inline_for_extraction noextract
let empty_key a = I.optional_key () I.Erased (stateful_key a 0)
/// Type abbreviations - makes KaRaMeL use pretty names in the generated code | false | false | Hacl.Streaming.Blake2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val blake2b_32_block_state : Type0 | [] | Hacl.Streaming.Blake2.blake2b_32_block_state | {
"file_name": "code/streaming/Hacl.Streaming.Blake2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 52,
"end_line": 638,
"start_col": 29,
"start_line": 638
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Blake2b_32",
"short_module": "Blake2b32"
},
{
"abbrev": true,
"full_module": "Hacl.Blake2s_32",
"short_module": "Blake2s32"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2.Generic",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Blake2.Core",
"short_module": "Core"
},
{
"abbrev": true,
"full_module": "Spec.Blake2",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Interface",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Functor",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let block (a : alg) = (block: S.seq uint8 { S.length block = Spec.size_block a }) | let block (a: alg) = | false | null | false | (block: S.seq uint8 {S.length block = Spec.size_block a}) | {
"checked_file": "Hacl.Streaming.Blake2.fst.checked",
"dependencies": [
"Spec.Blake2.Alternative.fsti.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Interface.fsti.checked",
"Hacl.Streaming.Functor.fsti.checked",
"Hacl.Impl.Blake2.Generic.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Blake2s_32.fst.checked",
"Hacl.Blake2b_32.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt128.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Streaming.Blake2.fst"
} | [
"total"
] | [
"Hacl.Streaming.Blake2.alg",
"FStar.Seq.Base.seq",
"Hacl.Streaming.Blake2.uint8",
"Prims.b2t",
"Prims.op_Equality",
"Prims.nat",
"FStar.Seq.Base.length",
"Spec.Blake2.size_block"
] | [] | module Hacl.Streaming.Blake2
module HS = FStar.HyperStack
module B = LowStar.Buffer
module G = FStar.Ghost
module S = FStar.Seq
module LS = Lib.Sequence
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module U128 = FStar.UInt128
module F = Hacl.Streaming.Functor
module I = Hacl.Streaming.Interface
module ST = FStar.HyperStack.ST
open FStar.Mul
module Loops = Lib.LoopCombinators
/// Opening a bunch of modules for Blake2
/// =====================================
inline_for_extraction noextract
let uint8 = Lib.IntTypes.uint8
inline_for_extraction noextract
let uint32 = Lib.IntTypes.uint32
unfold noextract
let size_nat = Lib.IntTypes.size_nat
unfold noextract
let max_key = Spec.Blake2.max_key
unfold noextract
let lbytes = Lib.ByteSequence.lbytes
module Spec = Spec.Blake2
module Core = Hacl.Impl.Blake2.Core
open Hacl.Impl.Blake2.Generic
module Blake2s32 = Hacl.Blake2s_32
module Blake2b32 = Hacl.Blake2b_32
/// An instance of the stateful type class for blake2
/// =================================================
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50"
inline_for_extraction noextract
let index = unit
inline_for_extraction noextract
let alg = Spec.alg
inline_for_extraction noextract
let m_spec = Core.m_spec
/// The stateful state: (wv, hash)
inline_for_extraction noextract
let s (a : alg) (m : m_spec) = Core.(state_p a m & state_p a m)
inline_for_extraction noextract
let t (a : alg) = Spec.state a
(* In the internal state, we keep wv, the working vector. It's essentially
temporary scratch space that the Blake2 implementation expects to receive. (Why
is the implementation not performing its own stack allocations? Don't know!) *)
inline_for_extraction noextract
let get_wv (#a : alg) (#m : m_spec) (s : s a m) : Tot (Core.state_p a m) =
match s with wv, _ -> wv
inline_for_extraction noextract
let get_state_p (#a : alg) (#m : m_spec) (s : s a m) : Tot (Core.state_p a m) =
match s with _, p -> p
(* But the working vector is not reflected in the state at all -- it doesn't
have meaningful specification contents. *)
inline_for_extraction noextract
let state_v (#a : alg) (#m : m_spec) (h : HS.mem) (s : s a m) : GTot (Spec.state a) =
Core.state_v h (get_state_p s)
inline_for_extraction noextract
let s_v (#a : alg) (#m : m_spec) (h : HS.mem) (s : s a m) : GTot (t a) =
state_v h s
/// Small helper which facilitates inferencing implicit arguments for buffer
/// operations
inline_for_extraction noextract
let state_to_lbuffer (#a : alg) (#m : m_spec) (s : Core.state_p a m) :
B.lbuffer (Core.element_t a m) (4 * U32.v (Core.row_len a m)) =
s
inline_for_extraction noextract
let stateful_blake2 (a : alg) (m : m_spec) : I.stateful unit =
I.Stateful
(fun () -> s a m) (* s *)
(* footprint *)
(fun #_ _ acc ->
let wv, b = acc in
B.loc_union
(B.loc_addr_of_buffer (state_to_lbuffer wv))
(B.loc_addr_of_buffer (state_to_lbuffer b)))
(* freeable *)
(fun #_ _ acc ->
let wv, b = acc in
B.freeable (state_to_lbuffer wv) /\
B.freeable (state_to_lbuffer b))
(* invariant *)
(fun #_ h acc ->
let wv, b = acc in
B.live h (state_to_lbuffer wv) /\
B.live h (state_to_lbuffer b) /\
B.disjoint (state_to_lbuffer wv) (state_to_lbuffer b))
(fun () -> t a) (* t *)
(fun () h acc -> s_v h acc) (* v *)
(fun #_ h acc -> let wv, b = acc in ()) (* invariant_loc_in_footprint *)
(fun #_ l acc h0 h1 -> let wv, b = acc in ()) (* frame_invariant *)
(fun #_ _ _ _ _ -> ()) (* frame_freeable *)
(* alloca *)
(fun () ->
let wv = Core.alloc_state a m in
let b = Core.alloc_state a m in
wv, b)
(* create_in *)
(fun () r ->
let wv = B.malloc r (Core.zero_element a m) U32.(4ul *^ Core.row_len a m) in
let b = B.malloc r (Core.zero_element a m) U32.(4ul *^ Core.row_len a m) in
wv, b)
(* free *)
(fun _ acc ->
match acc with wv, b ->
B.free (state_to_lbuffer wv);
B.free (state_to_lbuffer b))
(* copy *)
(fun _ src dst ->
match src with src_wv, src_b ->
match dst with src_wv, dst_b ->
B.blit (state_to_lbuffer src_b) 0ul (state_to_lbuffer dst_b) 0ul
U32.(4ul *^ Core.row_len a m))
/// Stateful key
/// ============
inline_for_extraction noextract
let key_size (a : alg) = kk:nat{kk <= Spec.max_key a}
inline_for_extraction noextract
let key_size_t (a : alg) =
key_size:U32.t{U32.v key_size <= Spec.max_key a}
/// Defining stateful keys
inline_for_extraction noextract
let stateful_key_t (a : alg) (key_size : key_size a) : Type =
if key_size = 0 then unit else b:B.buffer uint8 { B.length b == key_size}
inline_for_extraction noextract
let buffer_to_stateful_key_t (a : alg) (kk : key_size a{kk > 0})
(k : B.buffer uint8 { B.length k == kk }) :
Tot (stateful_key_t a kk) =
k
inline_for_extraction noextract
let unit_to_stateful_key_t (a : alg) :
Tot (stateful_key_t a 0) =
()
/// The ``has_key`` parameter is meta
/// TODO: this definition could be moved to Hacl.Streaming.Interface, it could
/// be pretty useful in other situations as it generalizes ``stateful_buffer`` in
/// the case the length is zero. Note that rather than being unit, the type could
/// be buffer too (and we would use null whenever needed).
inline_for_extraction noextract
let stateful_key (a : alg) (kk : key_size a) :
I.stateful unit =
I.Stateful
(fun _ -> stateful_key_t a kk)
(* footprint *)
(fun #_ h s -> if kk = 0 then B.loc_none else B.loc_addr_of_buffer (s <: B.buffer uint8))
(* freeable *)
(fun #_ h s -> if kk = 0 then True else B.freeable (s <: B.buffer uint8))
(* invariant *)
(fun #_ h s ->
if kk = 0 then True
else B.live h (s <: B.buffer uint8))
(fun _ -> s:S.seq uint8 { S.length s == kk })
(fun _ h s -> if kk = 0 then Seq.empty else B.as_seq h (s <: B.buffer uint8))
(fun #_ h s -> ()) (* invariant_loc_in_footprint *)
(fun #_ l s h0 h1 -> ()) (* frame_invariant *)
(fun #_ l s h0 h1 -> ()) (* frame_freeable *)
(* alloca *)
(fun () ->
if kk > 0 then
buffer_to_stateful_key_t a kk (B.alloca (Lib.IntTypes.u8 0) (U32.uint_to_t kk))
else unit_to_stateful_key_t a)
(* create_in *)
(fun () r ->
if kk > 0 then
buffer_to_stateful_key_t a kk (B.malloc r (Lib.IntTypes.u8 0) (U32.uint_to_t kk))
else unit_to_stateful_key_t a)
(* free *)
(fun _ s -> if kk > 0 then B.free (s <: B.buffer uint8) else ())
(* copy *)
(fun _ s_src s_dst ->
if kk > 0 then
B.blit (s_src <: B.buffer uint8) 0ul
(s_dst <: B.buffer uint8) 0ul (U32.uint_to_t kk)
else ())
inline_for_extraction noextract
let stateful_key_to_buffer (#a : alg) (#kk : key_size a)
(key : stateful_key_t a kk) :
b:B.buffer uint8 { B.length b = kk } =
if kk = 0 then B.null #uint8 else key
inline_for_extraction noextract
let k = stateful_key
/// Actual functor instantiation
/// ============================
/// Small helpers
/// -------------
noextract
let max_input_length (a : alg) : n:nat { n <= Spec.max_limb a /\ n > Spec.size_block a } =
assert_norm (pow2 64 < pow2 128);
pow2 64 - 1
noextract inline_for_extraction
let max_input_len (a: alg): (x:U64.t { U64.v x == max_input_length a }) = 0xffffffffffffffffUL | false | false | Hacl.Streaming.Blake2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val block : a: Hacl.Streaming.Blake2.alg -> Type0 | [] | Hacl.Streaming.Blake2.block | {
"file_name": "code/streaming/Hacl.Streaming.Blake2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Hacl.Streaming.Blake2.alg -> Type0 | {
"end_col": 81,
"end_line": 236,
"start_col": 22,
"start_line": 236
} |
|
Prims.Tot | val buffer_to_stateful_key_t
(a: alg)
(kk: key_size a {kk > 0})
(k: B.buffer uint8 {B.length k == kk})
: Tot (stateful_key_t a kk) | [
{
"abbrev": true,
"full_module": "Hacl.Blake2b_32",
"short_module": "Blake2b32"
},
{
"abbrev": true,
"full_module": "Hacl.Blake2s_32",
"short_module": "Blake2s32"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2.Generic",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Blake2.Core",
"short_module": "Core"
},
{
"abbrev": true,
"full_module": "Spec.Blake2",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Interface",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Functor",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let buffer_to_stateful_key_t (a : alg) (kk : key_size a{kk > 0})
(k : B.buffer uint8 { B.length k == kk }) :
Tot (stateful_key_t a kk) =
k | val buffer_to_stateful_key_t
(a: alg)
(kk: key_size a {kk > 0})
(k: B.buffer uint8 {B.length k == kk})
: Tot (stateful_key_t a kk)
let buffer_to_stateful_key_t
(a: alg)
(kk: key_size a {kk > 0})
(k: B.buffer uint8 {B.length k == kk})
: Tot (stateful_key_t a kk) = | false | null | false | k | {
"checked_file": "Hacl.Streaming.Blake2.fst.checked",
"dependencies": [
"Spec.Blake2.Alternative.fsti.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Interface.fsti.checked",
"Hacl.Streaming.Functor.fsti.checked",
"Hacl.Impl.Blake2.Generic.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Blake2s_32.fst.checked",
"Hacl.Blake2b_32.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt128.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Streaming.Blake2.fst"
} | [
"total"
] | [
"Hacl.Streaming.Blake2.alg",
"Hacl.Streaming.Blake2.key_size",
"Prims.b2t",
"Prims.op_GreaterThan",
"LowStar.Buffer.buffer",
"Hacl.Streaming.Blake2.uint8",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"Hacl.Streaming.Blake2.stateful_key_t"
] | [] | module Hacl.Streaming.Blake2
module HS = FStar.HyperStack
module B = LowStar.Buffer
module G = FStar.Ghost
module S = FStar.Seq
module LS = Lib.Sequence
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module U128 = FStar.UInt128
module F = Hacl.Streaming.Functor
module I = Hacl.Streaming.Interface
module ST = FStar.HyperStack.ST
open FStar.Mul
module Loops = Lib.LoopCombinators
/// Opening a bunch of modules for Blake2
/// =====================================
inline_for_extraction noextract
let uint8 = Lib.IntTypes.uint8
inline_for_extraction noextract
let uint32 = Lib.IntTypes.uint32
unfold noextract
let size_nat = Lib.IntTypes.size_nat
unfold noextract
let max_key = Spec.Blake2.max_key
unfold noextract
let lbytes = Lib.ByteSequence.lbytes
module Spec = Spec.Blake2
module Core = Hacl.Impl.Blake2.Core
open Hacl.Impl.Blake2.Generic
module Blake2s32 = Hacl.Blake2s_32
module Blake2b32 = Hacl.Blake2b_32
/// An instance of the stateful type class for blake2
/// =================================================
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50"
inline_for_extraction noextract
let index = unit
inline_for_extraction noextract
let alg = Spec.alg
inline_for_extraction noextract
let m_spec = Core.m_spec
/// The stateful state: (wv, hash)
inline_for_extraction noextract
let s (a : alg) (m : m_spec) = Core.(state_p a m & state_p a m)
inline_for_extraction noextract
let t (a : alg) = Spec.state a
(* In the internal state, we keep wv, the working vector. It's essentially
temporary scratch space that the Blake2 implementation expects to receive. (Why
is the implementation not performing its own stack allocations? Don't know!) *)
inline_for_extraction noextract
let get_wv (#a : alg) (#m : m_spec) (s : s a m) : Tot (Core.state_p a m) =
match s with wv, _ -> wv
inline_for_extraction noextract
let get_state_p (#a : alg) (#m : m_spec) (s : s a m) : Tot (Core.state_p a m) =
match s with _, p -> p
(* But the working vector is not reflected in the state at all -- it doesn't
have meaningful specification contents. *)
inline_for_extraction noextract
let state_v (#a : alg) (#m : m_spec) (h : HS.mem) (s : s a m) : GTot (Spec.state a) =
Core.state_v h (get_state_p s)
inline_for_extraction noextract
let s_v (#a : alg) (#m : m_spec) (h : HS.mem) (s : s a m) : GTot (t a) =
state_v h s
/// Small helper which facilitates inferencing implicit arguments for buffer
/// operations
inline_for_extraction noextract
let state_to_lbuffer (#a : alg) (#m : m_spec) (s : Core.state_p a m) :
B.lbuffer (Core.element_t a m) (4 * U32.v (Core.row_len a m)) =
s
inline_for_extraction noextract
let stateful_blake2 (a : alg) (m : m_spec) : I.stateful unit =
I.Stateful
(fun () -> s a m) (* s *)
(* footprint *)
(fun #_ _ acc ->
let wv, b = acc in
B.loc_union
(B.loc_addr_of_buffer (state_to_lbuffer wv))
(B.loc_addr_of_buffer (state_to_lbuffer b)))
(* freeable *)
(fun #_ _ acc ->
let wv, b = acc in
B.freeable (state_to_lbuffer wv) /\
B.freeable (state_to_lbuffer b))
(* invariant *)
(fun #_ h acc ->
let wv, b = acc in
B.live h (state_to_lbuffer wv) /\
B.live h (state_to_lbuffer b) /\
B.disjoint (state_to_lbuffer wv) (state_to_lbuffer b))
(fun () -> t a) (* t *)
(fun () h acc -> s_v h acc) (* v *)
(fun #_ h acc -> let wv, b = acc in ()) (* invariant_loc_in_footprint *)
(fun #_ l acc h0 h1 -> let wv, b = acc in ()) (* frame_invariant *)
(fun #_ _ _ _ _ -> ()) (* frame_freeable *)
(* alloca *)
(fun () ->
let wv = Core.alloc_state a m in
let b = Core.alloc_state a m in
wv, b)
(* create_in *)
(fun () r ->
let wv = B.malloc r (Core.zero_element a m) U32.(4ul *^ Core.row_len a m) in
let b = B.malloc r (Core.zero_element a m) U32.(4ul *^ Core.row_len a m) in
wv, b)
(* free *)
(fun _ acc ->
match acc with wv, b ->
B.free (state_to_lbuffer wv);
B.free (state_to_lbuffer b))
(* copy *)
(fun _ src dst ->
match src with src_wv, src_b ->
match dst with src_wv, dst_b ->
B.blit (state_to_lbuffer src_b) 0ul (state_to_lbuffer dst_b) 0ul
U32.(4ul *^ Core.row_len a m))
/// Stateful key
/// ============
inline_for_extraction noextract
let key_size (a : alg) = kk:nat{kk <= Spec.max_key a}
inline_for_extraction noextract
let key_size_t (a : alg) =
key_size:U32.t{U32.v key_size <= Spec.max_key a}
/// Defining stateful keys
inline_for_extraction noextract
let stateful_key_t (a : alg) (key_size : key_size a) : Type =
if key_size = 0 then unit else b:B.buffer uint8 { B.length b == key_size}
inline_for_extraction noextract
let buffer_to_stateful_key_t (a : alg) (kk : key_size a{kk > 0})
(k : B.buffer uint8 { B.length k == kk }) : | false | false | Hacl.Streaming.Blake2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val buffer_to_stateful_key_t
(a: alg)
(kk: key_size a {kk > 0})
(k: B.buffer uint8 {B.length k == kk})
: Tot (stateful_key_t a kk) | [] | Hacl.Streaming.Blake2.buffer_to_stateful_key_t | {
"file_name": "code/streaming/Hacl.Streaming.Blake2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Hacl.Streaming.Blake2.alg ->
kk: Hacl.Streaming.Blake2.key_size a {kk > 0} ->
k: LowStar.Buffer.buffer Hacl.Streaming.Blake2.uint8 {LowStar.Monotonic.Buffer.length k == kk}
-> Hacl.Streaming.Blake2.stateful_key_t a kk | {
"end_col": 3,
"end_line": 159,
"start_col": 2,
"start_line": 159
} |
Prims.Tot | val output_size (a: alg) : nat | [
{
"abbrev": true,
"full_module": "Hacl.Blake2b_32",
"short_module": "Blake2b32"
},
{
"abbrev": true,
"full_module": "Hacl.Blake2s_32",
"short_module": "Blake2s32"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2.Generic",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Blake2.Core",
"short_module": "Core"
},
{
"abbrev": true,
"full_module": "Spec.Blake2",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Interface",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Functor",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.UInt128",
"short_module": "U128"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Ghost",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Streaming",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let output_size (a : alg) : nat = Spec.max_output a | val output_size (a: alg) : nat
let output_size (a: alg) : nat = | false | null | false | Spec.max_output a | {
"checked_file": "Hacl.Streaming.Blake2.fst.checked",
"dependencies": [
"Spec.Blake2.Alternative.fsti.checked",
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Streaming.Interface.fsti.checked",
"Hacl.Streaming.Functor.fsti.checked",
"Hacl.Impl.Blake2.Generic.fst.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Blake2s_32.fst.checked",
"Hacl.Blake2b_32.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt128.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Streaming.Blake2.fst"
} | [
"total"
] | [
"Hacl.Streaming.Blake2.alg",
"Spec.Blake2.max_output",
"Prims.nat"
] | [] | module Hacl.Streaming.Blake2
module HS = FStar.HyperStack
module B = LowStar.Buffer
module G = FStar.Ghost
module S = FStar.Seq
module LS = Lib.Sequence
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module U128 = FStar.UInt128
module F = Hacl.Streaming.Functor
module I = Hacl.Streaming.Interface
module ST = FStar.HyperStack.ST
open FStar.Mul
module Loops = Lib.LoopCombinators
/// Opening a bunch of modules for Blake2
/// =====================================
inline_for_extraction noextract
let uint8 = Lib.IntTypes.uint8
inline_for_extraction noextract
let uint32 = Lib.IntTypes.uint32
unfold noextract
let size_nat = Lib.IntTypes.size_nat
unfold noextract
let max_key = Spec.Blake2.max_key
unfold noextract
let lbytes = Lib.ByteSequence.lbytes
module Spec = Spec.Blake2
module Core = Hacl.Impl.Blake2.Core
open Hacl.Impl.Blake2.Generic
module Blake2s32 = Hacl.Blake2s_32
module Blake2b32 = Hacl.Blake2b_32
/// An instance of the stateful type class for blake2
/// =================================================
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50"
inline_for_extraction noextract
let index = unit
inline_for_extraction noextract
let alg = Spec.alg
inline_for_extraction noextract
let m_spec = Core.m_spec
/// The stateful state: (wv, hash)
inline_for_extraction noextract
let s (a : alg) (m : m_spec) = Core.(state_p a m & state_p a m)
inline_for_extraction noextract
let t (a : alg) = Spec.state a
(* In the internal state, we keep wv, the working vector. It's essentially
temporary scratch space that the Blake2 implementation expects to receive. (Why
is the implementation not performing its own stack allocations? Don't know!) *)
inline_for_extraction noextract
let get_wv (#a : alg) (#m : m_spec) (s : s a m) : Tot (Core.state_p a m) =
match s with wv, _ -> wv
inline_for_extraction noextract
let get_state_p (#a : alg) (#m : m_spec) (s : s a m) : Tot (Core.state_p a m) =
match s with _, p -> p
(* But the working vector is not reflected in the state at all -- it doesn't
have meaningful specification contents. *)
inline_for_extraction noextract
let state_v (#a : alg) (#m : m_spec) (h : HS.mem) (s : s a m) : GTot (Spec.state a) =
Core.state_v h (get_state_p s)
inline_for_extraction noextract
let s_v (#a : alg) (#m : m_spec) (h : HS.mem) (s : s a m) : GTot (t a) =
state_v h s
/// Small helper which facilitates inferencing implicit arguments for buffer
/// operations
inline_for_extraction noextract
let state_to_lbuffer (#a : alg) (#m : m_spec) (s : Core.state_p a m) :
B.lbuffer (Core.element_t a m) (4 * U32.v (Core.row_len a m)) =
s
inline_for_extraction noextract
let stateful_blake2 (a : alg) (m : m_spec) : I.stateful unit =
I.Stateful
(fun () -> s a m) (* s *)
(* footprint *)
(fun #_ _ acc ->
let wv, b = acc in
B.loc_union
(B.loc_addr_of_buffer (state_to_lbuffer wv))
(B.loc_addr_of_buffer (state_to_lbuffer b)))
(* freeable *)
(fun #_ _ acc ->
let wv, b = acc in
B.freeable (state_to_lbuffer wv) /\
B.freeable (state_to_lbuffer b))
(* invariant *)
(fun #_ h acc ->
let wv, b = acc in
B.live h (state_to_lbuffer wv) /\
B.live h (state_to_lbuffer b) /\
B.disjoint (state_to_lbuffer wv) (state_to_lbuffer b))
(fun () -> t a) (* t *)
(fun () h acc -> s_v h acc) (* v *)
(fun #_ h acc -> let wv, b = acc in ()) (* invariant_loc_in_footprint *)
(fun #_ l acc h0 h1 -> let wv, b = acc in ()) (* frame_invariant *)
(fun #_ _ _ _ _ -> ()) (* frame_freeable *)
(* alloca *)
(fun () ->
let wv = Core.alloc_state a m in
let b = Core.alloc_state a m in
wv, b)
(* create_in *)
(fun () r ->
let wv = B.malloc r (Core.zero_element a m) U32.(4ul *^ Core.row_len a m) in
let b = B.malloc r (Core.zero_element a m) U32.(4ul *^ Core.row_len a m) in
wv, b)
(* free *)
(fun _ acc ->
match acc with wv, b ->
B.free (state_to_lbuffer wv);
B.free (state_to_lbuffer b))
(* copy *)
(fun _ src dst ->
match src with src_wv, src_b ->
match dst with src_wv, dst_b ->
B.blit (state_to_lbuffer src_b) 0ul (state_to_lbuffer dst_b) 0ul
U32.(4ul *^ Core.row_len a m))
/// Stateful key
/// ============
inline_for_extraction noextract
let key_size (a : alg) = kk:nat{kk <= Spec.max_key a}
inline_for_extraction noextract
let key_size_t (a : alg) =
key_size:U32.t{U32.v key_size <= Spec.max_key a}
/// Defining stateful keys
inline_for_extraction noextract
let stateful_key_t (a : alg) (key_size : key_size a) : Type =
if key_size = 0 then unit else b:B.buffer uint8 { B.length b == key_size}
inline_for_extraction noextract
let buffer_to_stateful_key_t (a : alg) (kk : key_size a{kk > 0})
(k : B.buffer uint8 { B.length k == kk }) :
Tot (stateful_key_t a kk) =
k
inline_for_extraction noextract
let unit_to_stateful_key_t (a : alg) :
Tot (stateful_key_t a 0) =
()
/// The ``has_key`` parameter is meta
/// TODO: this definition could be moved to Hacl.Streaming.Interface, it could
/// be pretty useful in other situations as it generalizes ``stateful_buffer`` in
/// the case the length is zero. Note that rather than being unit, the type could
/// be buffer too (and we would use null whenever needed).
inline_for_extraction noextract
let stateful_key (a : alg) (kk : key_size a) :
I.stateful unit =
I.Stateful
(fun _ -> stateful_key_t a kk)
(* footprint *)
(fun #_ h s -> if kk = 0 then B.loc_none else B.loc_addr_of_buffer (s <: B.buffer uint8))
(* freeable *)
(fun #_ h s -> if kk = 0 then True else B.freeable (s <: B.buffer uint8))
(* invariant *)
(fun #_ h s ->
if kk = 0 then True
else B.live h (s <: B.buffer uint8))
(fun _ -> s:S.seq uint8 { S.length s == kk })
(fun _ h s -> if kk = 0 then Seq.empty else B.as_seq h (s <: B.buffer uint8))
(fun #_ h s -> ()) (* invariant_loc_in_footprint *)
(fun #_ l s h0 h1 -> ()) (* frame_invariant *)
(fun #_ l s h0 h1 -> ()) (* frame_freeable *)
(* alloca *)
(fun () ->
if kk > 0 then
buffer_to_stateful_key_t a kk (B.alloca (Lib.IntTypes.u8 0) (U32.uint_to_t kk))
else unit_to_stateful_key_t a)
(* create_in *)
(fun () r ->
if kk > 0 then
buffer_to_stateful_key_t a kk (B.malloc r (Lib.IntTypes.u8 0) (U32.uint_to_t kk))
else unit_to_stateful_key_t a)
(* free *)
(fun _ s -> if kk > 0 then B.free (s <: B.buffer uint8) else ())
(* copy *)
(fun _ s_src s_dst ->
if kk > 0 then
B.blit (s_src <: B.buffer uint8) 0ul
(s_dst <: B.buffer uint8) 0ul (U32.uint_to_t kk)
else ())
inline_for_extraction noextract
let stateful_key_to_buffer (#a : alg) (#kk : key_size a)
(key : stateful_key_t a kk) :
b:B.buffer uint8 { B.length b = kk } =
if kk = 0 then B.null #uint8 else key
inline_for_extraction noextract
let k = stateful_key
/// Actual functor instantiation
/// ============================
/// Small helpers
/// -------------
noextract
let max_input_length (a : alg) : n:nat { n <= Spec.max_limb a /\ n > Spec.size_block a } =
assert_norm (pow2 64 < pow2 128);
pow2 64 - 1
noextract inline_for_extraction
let max_input_len (a: alg): (x:U64.t { U64.v x == max_input_length a }) = 0xffffffffffffffffUL
inline_for_extraction noextract
let block (a : alg) = (block: S.seq uint8 { S.length block = Spec.size_block a })
inline_for_extraction noextract
let block_len (a : alg) : U32.t = Core.size_block a | false | false | Hacl.Streaming.Blake2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val output_size (a: alg) : nat | [] | Hacl.Streaming.Blake2.output_size | {
"file_name": "code/streaming/Hacl.Streaming.Blake2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Hacl.Streaming.Blake2.alg -> Prims.nat | {
"end_col": 51,
"end_line": 242,
"start_col": 34,
"start_line": 242
} |
Subsets and Splits