file_name
stringlengths 5
52
| name
stringlengths 4
95
| original_source_type
stringlengths 0
23k
| source_type
stringlengths 9
23k
| source_definition
stringlengths 9
57.9k
| source
dict | source_range
dict | file_context
stringlengths 0
721k
| dependencies
dict | opens_and_abbrevs
listlengths 2
94
| vconfig
dict | interleaved
bool 1
class | verbose_type
stringlengths 1
7.42k
| effect
stringclasses 118
values | effect_flags
sequencelengths 0
2
| mutual_with
sequencelengths 0
11
| ideal_premises
sequencelengths 0
236
| proof_features
sequencelengths 0
1
| is_simple_lemma
bool 2
classes | is_div
bool 2
classes | is_proof
bool 2
classes | is_simply_typed
bool 2
classes | is_type
bool 2
classes | partial_definition
stringlengths 5
3.99k
| completed_definiton
stringlengths 1
1.63M
| isa_cross_project_example
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Hacl.Impl.K256.Qinv.fst | Hacl.Impl.K256.Qinv.mul_mod | val mul_mod : BE.lmul_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid | val mul_mod : BE.lmul_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid | let mul_mod ctx x y xy = qmul xy x y | {
"file_name": "code/k256/Hacl.Impl.K256.Qinv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 36,
"end_line": 52,
"start_col": 0,
"start_line": 52
} | module Hacl.Impl.K256.Qinv
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.K256.Scalar
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Spec.K256
module SI = Hacl.Spec.K256.Qinv
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module SD = Hacl.Spec.Bignum.Definitions
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
unfold
let linv_ctx (a:LSeq.lseq uint64 0) : Type0 = True
unfold
let linv (a:LSeq.lseq uint64 4) : Type0 =
SD.bn_v #U64 #4 a < S.q
unfold
let refl (a:LSeq.lseq uint64 4{linv a}) : GTot S.qelem =
SD.bn_v #U64 #4 a
inline_for_extraction noextract
let mk_to_k256_scalar_comm_monoid : BE.to_comm_monoid U64 4ul 0ul = {
BE.a_spec = S.qelem;
BE.comm_monoid = SI.nat_mod_comm_monoid;
BE.linv_ctx = linv_ctx;
BE.linv = linv;
BE.refl = refl;
}
inline_for_extraction noextract
val one_mod : BE.lone_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let one_mod ctx one = make_u64_4 one (u64 1, u64 0, u64 0, u64 0)
inline_for_extraction noextract | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.K256.Qinv.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.K256.Scalar.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.K256.Qinv.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "SD"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Qinv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.K256.Scalar",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Hacl.Impl.Exponentiation.Definitions.lmul_st Lib.IntTypes.U64
4ul
0ul
Hacl.Impl.K256.Qinv.mk_to_k256_scalar_comm_monoid | Prims.Tot | [
"total"
] | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.__uint_to_t",
"Hacl.K256.Scalar.qmul",
"Prims.unit"
] | [] | false | false | false | false | false | let mul_mod ctx x y xy =
| qmul xy x y | false |
Hacl.Impl.K256.Qinv.fst | Hacl.Impl.K256.Qinv.sqr_mod | val sqr_mod : BE.lsqr_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid | val sqr_mod : BE.lsqr_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid | let sqr_mod ctx x xx = qsqr xx x | {
"file_name": "code/k256/Hacl.Impl.K256.Qinv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 32,
"end_line": 57,
"start_col": 0,
"start_line": 57
} | module Hacl.Impl.K256.Qinv
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.K256.Scalar
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Spec.K256
module SI = Hacl.Spec.K256.Qinv
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module SD = Hacl.Spec.Bignum.Definitions
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
unfold
let linv_ctx (a:LSeq.lseq uint64 0) : Type0 = True
unfold
let linv (a:LSeq.lseq uint64 4) : Type0 =
SD.bn_v #U64 #4 a < S.q
unfold
let refl (a:LSeq.lseq uint64 4{linv a}) : GTot S.qelem =
SD.bn_v #U64 #4 a
inline_for_extraction noextract
let mk_to_k256_scalar_comm_monoid : BE.to_comm_monoid U64 4ul 0ul = {
BE.a_spec = S.qelem;
BE.comm_monoid = SI.nat_mod_comm_monoid;
BE.linv_ctx = linv_ctx;
BE.linv = linv;
BE.refl = refl;
}
inline_for_extraction noextract
val one_mod : BE.lone_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let one_mod ctx one = make_u64_4 one (u64 1, u64 0, u64 0, u64 0)
inline_for_extraction noextract
val mul_mod : BE.lmul_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let mul_mod ctx x y xy = qmul xy x y
inline_for_extraction noextract | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.K256.Qinv.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.K256.Scalar.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.K256.Qinv.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "SD"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Qinv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.K256.Scalar",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Hacl.Impl.Exponentiation.Definitions.lsqr_st Lib.IntTypes.U64
4ul
0ul
Hacl.Impl.K256.Qinv.mk_to_k256_scalar_comm_monoid | Prims.Tot | [
"total"
] | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.__uint_to_t",
"Hacl.K256.Scalar.qsqr",
"Prims.unit"
] | [] | false | false | false | false | false | let sqr_mod ctx x xx =
| qsqr xx x | false |
Hacl.Impl.K256.Qinv.fst | Hacl.Impl.K256.Qinv.linv | val linv (a: LSeq.lseq uint64 4) : Type0 | val linv (a: LSeq.lseq uint64 4) : Type0 | let linv (a:LSeq.lseq uint64 4) : Type0 =
SD.bn_v #U64 #4 a < S.q | {
"file_name": "code/k256/Hacl.Impl.K256.Qinv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 25,
"end_line": 29,
"start_col": 0,
"start_line": 28
} | module Hacl.Impl.K256.Qinv
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.K256.Scalar
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Spec.K256
module SI = Hacl.Spec.K256.Qinv
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module SD = Hacl.Spec.Bignum.Definitions
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
unfold
let linv_ctx (a:LSeq.lseq uint64 0) : Type0 = True | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.K256.Qinv.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.K256.Scalar.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.K256.Qinv.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "SD"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Qinv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.K256.Scalar",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Lib.Sequence.lseq Lib.IntTypes.uint64 4 -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Lib.IntTypes.U64",
"Spec.K256.PointOps.q"
] | [] | false | false | false | false | true | let linv (a: LSeq.lseq uint64 4) : Type0 =
| SD.bn_v #U64 #4 a < S.q | false |
Hacl.Impl.K256.Qinv.fst | Hacl.Impl.K256.Qinv.refl | val refl (a: LSeq.lseq uint64 4 {linv a}) : GTot S.qelem | val refl (a: LSeq.lseq uint64 4 {linv a}) : GTot S.qelem | let refl (a:LSeq.lseq uint64 4{linv a}) : GTot S.qelem =
SD.bn_v #U64 #4 a | {
"file_name": "code/k256/Hacl.Impl.K256.Qinv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 19,
"end_line": 33,
"start_col": 0,
"start_line": 32
} | module Hacl.Impl.K256.Qinv
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.K256.Scalar
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Spec.K256
module SI = Hacl.Spec.K256.Qinv
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module SD = Hacl.Spec.Bignum.Definitions
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
unfold
let linv_ctx (a:LSeq.lseq uint64 0) : Type0 = True
unfold
let linv (a:LSeq.lseq uint64 4) : Type0 =
SD.bn_v #U64 #4 a < S.q | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.K256.Qinv.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.K256.Scalar.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.K256.Qinv.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "SD"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Qinv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.K256.Scalar",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Lib.Sequence.lseq Lib.IntTypes.uint64 4 {Hacl.Impl.K256.Qinv.linv a}
-> Prims.GTot Spec.K256.PointOps.qelem | Prims.GTot | [
"sometrivial"
] | [] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Hacl.Impl.K256.Qinv.linv",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Lib.IntTypes.U64",
"Spec.K256.PointOps.qelem"
] | [] | false | false | false | false | false | let refl (a: LSeq.lseq uint64 4 {linv a}) : GTot S.qelem =
| SD.bn_v #U64 #4 a | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.bn_get_top_index_t | val bn_get_top_index_t : len: Lib.IntTypes.size_nat -> i: Prims.nat{i <= len} -> Type0 | let bn_get_top_index_t (len:size_nat) (i:nat{i <= len}) = x:nat{x < len} | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 72,
"end_line": 312,
"start_col": 0,
"start_line": 312
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2)
let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2)
val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t
let bn_get_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[i] j
val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j))
let bn_get_ith_bit_aux_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = b.[i] >>. size j in
calc (==) {
v b.[i] / pow2 j;
(==) { bn_eval_index b i }
(bn_v b / pow2 (pbits * i) % pow2 pbits) / pow2 j;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b / pow2 (pbits * i)) j pbits }
(bn_v b / pow2 (pbits * i) / pow2 j) % pow2 (pbits - j);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b) (pow2 (pbits * i)) (pow2 j) }
(bn_v b / (pow2 (pbits * i) * pow2 j)) % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_plus (pbits * i) j }
(bn_v b / pow2 (pbits * i + j)) % pow2 (pbits - j);
(==) { Math.Lemmas.euclidean_div_axiom ind pbits }
(bn_v b / pow2 ind) % pow2 (pbits - j);
};
assert (v res == (bn_v b / pow2 ind) % pow2 (pbits - j))
val bn_get_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} ->
Lemma (v (bn_get_ith_bit b i) == (bn_v b / pow2 i % 2))
let bn_get_ith_bit_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = limb_get_ith_bit b.[i] j in
limb_get_ith_bit_lemma b.[i] j;
calc (==) {
v b.[i] / pow2 j % 2;
(==) { bn_get_ith_bit_aux_lemma b ind }
(bn_v b / pow2 ind) % pow2 (pbits - j) % 2;
(==) { assert_norm (pow2 1 = 2);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 ind) 1 (pbits - j) }
(bn_v b / pow2 ind) % 2;
};
assert (v res == bn_v b / pow2 ind % 2)
val bn_set_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> lbignum t len
let bn_set_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
let inp = input.[i] <- input.[i] |. (uint #t 1 <<. size j) in
inp
val bn_set_ith_bit_lemma_aux: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a + b * pow2 c < pow2 (c + d) /\ a < pow2 c)
(ensures b < pow2 d)
let bn_set_ith_bit_lemma_aux a b c d =
Math.Lemmas.lemma_div_lt_nat (a + b * pow2 c) (c + d) c;
assert ((a + b * pow2 c) / pow2 c < pow2 d);
Math.Lemmas.lemma_div_plus a b (pow2 c);
assert (a / pow2 c + b < pow2 d);
Math.Lemmas.small_division_lemma_1 a (pow2 c)
val bn_lt_pow2_index_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} -> Lemma
(requires bn_v b < pow2 ind)
(ensures (let i = ind / bits t in v b.[i] < pow2 (ind % bits t) /\
bn_v b == bn_v (slice b 0 i) + pow2 (i * bits t) * v b.[i] /\
bn_v (slice b (i + 1) len) = 0))
let bn_lt_pow2_index_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
Math.Lemmas.euclidean_division_definition ind (pbits);
assert (bn_v b < pow2 (i * pbits + j));
Math.Lemmas.pow2_lt_compat (i * pbits + pbits) (i * pbits + j);
assert (bn_v b < pow2 (i * pbits + pbits));
bn_eval_split_i #t #len b (i + 1);
bn_eval_bound (slice b 0 (i + 1)) (i + 1);
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 (i + 1))) (bn_v (slice b (i + 1) len)) (pbits * (i + 1)) 0;
assert (bn_v b == bn_v (slice b 0 (i + 1)));
bn_eval_split_i #t #(i + 1) (slice b 0 (i + 1)) i;
bn_eval1 (slice b i (i + 1));
assert (bn_v b == bn_v (slice b 0 i) + pow2 (i * pbits) * v b.[i]);
bn_eval_bound #t #i (slice b 0 i) i;
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 i)) (v b.[i]) (i * pbits) j;
assert (v b.[i] < pow2 j)
val bn_set_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> Lemma
(requires bn_v b < pow2 i)
(ensures bn_v (bn_set_ith_bit b i) == bn_v b + pow2 i)
let bn_set_ith_bit_lemma #t #len input ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
bn_lt_pow2_index_lemma #t #len input ind;
assert (v input.[i] < pow2 j);
let b = uint #t 1 <<. size j in
let inp = input.[i] <- input.[i] |. b in
FStar.Math.Lemmas.pow2_lt_compat pbits j;
FStar.Math.Lemmas.modulo_lemma (pow2 j) (pow2 pbits);
assert (v b == pow2 j);
logor_disjoint (input.[i]) b j;
assert (v inp.[i] == v input.[i] + v b);
calc (==) {
bn_v inp;
(==) { bn_eval_split_i #t #len inp (i + 1);
bn_eval_extensionality_j (slice inp (i + 1) len) (slice input (i + 1) len) (len - i - 1) }
bn_v (slice inp 0 (i + 1));
(==) { bn_eval_split_i #t #(i + 1) (slice inp 0 (i + 1)) i }
bn_v (slice inp 0 i) + pow2 (i * pbits) * bn_v (slice inp i (i + 1));
(==) { bn_eval1 (slice inp i (i + 1)) }
bn_v (slice inp 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { bn_eval_extensionality_j input inp i }
bn_v (slice input 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { }
bn_v (slice input 0 i) + pow2 (i * pbits) * (v input.[i] + v b);
(==) { Math.Lemmas.distributivity_add_right (pow2 (i * pbits)) (v input.[i]) (v b) }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 (i * pbits) * v b;
(==) { Math.Lemmas.pow2_plus (i * pbits) j; Math.Lemmas.euclidean_division_definition ind pbits }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 ind;
(==) { }
bn_v input + pow2 ind;
}
///
/// % pow2 and / pow2
///
val bn_div_pow2: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i <= len} -> lbignum t (len - i)
let bn_div_pow2 #t #len b i =
slice b i len
val bn_div_pow2_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i < len} ->
Lemma (bn_v (bn_div_pow2 b i) == bn_v b / pow2 (bits t * i))
let bn_div_pow2_lemma #t #len c i =
let pbits = bits t in
calc (==) {
bn_v c / pow2 (pbits * i);
(==) { bn_eval_split_i c i }
(bn_v (slice c 0 i) + pow2 (pbits * i) * bn_v (slice c i len)) / pow2 (pbits * i);
(==) { Math.Lemmas.division_addition_lemma (bn_v (slice c 0 i)) (pow2 (pbits * i)) (bn_v (slice c i len)) }
bn_v (slice c 0 i) / pow2 (pbits * i) + bn_v (slice c i len);
(==) { bn_eval_bound (slice c 0 i) i; Math.Lemmas.small_division_lemma_1 (bn_v (slice c 0 i)) (pow2 (pbits * i)) }
bn_v (slice c i len);
};
assert (bn_v (slice c i len) == bn_v c / pow2 (pbits * i))
val bn_mod_pow2: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} -> lbignum t i
let bn_mod_pow2 #t #aLen a i = sub a 0 i
val bn_mod_pow2_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} ->
Lemma (bn_v (bn_mod_pow2 a i) == bn_v a % pow2 (bits t * i))
let bn_mod_pow2_lemma #t #aLen a i =
let pbits = bits t in
calc (==) {
bn_v a % pow2 (pbits * i);
(==) { bn_eval_split_i a i }
(bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v (slice a i aLen)) % pow2 (pbits * i);
(==) { Math.Lemmas.modulo_addition_lemma (bn_v (slice a 0 i)) (pow2 (pbits * i)) (bn_v (slice a i aLen)) }
(bn_v (slice a 0 i)) % pow2 (pbits * i);
(==) { bn_eval_bound (slice a 0 i) i; Math.Lemmas.small_mod (bn_v (slice a 0 i)) (pow2 (pbits * i)) }
bn_v (slice a 0 i);
}
///
/// Conditional swap
///
//the same as in curve25519
val lemma_cswap2_step:
#t:limb_t
-> bit:limb t{v bit <= 1}
-> p1:limb t
-> p2:limb t ->
Lemma
(let mask = uint #t 0 -. bit in
let dummy = mask &. (p1 ^. p2) in
let p1' = p1 ^. dummy in
let p2' = p2 ^. dummy in
if v bit = 1 then p1' == p2 /\ p2' == p1 else p1' == p1 /\ p2' == p2)
let lemma_cswap2_step #t bit p1 p2 =
let mask = uint #t 0 -. bit in
assert (v bit == 0 ==> v mask == 0);
assert (v bit == 1 ==> v mask == pow2 (bits t) - 1);
let dummy = mask &. (p1 ^. p2) in
logand_lemma mask (p1 ^. p2);
assert (v bit == 1 ==> v dummy == v (p1 ^. p2));
assert (v bit == 0 ==> v dummy == 0);
let p1' = p1 ^. dummy in
assert (v dummy == v (if v bit = 1 then (p1 ^. p2) else uint #t 0));
logxor_lemma p1 p2;
let p2' = p2 ^. dummy in
logxor_lemma p2 p1
val cswap2_f:
#t:limb_t
-> #len:size_nat
-> mask:limb t
-> i:nat{i < len}
-> tuple2 (lbignum t len) (lbignum t len) ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2_f #t #len mask i (p1, p2) =
let dummy = mask &. (p1.[i] ^. p2.[i]) in
let p1 = p1.[i] <- p1.[i] ^. dummy in
let p2 = p2.[i] <- p2.[i] ^. dummy in
(p1, p2)
val cswap2:
#t:limb_t
-> #len:size_nat
-> bit:limb t
-> b1:lbignum t len
-> b2:lbignum t len ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2 #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.repeati len (cswap2_f #t #len mask) (b1, b2)
val cswap2_lemma:
#t:limb_t
-> #len:size_nat
-> bit:limb t{v bit <= 1}
-> b1:lbignum t len
-> b2:lbignum t len ->
Lemma (let (p1, p2) = cswap2 bit b1 b2 in
(if v bit = 1 then p1 == b2 /\ p2 == b1 else p1 == b1 /\ p2 == b2))
let cswap2_lemma #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.eq_repeati0 len (cswap2_f #t #len mask) (b1, b2);
let (p1, p2) =
Loops.repeati_inductive #(tuple2 (lbignum t len) (lbignum t len)) len
(fun i (p1, p2) ->
(p1, p2) == Loops.repeati i (cswap2_f #t #len mask) (b1, b2) /\
(forall (k:nat{k < i}).
(if v bit = 1 then p1.[k] == b2.[k] /\ p2.[k] == b1.[k] else p1.[k] == b1.[k] /\ p2.[k] == b2.[k])) /\
(forall (k:nat{i <= k /\ k < len}). p1.[k] == b1.[k] /\ p2.[k] == b2.[k]))
(fun i (p1, p2) ->
Loops.unfold_repeati (i + 1) (cswap2_f #t #len mask) (b1, b2) i;
lemma_cswap2_step bit p1.[i] p2.[i];
cswap2_f #t #len mask i (p1, p2)) (b1, b2) in
assert (if v bit = 1 then (eq_intro p1 b2; p1 == b2) else (eq_intro p1 b1; p1 == b1));
assert (if v bit = 1 then (eq_intro p2 b1; p2 == b1) else (eq_intro p2 b2; p2 == b2));
//eq_intro p1 (if v bit = 1 then b2 else b1);
//eq_intro p2 (if v bit = 1 then b1 else b2);
() | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | len: Lib.IntTypes.size_nat -> i: Prims.nat{i <= len} -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Lib.IntTypes.size_nat",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan"
] | [] | false | false | false | false | true | let bn_get_top_index_t (len: size_nat) (i: nat{i <= len}) =
| x: nat{x < len} | false |
|
Hacl.Impl.K256.Qinv.fst | Hacl.Impl.K256.Qinv.qsquare_times | val qsquare_times (out a:qelem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ live h a /\ disjoint out a /\
qe_lt_q h a)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\ qe_lt_q h1 a /\
qas_nat h1 out == SI.qsquare_times (qas_nat h0 a) (v b)) | val qsquare_times (out a:qelem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ live h a /\ disjoint out a /\
qe_lt_q h a)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\ qe_lt_q h1 a /\
qas_nat h1 out == SI.qsquare_times (qas_nat h0 a) (v b)) | let qsquare_times out a b =
let h0 = ST.get () in
SE.exp_pow2_lemma SI.mk_nat_mod_concrete_ops (qas_nat h0 a) (v b);
BE.lexp_pow2 4ul 0ul mk_k256_scalar_concrete_ops (null uint64) a b out | {
"file_name": "code/k256/Hacl.Impl.K256.Qinv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 72,
"end_line": 93,
"start_col": 0,
"start_line": 90
} | module Hacl.Impl.K256.Qinv
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.K256.Scalar
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Spec.K256
module SI = Hacl.Spec.K256.Qinv
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module SD = Hacl.Spec.Bignum.Definitions
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
unfold
let linv_ctx (a:LSeq.lseq uint64 0) : Type0 = True
unfold
let linv (a:LSeq.lseq uint64 4) : Type0 =
SD.bn_v #U64 #4 a < S.q
unfold
let refl (a:LSeq.lseq uint64 4{linv a}) : GTot S.qelem =
SD.bn_v #U64 #4 a
inline_for_extraction noextract
let mk_to_k256_scalar_comm_monoid : BE.to_comm_monoid U64 4ul 0ul = {
BE.a_spec = S.qelem;
BE.comm_monoid = SI.nat_mod_comm_monoid;
BE.linv_ctx = linv_ctx;
BE.linv = linv;
BE.refl = refl;
}
inline_for_extraction noextract
val one_mod : BE.lone_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let one_mod ctx one = make_u64_4 one (u64 1, u64 0, u64 0, u64 0)
inline_for_extraction noextract
val mul_mod : BE.lmul_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let mul_mod ctx x y xy = qmul xy x y
inline_for_extraction noextract
val sqr_mod : BE.lsqr_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let sqr_mod ctx x xx = qsqr xx x
inline_for_extraction noextract
let mk_k256_scalar_concrete_ops : BE.concrete_ops U64 4ul 0ul = {
BE.to = mk_to_k256_scalar_comm_monoid;
BE.lone = one_mod;
BE.lmul = mul_mod;
BE.lsqr = sqr_mod;
}
val qsquare_times_in_place (out:qelem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ qe_lt_q h out)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\ qe_lt_q h1 out /\
qas_nat h1 out == SI.qsquare_times (qas_nat h0 out) (v b))
[@CInline]
let qsquare_times_in_place out b =
let h0 = ST.get () in
SE.exp_pow2_lemma SI.mk_nat_mod_concrete_ops (qas_nat h0 out) (v b);
BE.lexp_pow2_in_place 4ul 0ul mk_k256_scalar_concrete_ops (null uint64) out b
val qsquare_times (out a:qelem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ live h a /\ disjoint out a /\
qe_lt_q h a)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\ qe_lt_q h1 a /\
qas_nat h1 out == SI.qsquare_times (qas_nat h0 a) (v b)) | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.K256.Qinv.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.K256.Scalar.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.K256.Qinv.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "SD"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Qinv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.K256.Scalar",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | out: Hacl.K256.Scalar.qelem -> a: Hacl.K256.Scalar.qelem -> b: Lib.IntTypes.size_t
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.K256.Scalar.qelem",
"Lib.IntTypes.size_t",
"Hacl.Impl.Exponentiation.lexp_pow2",
"Lib.IntTypes.U64",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.K256.Qinv.mk_k256_scalar_concrete_ops",
"Lib.Buffer.null",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"Prims.unit",
"Spec.Exponentiation.exp_pow2_lemma",
"Spec.K256.PointOps.qelem",
"Hacl.Spec.K256.Qinv.mk_nat_mod_concrete_ops",
"Hacl.K256.Scalar.qas_nat",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get"
] | [] | false | true | false | false | false | let qsquare_times out a b =
| let h0 = ST.get () in
SE.exp_pow2_lemma SI.mk_nat_mod_concrete_ops (qas_nat h0 a) (v b);
BE.lexp_pow2 4ul 0ul mk_k256_scalar_concrete_ops (null uint64) a b out | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.limb_get_ith_bit | val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t | val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t | let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1 | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 57,
"end_line": 22,
"start_col": 0,
"start_line": 22
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
/// | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Hacl.Spec.Bignum.Definitions.limb t -> i: Prims.nat{i < Lib.IntTypes.bits t}
-> Hacl.Spec.Bignum.Definitions.limb t | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.bits",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.SEC",
"Lib.IntTypes.op_Greater_Greater_Dot",
"Lib.IntTypes.size",
"Lib.IntTypes.uint"
] | [] | false | false | false | false | false | let limb_get_ith_bit #t a i =
| (a >>. size i) &. uint #t 1 | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.bn_get_ith_bit | val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t | val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t | let bn_get_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[i] j | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 30,
"end_line": 38,
"start_col": 0,
"start_line": 35
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2)
let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: Hacl.Spec.Bignum.Definitions.lbignum t len ->
i: Lib.IntTypes.size_nat{i / Lib.IntTypes.bits t < len}
-> Hacl.Spec.Bignum.Definitions.limb t | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Division",
"Lib.IntTypes.bits",
"Hacl.Spec.Bignum.Lib.limb_get_ith_bit",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.int",
"Prims.op_Modulus"
] | [] | false | false | false | false | false | let bn_get_ith_bit #t #len input ind =
| let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[ i ] j | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.limb_get_ith_bit_lemma | val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2) | val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2) | let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 37,
"end_line": 32,
"start_col": 0,
"start_line": 27
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Hacl.Spec.Bignum.Definitions.limb t -> i: Prims.nat{i < Lib.IntTypes.bits t}
-> FStar.Pervasives.Lemma
(ensures
Lib.IntTypes.v (Hacl.Spec.Bignum.Lib.limb_get_ith_bit a i) ==
Lib.IntTypes.v a / Prims.pow2 i % 2) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.bits",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims.op_Modulus",
"Prims.op_Division",
"Prims.pow2",
"Prims.unit",
"Lib.IntTypes.range_t",
"Lib.IntTypes.mod_mask",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.uint",
"Lib.IntTypes.mod_mask_lemma",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.op_Greater_Greater_Dot",
"Lib.IntTypes.size"
] | [] | true | false | true | false | false | let limb_get_ith_bit_lemma #t a i =
| let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2) | false |
Hacl.Impl.K256.Qinv.fst | Hacl.Impl.K256.Qinv.qinv | val qinv (out f: qelem) : Stack unit
(requires fun h ->
live h out /\ live h f /\ disjoint out f /\
qe_lt_q h f)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
qas_nat h1 out == S.qinv (qas_nat h0 f) /\
qe_lt_q h1 out) | val qinv (out f: qelem) : Stack unit
(requires fun h ->
live h out /\ live h f /\ disjoint out f /\
qe_lt_q h f)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
qas_nat h1 out == S.qinv (qas_nat h0 f) /\
qe_lt_q h1 out) | let qinv out f =
let h0 = ST.get () in
SI.qinv_is_qinv_lemma (qas_nat h0 f);
qinv_ out f | {
"file_name": "code/k256/Hacl.Impl.K256.Qinv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 13,
"end_line": 505,
"start_col": 0,
"start_line": 502
} | module Hacl.Impl.K256.Qinv
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.K256.Scalar
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Spec.K256
module SI = Hacl.Spec.K256.Qinv
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module SD = Hacl.Spec.Bignum.Definitions
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
unfold
let linv_ctx (a:LSeq.lseq uint64 0) : Type0 = True
unfold
let linv (a:LSeq.lseq uint64 4) : Type0 =
SD.bn_v #U64 #4 a < S.q
unfold
let refl (a:LSeq.lseq uint64 4{linv a}) : GTot S.qelem =
SD.bn_v #U64 #4 a
inline_for_extraction noextract
let mk_to_k256_scalar_comm_monoid : BE.to_comm_monoid U64 4ul 0ul = {
BE.a_spec = S.qelem;
BE.comm_monoid = SI.nat_mod_comm_monoid;
BE.linv_ctx = linv_ctx;
BE.linv = linv;
BE.refl = refl;
}
inline_for_extraction noextract
val one_mod : BE.lone_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let one_mod ctx one = make_u64_4 one (u64 1, u64 0, u64 0, u64 0)
inline_for_extraction noextract
val mul_mod : BE.lmul_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let mul_mod ctx x y xy = qmul xy x y
inline_for_extraction noextract
val sqr_mod : BE.lsqr_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let sqr_mod ctx x xx = qsqr xx x
inline_for_extraction noextract
let mk_k256_scalar_concrete_ops : BE.concrete_ops U64 4ul 0ul = {
BE.to = mk_to_k256_scalar_comm_monoid;
BE.lone = one_mod;
BE.lmul = mul_mod;
BE.lsqr = sqr_mod;
}
val qsquare_times_in_place (out:qelem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ qe_lt_q h out)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\ qe_lt_q h1 out /\
qas_nat h1 out == SI.qsquare_times (qas_nat h0 out) (v b))
[@CInline]
let qsquare_times_in_place out b =
let h0 = ST.get () in
SE.exp_pow2_lemma SI.mk_nat_mod_concrete_ops (qas_nat h0 out) (v b);
BE.lexp_pow2_in_place 4ul 0ul mk_k256_scalar_concrete_ops (null uint64) out b
val qsquare_times (out a:qelem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ live h a /\ disjoint out a /\
qe_lt_q h a)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\ qe_lt_q h1 a /\
qas_nat h1 out == SI.qsquare_times (qas_nat h0 a) (v b))
[@CInline]
let qsquare_times out a b =
let h0 = ST.get () in
SE.exp_pow2_lemma SI.mk_nat_mod_concrete_ops (qas_nat h0 a) (v b);
BE.lexp_pow2 4ul 0ul mk_k256_scalar_concrete_ops (null uint64) a b out
inline_for_extraction noextract
val qinv1 (f x_10 x_11 x_101 x_111 x_1001 x_1011 x_1101:qelem) : Stack unit
(requires fun h ->
live h f /\ live h x_10 /\ live h x_11 /\ live h x_101 /\
live h x_111 /\ live h x_1001 /\ live h x_1011 /\ live h x_1101 /\
disjoint f x_10 /\ disjoint f x_11 /\ disjoint f x_101 /\
disjoint f x_111 /\ disjoint f x_1001 /\ disjoint f x_1011 /\
disjoint f x_1101 /\ disjoint x_10 x_11 /\ disjoint x_10 x_101 /\
disjoint x_10 x_111 /\ disjoint x_10 x_1001 /\ disjoint x_10 x_1011 /\
disjoint x_10 x_1101 /\ disjoint x_11 x_101 /\ disjoint x_11 x_111 /\
disjoint x_11 x_1001 /\ disjoint x_11 x_1011 /\ disjoint x_11 x_1101 /\
disjoint x_101 x_111 /\ disjoint x_101 x_1001 /\ disjoint x_101 x_1011 /\
disjoint x_101 x_1101 /\ disjoint x_111 x_1001 /\ disjoint x_111 x_1011 /\
disjoint x_111 x_1101 /\ disjoint x_1001 x_1011 /\ disjoint x_1001 x_1101 /\
disjoint x_1011 x_1101 /\ qe_lt_q h f)
(ensures fun h0 _ h1 ->
modifies (loc x_10 |+| loc x_11 |+| loc x_101 |+|
loc x_111 |+| loc x_1001 |+| loc x_1011 |+| loc x_1101) h0 h1 /\
(let _x_10 = SI.qsquare_times (qas_nat h0 f) 1 in
let _x_11 = S.qmul _x_10 (qas_nat h0 f) in
let _x_101 = S.qmul _x_10 _x_11 in
let _x_111 = S.qmul _x_10 _x_101 in
let _x_1001 = S.qmul _x_10 _x_111 in
let _x_1011 = S.qmul _x_10 _x_1001 in
let _x_1101 = S.qmul _x_10 _x_1011 in
qas_nat h1 x_10 == _x_10 /\ qe_lt_q h1 x_10 /\
qas_nat h1 x_11 == _x_11 /\ qe_lt_q h1 x_11 /\
qas_nat h1 x_101 == _x_101 /\ qe_lt_q h1 x_101 /\
qas_nat h1 x_111 == _x_111 /\ qe_lt_q h1 x_111 /\
qas_nat h1 x_1001 == _x_1001 /\ qe_lt_q h1 x_1001 /\
qas_nat h1 x_1011 == _x_1011 /\ qe_lt_q h1 x_1011 /\
qas_nat h1 x_1101 == _x_1101 /\ qe_lt_q h1 x_1101))
let qinv1 f x_10 x_11 x_101 x_111 x_1001 x_1011 x_1101 =
let h0 = ST.get () in
qsquare_times x_10 f 1ul;
let h1 = ST.get () in
assert (qas_nat h1 x_10 == SI.qsquare_times (qas_nat h0 f) 1);
qmul x_11 x_10 f;
let h2 = ST.get () in
assert (qas_nat h2 x_11 == S.qmul (qas_nat h1 x_10) (qas_nat h0 f));
qmul x_101 x_10 x_11;
let h3 = ST.get () in
assert (qas_nat h3 x_101 == S.qmul (qas_nat h1 x_10) (qas_nat h2 x_11));
qmul x_111 x_10 x_101;
let h4 = ST.get () in
assert (qas_nat h4 x_111 == S.qmul (qas_nat h1 x_10) (qas_nat h3 x_101));
qmul x_1001 x_10 x_111;
let h5 = ST.get () in
assert (qas_nat h5 x_1001 == S.qmul (qas_nat h1 x_10) (qas_nat h4 x_111));
qmul x_1011 x_10 x_1001;
let h6 = ST.get () in
assert (qas_nat h6 x_1011 == S.qmul (qas_nat h1 x_10) (qas_nat h5 x_1001));
qmul x_1101 x_10 x_1011;
let h7 = ST.get () in
assert (qas_nat h7 x_1101 == S.qmul (qas_nat h1 x_10) (qas_nat h6 x_1011))
inline_for_extraction noextract
val qinv2 (x_11 x_1011 x_1101 x6 x8 x14: qelem) : Stack unit
(requires fun h ->
live h x_11 /\ live h x_1011 /\ live h x_1101 /\
live h x6 /\ live h x8 /\ live h x14 /\
disjoint x_11 x6 /\ disjoint x_11 x8 /\ disjoint x_11 x14 /\
disjoint x_1011 x6 /\ disjoint x_1011 x8 /\ disjoint x_1011 x14 /\
disjoint x_1101 x6 /\ disjoint x_1101 x8 /\ disjoint x_1101 x14 /\
disjoint x6 x8 /\ disjoint x6 x14 /\ disjoint x8 x14 /\
qe_lt_q h x_11 /\ qe_lt_q h x_1011 /\ qe_lt_q h x_1101)
(ensures fun h0 _ h1 -> modifies (loc x6 |+| loc x8 |+| loc x14) h0 h1 /\
(let _x6 = S.qmul (SI.qsquare_times (qas_nat h0 x_1101) 2) (qas_nat h0 x_1011) in
let _x8 = S.qmul (SI.qsquare_times _x6 2) (qas_nat h0 x_11) in
let _x14 = S.qmul (SI.qsquare_times _x8 6) _x6 in
qas_nat h1 x6 == _x6 /\ qe_lt_q h1 x6 /\
qas_nat h1 x8 == _x8 /\ qe_lt_q h1 x8 /\
qas_nat h1 x14 == _x14 /\ qe_lt_q h1 x14))
let qinv2 x_11 x_1011 x_1101 x6 x8 x14 =
let h0 = ST.get () in
qsquare_times x6 x_1101 2ul;
qmul x6 x6 x_1011;
let h1 = ST.get () in
assert (qas_nat h1 x6 == S.qmul (SI.qsquare_times (qas_nat h0 x_1101) 2) (qas_nat h0 x_1011));
qsquare_times x8 x6 2ul;
qmul x8 x8 x_11;
let h2 = ST.get () in
assert (qas_nat h2 x8 == S.qmul (SI.qsquare_times (qas_nat h1 x6) 2) (qas_nat h0 x_11));
qsquare_times x14 x8 6ul;
qmul x14 x14 x6;
let h3 = ST.get () in
assert (qas_nat h3 x14 == S.qmul (SI.qsquare_times (qas_nat h2 x8) 6) (qas_nat h1 x6))
inline_for_extraction noextract
val qinv3 (tmp x14: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h x14 /\ disjoint tmp x14 /\
qe_lt_q h x14)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r0_r1 (qas_nat h0 x14) /\
qe_lt_q h1 tmp)
let qinv3 tmp x14 =
push_frame ();
let x56 = create_qelem () in
let h0 = ST.get () in
qsquare_times tmp x14 14ul;
qmul tmp tmp x14; //tmp = x28
let h1 = ST.get () in
assert (qas_nat h1 tmp == S.qmul (SI.qsquare_times (qas_nat h0 x14) 14) (qas_nat h0 x14));
qsquare_times x56 tmp 28ul;
qmul x56 x56 tmp;
let h2 = ST.get () in
assert (qas_nat h2 x56 == S.qmul (SI.qsquare_times (qas_nat h1 tmp) 28) (qas_nat h1 tmp));
qsquare_times tmp x56 56ul; //tmp = r0
qmul tmp tmp x56;
let h3 = ST.get () in
assert (qas_nat h3 tmp == S.qmul (SI.qsquare_times (qas_nat h2 x56) 56) (qas_nat h2 x56));
qsquare_times_in_place tmp 14ul; //tmp = r1
qmul tmp tmp x14;
let h4 = ST.get () in
assert (qas_nat h4 tmp == S.qmul (SI.qsquare_times (qas_nat h3 tmp) 14) (qas_nat h0 x14));
pop_frame ()
//r2; .. ;r8
inline_for_extraction noextract
val qinv4 (tmp x_101 x_111 x_1011: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h x_101 /\ live h x_111 /\ live h x_1011 /\
disjoint tmp x_101 /\ disjoint tmp x_111 /\ disjoint tmp x_1011 /\
qe_lt_q h tmp /\ qe_lt_q h x_101 /\ qe_lt_q h x_111 /\ qe_lt_q h x_1011)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r2_r8 (qas_nat h0 tmp)
(qas_nat h0 x_101) (qas_nat h0 x_111) (qas_nat h0 x_1011) /\
qe_lt_q h1 tmp)
let qinv4 tmp x_101 x_111 x_1011 =
let h0 = ST.get () in
qsquare_times_in_place tmp 3ul;
qmul tmp tmp x_101; //tmp = r2
let h1 = ST.get () in
assert (qas_nat h1 tmp == S.qmul (SI.qsquare_times (qas_nat h0 tmp) 3) (qas_nat h0 x_101));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_111; //tmp = r3
let h2 = ST.get () in
assert (qas_nat h2 tmp == S.qmul (SI.qsquare_times (qas_nat h1 tmp) 4) (qas_nat h0 x_111));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_101; //tmp = r4
let h3 = ST.get () in
assert (qas_nat h3 tmp == S.qmul (SI.qsquare_times (qas_nat h2 tmp) 4) (qas_nat h0 x_101));
qsquare_times_in_place tmp 5ul;
qmul tmp tmp x_1011; //tmp = r5
let h4 = ST.get () in
assert (qas_nat h4 tmp == S.qmul (SI.qsquare_times (qas_nat h3 tmp) 5) (qas_nat h0 x_1011));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_1011; //tmp = r6
let h5 = ST.get () in
assert (qas_nat h5 tmp == S.qmul (SI.qsquare_times (qas_nat h4 tmp) 4) (qas_nat h0 x_1011));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_111; //tmp = r7
let h6 = ST.get () in
assert (qas_nat h6 tmp == S.qmul (SI.qsquare_times (qas_nat h5 tmp) 4) (qas_nat h0 x_111));
qsquare_times_in_place tmp 5ul;
qmul tmp tmp x_111; //tmp = r8
let h7 = ST.get () in
assert (qas_nat h7 tmp == S.qmul (SI.qsquare_times (qas_nat h6 tmp) 5) (qas_nat h0 x_111))
// r9; ..; r15
inline_for_extraction noextract
val qinv5 (tmp x_101 x_111 x_1001 x_1101: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h x_101 /\ live h x_111 /\
live h x_1001 /\ live h x_1101 /\ disjoint tmp x_101 /\
disjoint tmp x_111 /\ disjoint tmp x_1001 /\ disjoint tmp x_1101 /\
qe_lt_q h tmp /\ qe_lt_q h x_101 /\ qe_lt_q h x_111 /\
qe_lt_q h x_1001 /\ qe_lt_q h x_1101)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r9_r15 (qas_nat h0 tmp)
(qas_nat h0 x_101) (qas_nat h0 x_111) (qas_nat h0 x_1001) (qas_nat h0 x_1101) /\
qe_lt_q h1 tmp)
let qinv5 tmp x_101 x_111 x_1001 x_1101 =
let h0 = ST.get () in
qsquare_times_in_place tmp 6ul;
qmul tmp tmp x_1101; //tmp = r9
let h1 = ST.get () in
assert (qas_nat h1 tmp == S.qmul (SI.qsquare_times (qas_nat h0 tmp) 6) (qas_nat h0 x_1101));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_101; //tmp = r10
let h2 = ST.get () in
assert (qas_nat h2 tmp == S.qmul (SI.qsquare_times (qas_nat h1 tmp) 4) (qas_nat h0 x_101));
qsquare_times_in_place tmp 3ul;
qmul tmp tmp x_111; //tmp = r11
let h3 = ST.get () in
assert (qas_nat h3 tmp == S.qmul (SI.qsquare_times (qas_nat h2 tmp) 3) (qas_nat h0 x_111));
qsquare_times_in_place tmp 5ul;
qmul tmp tmp x_1001; //tmp = r12
let h4 = ST.get () in
assert (qas_nat h4 tmp == S.qmul (SI.qsquare_times (qas_nat h3 tmp) 5) (qas_nat h0 x_1001));
qsquare_times_in_place tmp 6ul;
qmul tmp tmp x_101; //tmp = r13
let h5 = ST.get () in
assert (qas_nat h5 tmp == S.qmul (SI.qsquare_times (qas_nat h4 tmp) 6) (qas_nat h0 x_101));
qsquare_times_in_place tmp 10ul;
qmul tmp tmp x_111; //tmp = r14
let h6 = ST.get () in
assert (qas_nat h6 tmp == S.qmul (SI.qsquare_times (qas_nat h5 tmp) 10) (qas_nat h0 x_111));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_111; //tmp = r15
let h7 = ST.get () in
assert (qas_nat h7 tmp == S.qmul (SI.qsquare_times (qas_nat h6 tmp) 4) (qas_nat h0 x_111))
// r16; ..;r23
inline_for_extraction noextract
val qinv6 (tmp x8 x_11 x_1001 x_1011 x_1101: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h x8 /\ live h x_11 /\
live h x_1001 /\ live h x_1011 /\ live h x_1101 /\
disjoint tmp x8 /\ disjoint tmp x_11 /\ disjoint tmp x_1001 /\
disjoint tmp x_1011 /\ disjoint tmp x_1101 /\
qe_lt_q h tmp /\ qe_lt_q h x8 /\ qe_lt_q h x_11 /\
qe_lt_q h x_1001 /\ qe_lt_q h x_1011 /\ qe_lt_q h x_1101)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r16_r23 (qas_nat h0 tmp)
(qas_nat h0 x8) (qas_nat h0 x_11) (qas_nat h0 x_1001) (qas_nat h0 x_1011) (qas_nat h0 x_1101) /\
qe_lt_q h1 tmp)
let qinv6 tmp x8 x_11 x_1001 x_1011 x_1101 =
let h0 = ST.get () in
qsquare_times_in_place tmp 9ul;
qmul tmp tmp x8; //tmp = r16
let h1 = ST.get () in
assert (qas_nat h1 tmp == S.qmul (SI.qsquare_times (qas_nat h0 tmp) 9) (qas_nat h0 x8));
qsquare_times_in_place tmp 5ul;
qmul tmp tmp x_1001; //tmp = r17
let h2 = ST.get () in
assert (qas_nat h2 tmp == S.qmul (SI.qsquare_times (qas_nat h1 tmp) 5) (qas_nat h0 x_1001));
qsquare_times_in_place tmp 6ul;
qmul tmp tmp x_1011; //tmp = r18
let h3 = ST.get () in
assert (qas_nat h3 tmp == S.qmul (SI.qsquare_times (qas_nat h2 tmp) 6) (qas_nat h0 x_1011));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_1101; //tmp = r19
let h4 = ST.get () in
assert (qas_nat h4 tmp == S.qmul (SI.qsquare_times (qas_nat h3 tmp) 4) (qas_nat h0 x_1101));
qsquare_times_in_place tmp 5ul;
qmul tmp tmp x_11; //tmp = r20
let h5 = ST.get () in
assert (qas_nat h5 tmp == S.qmul (SI.qsquare_times (qas_nat h4 tmp) 5) (qas_nat h0 x_11));
qsquare_times_in_place tmp 6ul;
qmul tmp tmp x_1101; //tmp = r21
let h6 = ST.get () in
assert (qas_nat h6 tmp == S.qmul (SI.qsquare_times (qas_nat h5 tmp) 6) (qas_nat h0 x_1101));
qsquare_times_in_place tmp 10ul;
qmul tmp tmp x_1101; //tmp = r22
let h7 = ST.get () in
assert (qas_nat h7 tmp == S.qmul (SI.qsquare_times (qas_nat h6 tmp) 10) (qas_nat h0 x_1101));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_1001; //tmp = r23
let h8 = ST.get () in
assert (qas_nat h8 tmp == S.qmul (SI.qsquare_times (qas_nat h7 tmp) 4) (qas_nat h0 x_1001))
//r24; r25
inline_for_extraction noextract
val qinv7 (tmp f x6: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h f /\ live h x6 /\
disjoint tmp f /\ disjoint tmp x6 /\
qe_lt_q h tmp /\ qe_lt_q h f /\ qe_lt_q h x6)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r24_r25 (qas_nat h0 tmp) (qas_nat h0 f) (qas_nat h0 x6) /\
qe_lt_q h1 tmp)
let qinv7 tmp f x6 =
let h0 = ST.get () in
qsquare_times_in_place tmp 6ul;
qmul tmp tmp f; //tmp = r23
let h1 = ST.get () in
assert (qas_nat h1 tmp == S.qmul (SI.qsquare_times (qas_nat h0 tmp) 6) (qas_nat h0 f));
qsquare_times_in_place tmp 8ul;
qmul tmp tmp x6; //tmp = r24
let h2 = ST.get () in
assert (qas_nat h2 tmp == S.qmul (SI.qsquare_times (qas_nat h1 tmp) 8) (qas_nat h0 x6))
inline_for_extraction noextract
val qinv8 (tmp f x_11 x_101 x_111 x_1001 x_1011 x_1101: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h f /\ live h x_11 /\
live h x_101 /\ live h x_111 /\ live h x_1001 /\
live h x_1011 /\ live h x_1101 /\
disjoint tmp f /\ disjoint tmp x_11 /\ disjoint tmp x_101 /\
disjoint tmp x_111 /\ disjoint tmp x_1001 /\ disjoint tmp x_1011 /\
disjoint tmp x_1101 /\
qe_lt_q h f /\ qe_lt_q h x_11 /\ qe_lt_q h x_101 /\
qe_lt_q h x_111 /\ qe_lt_q h x_1001 /\ qe_lt_q h x_1011 /\
qe_lt_q h x_1101)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r0_r25 (qas_nat h0 f)
(qas_nat h0 x_11) (qas_nat h0 x_101) (qas_nat h0 x_111)
(qas_nat h0 x_1001) (qas_nat h0 x_1011) (qas_nat h0 x_1101) /\
qe_lt_q h1 tmp)
let qinv8 tmp f x_11 x_101 x_111 x_1001 x_1011 x_1101 =
push_frame ();
let x6 = create_qelem () in
let x8 = create_qelem () in
let x14 = create_qelem () in
let h1 = ST.get () in
qinv2 x_11 x_1011 x_1101 x6 x8 x14; //x6; x8; x14
let h2 = ST.get () in
assert (modifies (loc x6 |+| loc x8 |+| loc x14) h1 h2);
qinv3 tmp x14; //x28; x56; r0; r1
let h3 = ST.get () in
assert (modifies (loc tmp) h2 h3);
qinv4 tmp x_101 x_111 x_1011; //r2; ..; r8
let h4 = ST.get () in
assert (modifies (loc tmp) h3 h4);
qinv5 tmp x_101 x_111 x_1001 x_1101; //r9; ..; r15
let h5 = ST.get () in
assert (modifies (loc tmp) h4 h5);
qinv6 tmp x8 x_11 x_1001 x_1011 x_1101; //r16; ..; r23
let h6 = ST.get () in
assert (modifies (loc tmp) h5 h6);
qinv7 tmp f x6; //r24; r25
let h7 = ST.get () in
assert (modifies (loc tmp) h6 h7);
pop_frame ()
inline_for_extraction noextract
val qinv_ (out f: qelem) : Stack unit
(requires fun h ->
live h out /\ live h f /\ disjoint out f /\
qe_lt_q h f)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
qas_nat h1 out == SI.qinv (qas_nat h0 f) /\
qe_lt_q h1 out)
#set-options "--z3rlimit 150"
let qinv_ out f =
push_frame ();
let x_10 = create_qelem () in
let x_11 = create_qelem () in
let x_101 = create_qelem () in
let x_111 = create_qelem () in
let x_1001 = create_qelem () in
let x_1011 = create_qelem () in
let x_1101 = create_qelem () in
qinv1 f x_10 x_11 x_101 x_111 x_1001 x_1011 x_1101;
qinv8 out f x_11 x_101 x_111 x_1001 x_1011 x_1101;
pop_frame ()
val qinv (out f: qelem) : Stack unit
(requires fun h ->
live h out /\ live h f /\ disjoint out f /\
qe_lt_q h f)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
qas_nat h1 out == S.qinv (qas_nat h0 f) /\
qe_lt_q h1 out) | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.K256.Qinv.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.K256.Scalar.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.K256.Qinv.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "SD"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Qinv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.K256.Scalar",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 150,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | out: Hacl.K256.Scalar.qelem -> f: Hacl.K256.Scalar.qelem -> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.K256.Scalar.qelem",
"Hacl.Impl.K256.Qinv.qinv_",
"Prims.unit",
"Hacl.Spec.K256.Qinv.qinv_is_qinv_lemma",
"Hacl.K256.Scalar.qas_nat",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get"
] | [] | false | true | false | false | false | let qinv out f =
| let h0 = ST.get () in
SI.qinv_is_qinv_lemma (qas_nat h0 f);
qinv_ out f | false |
Hacl.Impl.K256.Qinv.fst | Hacl.Impl.K256.Qinv.qsquare_times_in_place | val qsquare_times_in_place (out:qelem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ qe_lt_q h out)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\ qe_lt_q h1 out /\
qas_nat h1 out == SI.qsquare_times (qas_nat h0 out) (v b)) | val qsquare_times_in_place (out:qelem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ qe_lt_q h out)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\ qe_lt_q h1 out /\
qas_nat h1 out == SI.qsquare_times (qas_nat h0 out) (v b)) | let qsquare_times_in_place out b =
let h0 = ST.get () in
SE.exp_pow2_lemma SI.mk_nat_mod_concrete_ops (qas_nat h0 out) (v b);
BE.lexp_pow2_in_place 4ul 0ul mk_k256_scalar_concrete_ops (null uint64) out b | {
"file_name": "code/k256/Hacl.Impl.K256.Qinv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 79,
"end_line": 79,
"start_col": 0,
"start_line": 76
} | module Hacl.Impl.K256.Qinv
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.K256.Scalar
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Spec.K256
module SI = Hacl.Spec.K256.Qinv
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module SD = Hacl.Spec.Bignum.Definitions
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
unfold
let linv_ctx (a:LSeq.lseq uint64 0) : Type0 = True
unfold
let linv (a:LSeq.lseq uint64 4) : Type0 =
SD.bn_v #U64 #4 a < S.q
unfold
let refl (a:LSeq.lseq uint64 4{linv a}) : GTot S.qelem =
SD.bn_v #U64 #4 a
inline_for_extraction noextract
let mk_to_k256_scalar_comm_monoid : BE.to_comm_monoid U64 4ul 0ul = {
BE.a_spec = S.qelem;
BE.comm_monoid = SI.nat_mod_comm_monoid;
BE.linv_ctx = linv_ctx;
BE.linv = linv;
BE.refl = refl;
}
inline_for_extraction noextract
val one_mod : BE.lone_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let one_mod ctx one = make_u64_4 one (u64 1, u64 0, u64 0, u64 0)
inline_for_extraction noextract
val mul_mod : BE.lmul_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let mul_mod ctx x y xy = qmul xy x y
inline_for_extraction noextract
val sqr_mod : BE.lsqr_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let sqr_mod ctx x xx = qsqr xx x
inline_for_extraction noextract
let mk_k256_scalar_concrete_ops : BE.concrete_ops U64 4ul 0ul = {
BE.to = mk_to_k256_scalar_comm_monoid;
BE.lone = one_mod;
BE.lmul = mul_mod;
BE.lsqr = sqr_mod;
}
val qsquare_times_in_place (out:qelem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ qe_lt_q h out)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\ qe_lt_q h1 out /\
qas_nat h1 out == SI.qsquare_times (qas_nat h0 out) (v b)) | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.K256.Qinv.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.K256.Scalar.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.K256.Qinv.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "SD"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Qinv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.K256.Scalar",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | out: Hacl.K256.Scalar.qelem -> b: Lib.IntTypes.size_t -> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.K256.Scalar.qelem",
"Lib.IntTypes.size_t",
"Hacl.Impl.Exponentiation.lexp_pow2_in_place",
"Lib.IntTypes.U64",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.K256.Qinv.mk_k256_scalar_concrete_ops",
"Lib.Buffer.null",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"Prims.unit",
"Spec.Exponentiation.exp_pow2_lemma",
"Spec.K256.PointOps.qelem",
"Hacl.Spec.K256.Qinv.mk_nat_mod_concrete_ops",
"Hacl.K256.Scalar.qas_nat",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get"
] | [] | false | true | false | false | false | let qsquare_times_in_place out b =
| let h0 = ST.get () in
SE.exp_pow2_lemma SI.mk_nat_mod_concrete_ops (qas_nat h0 out) (v b);
BE.lexp_pow2_in_place 4ul 0ul mk_k256_scalar_concrete_ops (null uint64) out b | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.bn_set_ith_bit_lemma_aux | val bn_set_ith_bit_lemma_aux: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a + b * pow2 c < pow2 (c + d) /\ a < pow2 c)
(ensures b < pow2 d) | val bn_set_ith_bit_lemma_aux: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a + b * pow2 c < pow2 (c + d) /\ a < pow2 c)
(ensures b < pow2 d) | let bn_set_ith_bit_lemma_aux a b c d =
Math.Lemmas.lemma_div_lt_nat (a + b * pow2 c) (c + d) c;
assert ((a + b * pow2 c) / pow2 c < pow2 d);
Math.Lemmas.lemma_div_plus a b (pow2 c);
assert (a / pow2 c + b < pow2 d);
Math.Lemmas.small_division_lemma_1 a (pow2 c) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 47,
"end_line": 106,
"start_col": 0,
"start_line": 101
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2)
let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2)
val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t
let bn_get_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[i] j
val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j))
let bn_get_ith_bit_aux_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = b.[i] >>. size j in
calc (==) {
v b.[i] / pow2 j;
(==) { bn_eval_index b i }
(bn_v b / pow2 (pbits * i) % pow2 pbits) / pow2 j;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b / pow2 (pbits * i)) j pbits }
(bn_v b / pow2 (pbits * i) / pow2 j) % pow2 (pbits - j);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b) (pow2 (pbits * i)) (pow2 j) }
(bn_v b / (pow2 (pbits * i) * pow2 j)) % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_plus (pbits * i) j }
(bn_v b / pow2 (pbits * i + j)) % pow2 (pbits - j);
(==) { Math.Lemmas.euclidean_div_axiom ind pbits }
(bn_v b / pow2 ind) % pow2 (pbits - j);
};
assert (v res == (bn_v b / pow2 ind) % pow2 (pbits - j))
val bn_get_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} ->
Lemma (v (bn_get_ith_bit b i) == (bn_v b / pow2 i % 2))
let bn_get_ith_bit_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = limb_get_ith_bit b.[i] j in
limb_get_ith_bit_lemma b.[i] j;
calc (==) {
v b.[i] / pow2 j % 2;
(==) { bn_get_ith_bit_aux_lemma b ind }
(bn_v b / pow2 ind) % pow2 (pbits - j) % 2;
(==) { assert_norm (pow2 1 = 2);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 ind) 1 (pbits - j) }
(bn_v b / pow2 ind) % 2;
};
assert (v res == bn_v b / pow2 ind % 2)
val bn_set_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> lbignum t len
let bn_set_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
let inp = input.[i] <- input.[i] |. (uint #t 1 <<. size j) in
inp
val bn_set_ith_bit_lemma_aux: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a + b * pow2 c < pow2 (c + d) /\ a < pow2 c)
(ensures b < pow2 d) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Prims.nat -> b: Prims.nat -> c: Prims.nat -> d: Prims.nat
-> FStar.Pervasives.Lemma (requires a + b * Prims.pow2 c < Prims.pow2 (c + d) /\ a < Prims.pow2 c)
(ensures b < Prims.pow2 d) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"FStar.Math.Lemmas.small_division_lemma_1",
"Prims.pow2",
"Prims.unit",
"Prims._assert",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Addition",
"Prims.op_Division",
"FStar.Math.Lemmas.lemma_div_plus",
"FStar.Mul.op_Star",
"FStar.Math.Lemmas.lemma_div_lt_nat"
] | [] | true | false | true | false | false | let bn_set_ith_bit_lemma_aux a b c d =
| Math.Lemmas.lemma_div_lt_nat (a + b * pow2 c) (c + d) c;
assert ((a + b * pow2 c) / pow2 c < pow2 d);
Math.Lemmas.lemma_div_plus a b (pow2 c);
assert (a / pow2 c + b < pow2 d);
Math.Lemmas.small_division_lemma_1 a (pow2 c) | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.bn_div_pow2 | val bn_div_pow2: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i <= len} -> lbignum t (len - i) | val bn_div_pow2: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i <= len} -> lbignum t (len - i) | let bn_div_pow2 #t #len b i =
slice b i len | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 185,
"start_col": 0,
"start_line": 184
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2)
let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2)
val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t
let bn_get_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[i] j
val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j))
let bn_get_ith_bit_aux_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = b.[i] >>. size j in
calc (==) {
v b.[i] / pow2 j;
(==) { bn_eval_index b i }
(bn_v b / pow2 (pbits * i) % pow2 pbits) / pow2 j;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b / pow2 (pbits * i)) j pbits }
(bn_v b / pow2 (pbits * i) / pow2 j) % pow2 (pbits - j);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b) (pow2 (pbits * i)) (pow2 j) }
(bn_v b / (pow2 (pbits * i) * pow2 j)) % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_plus (pbits * i) j }
(bn_v b / pow2 (pbits * i + j)) % pow2 (pbits - j);
(==) { Math.Lemmas.euclidean_div_axiom ind pbits }
(bn_v b / pow2 ind) % pow2 (pbits - j);
};
assert (v res == (bn_v b / pow2 ind) % pow2 (pbits - j))
val bn_get_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} ->
Lemma (v (bn_get_ith_bit b i) == (bn_v b / pow2 i % 2))
let bn_get_ith_bit_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = limb_get_ith_bit b.[i] j in
limb_get_ith_bit_lemma b.[i] j;
calc (==) {
v b.[i] / pow2 j % 2;
(==) { bn_get_ith_bit_aux_lemma b ind }
(bn_v b / pow2 ind) % pow2 (pbits - j) % 2;
(==) { assert_norm (pow2 1 = 2);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 ind) 1 (pbits - j) }
(bn_v b / pow2 ind) % 2;
};
assert (v res == bn_v b / pow2 ind % 2)
val bn_set_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> lbignum t len
let bn_set_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
let inp = input.[i] <- input.[i] |. (uint #t 1 <<. size j) in
inp
val bn_set_ith_bit_lemma_aux: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a + b * pow2 c < pow2 (c + d) /\ a < pow2 c)
(ensures b < pow2 d)
let bn_set_ith_bit_lemma_aux a b c d =
Math.Lemmas.lemma_div_lt_nat (a + b * pow2 c) (c + d) c;
assert ((a + b * pow2 c) / pow2 c < pow2 d);
Math.Lemmas.lemma_div_plus a b (pow2 c);
assert (a / pow2 c + b < pow2 d);
Math.Lemmas.small_division_lemma_1 a (pow2 c)
val bn_lt_pow2_index_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} -> Lemma
(requires bn_v b < pow2 ind)
(ensures (let i = ind / bits t in v b.[i] < pow2 (ind % bits t) /\
bn_v b == bn_v (slice b 0 i) + pow2 (i * bits t) * v b.[i] /\
bn_v (slice b (i + 1) len) = 0))
let bn_lt_pow2_index_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
Math.Lemmas.euclidean_division_definition ind (pbits);
assert (bn_v b < pow2 (i * pbits + j));
Math.Lemmas.pow2_lt_compat (i * pbits + pbits) (i * pbits + j);
assert (bn_v b < pow2 (i * pbits + pbits));
bn_eval_split_i #t #len b (i + 1);
bn_eval_bound (slice b 0 (i + 1)) (i + 1);
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 (i + 1))) (bn_v (slice b (i + 1) len)) (pbits * (i + 1)) 0;
assert (bn_v b == bn_v (slice b 0 (i + 1)));
bn_eval_split_i #t #(i + 1) (slice b 0 (i + 1)) i;
bn_eval1 (slice b i (i + 1));
assert (bn_v b == bn_v (slice b 0 i) + pow2 (i * pbits) * v b.[i]);
bn_eval_bound #t #i (slice b 0 i) i;
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 i)) (v b.[i]) (i * pbits) j;
assert (v b.[i] < pow2 j)
val bn_set_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> Lemma
(requires bn_v b < pow2 i)
(ensures bn_v (bn_set_ith_bit b i) == bn_v b + pow2 i)
let bn_set_ith_bit_lemma #t #len input ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
bn_lt_pow2_index_lemma #t #len input ind;
assert (v input.[i] < pow2 j);
let b = uint #t 1 <<. size j in
let inp = input.[i] <- input.[i] |. b in
FStar.Math.Lemmas.pow2_lt_compat pbits j;
FStar.Math.Lemmas.modulo_lemma (pow2 j) (pow2 pbits);
assert (v b == pow2 j);
logor_disjoint (input.[i]) b j;
assert (v inp.[i] == v input.[i] + v b);
calc (==) {
bn_v inp;
(==) { bn_eval_split_i #t #len inp (i + 1);
bn_eval_extensionality_j (slice inp (i + 1) len) (slice input (i + 1) len) (len - i - 1) }
bn_v (slice inp 0 (i + 1));
(==) { bn_eval_split_i #t #(i + 1) (slice inp 0 (i + 1)) i }
bn_v (slice inp 0 i) + pow2 (i * pbits) * bn_v (slice inp i (i + 1));
(==) { bn_eval1 (slice inp i (i + 1)) }
bn_v (slice inp 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { bn_eval_extensionality_j input inp i }
bn_v (slice input 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { }
bn_v (slice input 0 i) + pow2 (i * pbits) * (v input.[i] + v b);
(==) { Math.Lemmas.distributivity_add_right (pow2 (i * pbits)) (v input.[i]) (v b) }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 (i * pbits) * v b;
(==) { Math.Lemmas.pow2_plus (i * pbits) j; Math.Lemmas.euclidean_division_definition ind pbits }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 ind;
(==) { }
bn_v input + pow2 ind;
}
///
/// % pow2 and / pow2
/// | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b: Hacl.Spec.Bignum.Definitions.lbignum t len -> i: Lib.IntTypes.size_nat{i <= len}
-> Hacl.Spec.Bignum.Definitions.lbignum t (len - i) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.Sequence.slice",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.op_Subtraction"
] | [] | false | false | false | false | false | let bn_div_pow2 #t #len b i =
| slice b i len | false |
Hacl.Impl.K256.Qinv.fst | Hacl.Impl.K256.Qinv.qinv7 | val qinv7 (tmp f x6: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h f /\ live h x6 /\
disjoint tmp f /\ disjoint tmp x6 /\
qe_lt_q h tmp /\ qe_lt_q h f /\ qe_lt_q h x6)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r24_r25 (qas_nat h0 tmp) (qas_nat h0 f) (qas_nat h0 x6) /\
qe_lt_q h1 tmp) | val qinv7 (tmp f x6: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h f /\ live h x6 /\
disjoint tmp f /\ disjoint tmp x6 /\
qe_lt_q h tmp /\ qe_lt_q h f /\ qe_lt_q h x6)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r24_r25 (qas_nat h0 tmp) (qas_nat h0 f) (qas_nat h0 x6) /\
qe_lt_q h1 tmp) | let qinv7 tmp f x6 =
let h0 = ST.get () in
qsquare_times_in_place tmp 6ul;
qmul tmp tmp f; //tmp = r23
let h1 = ST.get () in
assert (qas_nat h1 tmp == S.qmul (SI.qsquare_times (qas_nat h0 tmp) 6) (qas_nat h0 f));
qsquare_times_in_place tmp 8ul;
qmul tmp tmp x6; //tmp = r24
let h2 = ST.get () in
assert (qas_nat h2 tmp == S.qmul (SI.qsquare_times (qas_nat h1 tmp) 8) (qas_nat h0 x6)) | {
"file_name": "code/k256/Hacl.Impl.K256.Qinv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 89,
"end_line": 413,
"start_col": 0,
"start_line": 403
} | module Hacl.Impl.K256.Qinv
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.K256.Scalar
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Spec.K256
module SI = Hacl.Spec.K256.Qinv
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module SD = Hacl.Spec.Bignum.Definitions
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
unfold
let linv_ctx (a:LSeq.lseq uint64 0) : Type0 = True
unfold
let linv (a:LSeq.lseq uint64 4) : Type0 =
SD.bn_v #U64 #4 a < S.q
unfold
let refl (a:LSeq.lseq uint64 4{linv a}) : GTot S.qelem =
SD.bn_v #U64 #4 a
inline_for_extraction noextract
let mk_to_k256_scalar_comm_monoid : BE.to_comm_monoid U64 4ul 0ul = {
BE.a_spec = S.qelem;
BE.comm_monoid = SI.nat_mod_comm_monoid;
BE.linv_ctx = linv_ctx;
BE.linv = linv;
BE.refl = refl;
}
inline_for_extraction noextract
val one_mod : BE.lone_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let one_mod ctx one = make_u64_4 one (u64 1, u64 0, u64 0, u64 0)
inline_for_extraction noextract
val mul_mod : BE.lmul_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let mul_mod ctx x y xy = qmul xy x y
inline_for_extraction noextract
val sqr_mod : BE.lsqr_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let sqr_mod ctx x xx = qsqr xx x
inline_for_extraction noextract
let mk_k256_scalar_concrete_ops : BE.concrete_ops U64 4ul 0ul = {
BE.to = mk_to_k256_scalar_comm_monoid;
BE.lone = one_mod;
BE.lmul = mul_mod;
BE.lsqr = sqr_mod;
}
val qsquare_times_in_place (out:qelem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ qe_lt_q h out)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\ qe_lt_q h1 out /\
qas_nat h1 out == SI.qsquare_times (qas_nat h0 out) (v b))
[@CInline]
let qsquare_times_in_place out b =
let h0 = ST.get () in
SE.exp_pow2_lemma SI.mk_nat_mod_concrete_ops (qas_nat h0 out) (v b);
BE.lexp_pow2_in_place 4ul 0ul mk_k256_scalar_concrete_ops (null uint64) out b
val qsquare_times (out a:qelem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ live h a /\ disjoint out a /\
qe_lt_q h a)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\ qe_lt_q h1 a /\
qas_nat h1 out == SI.qsquare_times (qas_nat h0 a) (v b))
[@CInline]
let qsquare_times out a b =
let h0 = ST.get () in
SE.exp_pow2_lemma SI.mk_nat_mod_concrete_ops (qas_nat h0 a) (v b);
BE.lexp_pow2 4ul 0ul mk_k256_scalar_concrete_ops (null uint64) a b out
inline_for_extraction noextract
val qinv1 (f x_10 x_11 x_101 x_111 x_1001 x_1011 x_1101:qelem) : Stack unit
(requires fun h ->
live h f /\ live h x_10 /\ live h x_11 /\ live h x_101 /\
live h x_111 /\ live h x_1001 /\ live h x_1011 /\ live h x_1101 /\
disjoint f x_10 /\ disjoint f x_11 /\ disjoint f x_101 /\
disjoint f x_111 /\ disjoint f x_1001 /\ disjoint f x_1011 /\
disjoint f x_1101 /\ disjoint x_10 x_11 /\ disjoint x_10 x_101 /\
disjoint x_10 x_111 /\ disjoint x_10 x_1001 /\ disjoint x_10 x_1011 /\
disjoint x_10 x_1101 /\ disjoint x_11 x_101 /\ disjoint x_11 x_111 /\
disjoint x_11 x_1001 /\ disjoint x_11 x_1011 /\ disjoint x_11 x_1101 /\
disjoint x_101 x_111 /\ disjoint x_101 x_1001 /\ disjoint x_101 x_1011 /\
disjoint x_101 x_1101 /\ disjoint x_111 x_1001 /\ disjoint x_111 x_1011 /\
disjoint x_111 x_1101 /\ disjoint x_1001 x_1011 /\ disjoint x_1001 x_1101 /\
disjoint x_1011 x_1101 /\ qe_lt_q h f)
(ensures fun h0 _ h1 ->
modifies (loc x_10 |+| loc x_11 |+| loc x_101 |+|
loc x_111 |+| loc x_1001 |+| loc x_1011 |+| loc x_1101) h0 h1 /\
(let _x_10 = SI.qsquare_times (qas_nat h0 f) 1 in
let _x_11 = S.qmul _x_10 (qas_nat h0 f) in
let _x_101 = S.qmul _x_10 _x_11 in
let _x_111 = S.qmul _x_10 _x_101 in
let _x_1001 = S.qmul _x_10 _x_111 in
let _x_1011 = S.qmul _x_10 _x_1001 in
let _x_1101 = S.qmul _x_10 _x_1011 in
qas_nat h1 x_10 == _x_10 /\ qe_lt_q h1 x_10 /\
qas_nat h1 x_11 == _x_11 /\ qe_lt_q h1 x_11 /\
qas_nat h1 x_101 == _x_101 /\ qe_lt_q h1 x_101 /\
qas_nat h1 x_111 == _x_111 /\ qe_lt_q h1 x_111 /\
qas_nat h1 x_1001 == _x_1001 /\ qe_lt_q h1 x_1001 /\
qas_nat h1 x_1011 == _x_1011 /\ qe_lt_q h1 x_1011 /\
qas_nat h1 x_1101 == _x_1101 /\ qe_lt_q h1 x_1101))
let qinv1 f x_10 x_11 x_101 x_111 x_1001 x_1011 x_1101 =
let h0 = ST.get () in
qsquare_times x_10 f 1ul;
let h1 = ST.get () in
assert (qas_nat h1 x_10 == SI.qsquare_times (qas_nat h0 f) 1);
qmul x_11 x_10 f;
let h2 = ST.get () in
assert (qas_nat h2 x_11 == S.qmul (qas_nat h1 x_10) (qas_nat h0 f));
qmul x_101 x_10 x_11;
let h3 = ST.get () in
assert (qas_nat h3 x_101 == S.qmul (qas_nat h1 x_10) (qas_nat h2 x_11));
qmul x_111 x_10 x_101;
let h4 = ST.get () in
assert (qas_nat h4 x_111 == S.qmul (qas_nat h1 x_10) (qas_nat h3 x_101));
qmul x_1001 x_10 x_111;
let h5 = ST.get () in
assert (qas_nat h5 x_1001 == S.qmul (qas_nat h1 x_10) (qas_nat h4 x_111));
qmul x_1011 x_10 x_1001;
let h6 = ST.get () in
assert (qas_nat h6 x_1011 == S.qmul (qas_nat h1 x_10) (qas_nat h5 x_1001));
qmul x_1101 x_10 x_1011;
let h7 = ST.get () in
assert (qas_nat h7 x_1101 == S.qmul (qas_nat h1 x_10) (qas_nat h6 x_1011))
inline_for_extraction noextract
val qinv2 (x_11 x_1011 x_1101 x6 x8 x14: qelem) : Stack unit
(requires fun h ->
live h x_11 /\ live h x_1011 /\ live h x_1101 /\
live h x6 /\ live h x8 /\ live h x14 /\
disjoint x_11 x6 /\ disjoint x_11 x8 /\ disjoint x_11 x14 /\
disjoint x_1011 x6 /\ disjoint x_1011 x8 /\ disjoint x_1011 x14 /\
disjoint x_1101 x6 /\ disjoint x_1101 x8 /\ disjoint x_1101 x14 /\
disjoint x6 x8 /\ disjoint x6 x14 /\ disjoint x8 x14 /\
qe_lt_q h x_11 /\ qe_lt_q h x_1011 /\ qe_lt_q h x_1101)
(ensures fun h0 _ h1 -> modifies (loc x6 |+| loc x8 |+| loc x14) h0 h1 /\
(let _x6 = S.qmul (SI.qsquare_times (qas_nat h0 x_1101) 2) (qas_nat h0 x_1011) in
let _x8 = S.qmul (SI.qsquare_times _x6 2) (qas_nat h0 x_11) in
let _x14 = S.qmul (SI.qsquare_times _x8 6) _x6 in
qas_nat h1 x6 == _x6 /\ qe_lt_q h1 x6 /\
qas_nat h1 x8 == _x8 /\ qe_lt_q h1 x8 /\
qas_nat h1 x14 == _x14 /\ qe_lt_q h1 x14))
let qinv2 x_11 x_1011 x_1101 x6 x8 x14 =
let h0 = ST.get () in
qsquare_times x6 x_1101 2ul;
qmul x6 x6 x_1011;
let h1 = ST.get () in
assert (qas_nat h1 x6 == S.qmul (SI.qsquare_times (qas_nat h0 x_1101) 2) (qas_nat h0 x_1011));
qsquare_times x8 x6 2ul;
qmul x8 x8 x_11;
let h2 = ST.get () in
assert (qas_nat h2 x8 == S.qmul (SI.qsquare_times (qas_nat h1 x6) 2) (qas_nat h0 x_11));
qsquare_times x14 x8 6ul;
qmul x14 x14 x6;
let h3 = ST.get () in
assert (qas_nat h3 x14 == S.qmul (SI.qsquare_times (qas_nat h2 x8) 6) (qas_nat h1 x6))
inline_for_extraction noextract
val qinv3 (tmp x14: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h x14 /\ disjoint tmp x14 /\
qe_lt_q h x14)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r0_r1 (qas_nat h0 x14) /\
qe_lt_q h1 tmp)
let qinv3 tmp x14 =
push_frame ();
let x56 = create_qelem () in
let h0 = ST.get () in
qsquare_times tmp x14 14ul;
qmul tmp tmp x14; //tmp = x28
let h1 = ST.get () in
assert (qas_nat h1 tmp == S.qmul (SI.qsquare_times (qas_nat h0 x14) 14) (qas_nat h0 x14));
qsquare_times x56 tmp 28ul;
qmul x56 x56 tmp;
let h2 = ST.get () in
assert (qas_nat h2 x56 == S.qmul (SI.qsquare_times (qas_nat h1 tmp) 28) (qas_nat h1 tmp));
qsquare_times tmp x56 56ul; //tmp = r0
qmul tmp tmp x56;
let h3 = ST.get () in
assert (qas_nat h3 tmp == S.qmul (SI.qsquare_times (qas_nat h2 x56) 56) (qas_nat h2 x56));
qsquare_times_in_place tmp 14ul; //tmp = r1
qmul tmp tmp x14;
let h4 = ST.get () in
assert (qas_nat h4 tmp == S.qmul (SI.qsquare_times (qas_nat h3 tmp) 14) (qas_nat h0 x14));
pop_frame ()
//r2; .. ;r8
inline_for_extraction noextract
val qinv4 (tmp x_101 x_111 x_1011: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h x_101 /\ live h x_111 /\ live h x_1011 /\
disjoint tmp x_101 /\ disjoint tmp x_111 /\ disjoint tmp x_1011 /\
qe_lt_q h tmp /\ qe_lt_q h x_101 /\ qe_lt_q h x_111 /\ qe_lt_q h x_1011)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r2_r8 (qas_nat h0 tmp)
(qas_nat h0 x_101) (qas_nat h0 x_111) (qas_nat h0 x_1011) /\
qe_lt_q h1 tmp)
let qinv4 tmp x_101 x_111 x_1011 =
let h0 = ST.get () in
qsquare_times_in_place tmp 3ul;
qmul tmp tmp x_101; //tmp = r2
let h1 = ST.get () in
assert (qas_nat h1 tmp == S.qmul (SI.qsquare_times (qas_nat h0 tmp) 3) (qas_nat h0 x_101));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_111; //tmp = r3
let h2 = ST.get () in
assert (qas_nat h2 tmp == S.qmul (SI.qsquare_times (qas_nat h1 tmp) 4) (qas_nat h0 x_111));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_101; //tmp = r4
let h3 = ST.get () in
assert (qas_nat h3 tmp == S.qmul (SI.qsquare_times (qas_nat h2 tmp) 4) (qas_nat h0 x_101));
qsquare_times_in_place tmp 5ul;
qmul tmp tmp x_1011; //tmp = r5
let h4 = ST.get () in
assert (qas_nat h4 tmp == S.qmul (SI.qsquare_times (qas_nat h3 tmp) 5) (qas_nat h0 x_1011));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_1011; //tmp = r6
let h5 = ST.get () in
assert (qas_nat h5 tmp == S.qmul (SI.qsquare_times (qas_nat h4 tmp) 4) (qas_nat h0 x_1011));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_111; //tmp = r7
let h6 = ST.get () in
assert (qas_nat h6 tmp == S.qmul (SI.qsquare_times (qas_nat h5 tmp) 4) (qas_nat h0 x_111));
qsquare_times_in_place tmp 5ul;
qmul tmp tmp x_111; //tmp = r8
let h7 = ST.get () in
assert (qas_nat h7 tmp == S.qmul (SI.qsquare_times (qas_nat h6 tmp) 5) (qas_nat h0 x_111))
// r9; ..; r15
inline_for_extraction noextract
val qinv5 (tmp x_101 x_111 x_1001 x_1101: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h x_101 /\ live h x_111 /\
live h x_1001 /\ live h x_1101 /\ disjoint tmp x_101 /\
disjoint tmp x_111 /\ disjoint tmp x_1001 /\ disjoint tmp x_1101 /\
qe_lt_q h tmp /\ qe_lt_q h x_101 /\ qe_lt_q h x_111 /\
qe_lt_q h x_1001 /\ qe_lt_q h x_1101)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r9_r15 (qas_nat h0 tmp)
(qas_nat h0 x_101) (qas_nat h0 x_111) (qas_nat h0 x_1001) (qas_nat h0 x_1101) /\
qe_lt_q h1 tmp)
let qinv5 tmp x_101 x_111 x_1001 x_1101 =
let h0 = ST.get () in
qsquare_times_in_place tmp 6ul;
qmul tmp tmp x_1101; //tmp = r9
let h1 = ST.get () in
assert (qas_nat h1 tmp == S.qmul (SI.qsquare_times (qas_nat h0 tmp) 6) (qas_nat h0 x_1101));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_101; //tmp = r10
let h2 = ST.get () in
assert (qas_nat h2 tmp == S.qmul (SI.qsquare_times (qas_nat h1 tmp) 4) (qas_nat h0 x_101));
qsquare_times_in_place tmp 3ul;
qmul tmp tmp x_111; //tmp = r11
let h3 = ST.get () in
assert (qas_nat h3 tmp == S.qmul (SI.qsquare_times (qas_nat h2 tmp) 3) (qas_nat h0 x_111));
qsquare_times_in_place tmp 5ul;
qmul tmp tmp x_1001; //tmp = r12
let h4 = ST.get () in
assert (qas_nat h4 tmp == S.qmul (SI.qsquare_times (qas_nat h3 tmp) 5) (qas_nat h0 x_1001));
qsquare_times_in_place tmp 6ul;
qmul tmp tmp x_101; //tmp = r13
let h5 = ST.get () in
assert (qas_nat h5 tmp == S.qmul (SI.qsquare_times (qas_nat h4 tmp) 6) (qas_nat h0 x_101));
qsquare_times_in_place tmp 10ul;
qmul tmp tmp x_111; //tmp = r14
let h6 = ST.get () in
assert (qas_nat h6 tmp == S.qmul (SI.qsquare_times (qas_nat h5 tmp) 10) (qas_nat h0 x_111));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_111; //tmp = r15
let h7 = ST.get () in
assert (qas_nat h7 tmp == S.qmul (SI.qsquare_times (qas_nat h6 tmp) 4) (qas_nat h0 x_111))
// r16; ..;r23
inline_for_extraction noextract
val qinv6 (tmp x8 x_11 x_1001 x_1011 x_1101: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h x8 /\ live h x_11 /\
live h x_1001 /\ live h x_1011 /\ live h x_1101 /\
disjoint tmp x8 /\ disjoint tmp x_11 /\ disjoint tmp x_1001 /\
disjoint tmp x_1011 /\ disjoint tmp x_1101 /\
qe_lt_q h tmp /\ qe_lt_q h x8 /\ qe_lt_q h x_11 /\
qe_lt_q h x_1001 /\ qe_lt_q h x_1011 /\ qe_lt_q h x_1101)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r16_r23 (qas_nat h0 tmp)
(qas_nat h0 x8) (qas_nat h0 x_11) (qas_nat h0 x_1001) (qas_nat h0 x_1011) (qas_nat h0 x_1101) /\
qe_lt_q h1 tmp)
let qinv6 tmp x8 x_11 x_1001 x_1011 x_1101 =
let h0 = ST.get () in
qsquare_times_in_place tmp 9ul;
qmul tmp tmp x8; //tmp = r16
let h1 = ST.get () in
assert (qas_nat h1 tmp == S.qmul (SI.qsquare_times (qas_nat h0 tmp) 9) (qas_nat h0 x8));
qsquare_times_in_place tmp 5ul;
qmul tmp tmp x_1001; //tmp = r17
let h2 = ST.get () in
assert (qas_nat h2 tmp == S.qmul (SI.qsquare_times (qas_nat h1 tmp) 5) (qas_nat h0 x_1001));
qsquare_times_in_place tmp 6ul;
qmul tmp tmp x_1011; //tmp = r18
let h3 = ST.get () in
assert (qas_nat h3 tmp == S.qmul (SI.qsquare_times (qas_nat h2 tmp) 6) (qas_nat h0 x_1011));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_1101; //tmp = r19
let h4 = ST.get () in
assert (qas_nat h4 tmp == S.qmul (SI.qsquare_times (qas_nat h3 tmp) 4) (qas_nat h0 x_1101));
qsquare_times_in_place tmp 5ul;
qmul tmp tmp x_11; //tmp = r20
let h5 = ST.get () in
assert (qas_nat h5 tmp == S.qmul (SI.qsquare_times (qas_nat h4 tmp) 5) (qas_nat h0 x_11));
qsquare_times_in_place tmp 6ul;
qmul tmp tmp x_1101; //tmp = r21
let h6 = ST.get () in
assert (qas_nat h6 tmp == S.qmul (SI.qsquare_times (qas_nat h5 tmp) 6) (qas_nat h0 x_1101));
qsquare_times_in_place tmp 10ul;
qmul tmp tmp x_1101; //tmp = r22
let h7 = ST.get () in
assert (qas_nat h7 tmp == S.qmul (SI.qsquare_times (qas_nat h6 tmp) 10) (qas_nat h0 x_1101));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_1001; //tmp = r23
let h8 = ST.get () in
assert (qas_nat h8 tmp == S.qmul (SI.qsquare_times (qas_nat h7 tmp) 4) (qas_nat h0 x_1001))
//r24; r25
inline_for_extraction noextract
val qinv7 (tmp f x6: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h f /\ live h x6 /\
disjoint tmp f /\ disjoint tmp x6 /\
qe_lt_q h tmp /\ qe_lt_q h f /\ qe_lt_q h x6)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r24_r25 (qas_nat h0 tmp) (qas_nat h0 f) (qas_nat h0 x6) /\
qe_lt_q h1 tmp) | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.K256.Qinv.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.K256.Scalar.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.K256.Qinv.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "SD"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Qinv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.K256.Scalar",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | tmp: Hacl.K256.Scalar.qelem -> f: Hacl.K256.Scalar.qelem -> x6: Hacl.K256.Scalar.qelem
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.K256.Scalar.qelem",
"Prims._assert",
"Prims.eq2",
"Prims.nat",
"Hacl.K256.Scalar.qas_nat",
"Spec.K256.PointOps.qmul",
"Hacl.Spec.K256.Qinv.qsquare_times",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Hacl.K256.Scalar.qmul",
"Hacl.Impl.K256.Qinv.qsquare_times_in_place",
"FStar.UInt32.__uint_to_t"
] | [] | false | true | false | false | false | let qinv7 tmp f x6 =
| let h0 = ST.get () in
qsquare_times_in_place tmp 6ul;
qmul tmp tmp f;
let h1 = ST.get () in
assert (qas_nat h1 tmp == S.qmul (SI.qsquare_times (qas_nat h0 tmp) 6) (qas_nat h0 f));
qsquare_times_in_place tmp 8ul;
qmul tmp tmp x6;
let h2 = ST.get () in
assert (qas_nat h2 tmp == S.qmul (SI.qsquare_times (qas_nat h1 tmp) 8) (qas_nat h0 x6)) | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.bn_set_ith_bit | val bn_set_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> lbignum t len | val bn_set_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> lbignum t len | let bn_set_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
let inp = input.[i] <- input.[i] |. (uint #t 1 <<. size j) in
inp | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 94,
"start_col": 0,
"start_line": 90
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2)
let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2)
val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t
let bn_get_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[i] j
val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j))
let bn_get_ith_bit_aux_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = b.[i] >>. size j in
calc (==) {
v b.[i] / pow2 j;
(==) { bn_eval_index b i }
(bn_v b / pow2 (pbits * i) % pow2 pbits) / pow2 j;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b / pow2 (pbits * i)) j pbits }
(bn_v b / pow2 (pbits * i) / pow2 j) % pow2 (pbits - j);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b) (pow2 (pbits * i)) (pow2 j) }
(bn_v b / (pow2 (pbits * i) * pow2 j)) % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_plus (pbits * i) j }
(bn_v b / pow2 (pbits * i + j)) % pow2 (pbits - j);
(==) { Math.Lemmas.euclidean_div_axiom ind pbits }
(bn_v b / pow2 ind) % pow2 (pbits - j);
};
assert (v res == (bn_v b / pow2 ind) % pow2 (pbits - j))
val bn_get_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} ->
Lemma (v (bn_get_ith_bit b i) == (bn_v b / pow2 i % 2))
let bn_get_ith_bit_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = limb_get_ith_bit b.[i] j in
limb_get_ith_bit_lemma b.[i] j;
calc (==) {
v b.[i] / pow2 j % 2;
(==) { bn_get_ith_bit_aux_lemma b ind }
(bn_v b / pow2 ind) % pow2 (pbits - j) % 2;
(==) { assert_norm (pow2 1 = 2);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 ind) 1 (pbits - j) }
(bn_v b / pow2 ind) % 2;
};
assert (v res == bn_v b / pow2 ind % 2) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: Hacl.Spec.Bignum.Definitions.lbignum t len ->
i: Lib.IntTypes.size_nat{i / Lib.IntTypes.bits t < len}
-> Hacl.Spec.Bignum.Definitions.lbignum t len | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Division",
"Lib.IntTypes.bits",
"Lib.Sequence.lseq",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.upd",
"Lib.IntTypes.logor",
"Lib.IntTypes.SEC",
"Lib.Sequence.index",
"Lib.IntTypes.shift_left",
"Lib.IntTypes.mk_int",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.l_Forall",
"Prims.nat",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.l_imp",
"Prims.op_disEquality",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.op_String_Assignment",
"Lib.IntTypes.op_Bar_Dot",
"Lib.Sequence.op_String_Access",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.IntTypes.uint",
"Lib.IntTypes.size",
"Prims.int",
"Prims.op_Modulus"
] | [] | false | false | false | false | false | let bn_set_ith_bit #t #len input ind =
| let i = ind / bits t in
let j = ind % bits t in
let inp = input.[ i ] <- input.[ i ] |. (uint #t 1 <<. size j) in
inp | false |
Hacl.Impl.K256.Qinv.fst | Hacl.Impl.K256.Qinv.qinv1 | val qinv1 (f x_10 x_11 x_101 x_111 x_1001 x_1011 x_1101:qelem) : Stack unit
(requires fun h ->
live h f /\ live h x_10 /\ live h x_11 /\ live h x_101 /\
live h x_111 /\ live h x_1001 /\ live h x_1011 /\ live h x_1101 /\
disjoint f x_10 /\ disjoint f x_11 /\ disjoint f x_101 /\
disjoint f x_111 /\ disjoint f x_1001 /\ disjoint f x_1011 /\
disjoint f x_1101 /\ disjoint x_10 x_11 /\ disjoint x_10 x_101 /\
disjoint x_10 x_111 /\ disjoint x_10 x_1001 /\ disjoint x_10 x_1011 /\
disjoint x_10 x_1101 /\ disjoint x_11 x_101 /\ disjoint x_11 x_111 /\
disjoint x_11 x_1001 /\ disjoint x_11 x_1011 /\ disjoint x_11 x_1101 /\
disjoint x_101 x_111 /\ disjoint x_101 x_1001 /\ disjoint x_101 x_1011 /\
disjoint x_101 x_1101 /\ disjoint x_111 x_1001 /\ disjoint x_111 x_1011 /\
disjoint x_111 x_1101 /\ disjoint x_1001 x_1011 /\ disjoint x_1001 x_1101 /\
disjoint x_1011 x_1101 /\ qe_lt_q h f)
(ensures fun h0 _ h1 ->
modifies (loc x_10 |+| loc x_11 |+| loc x_101 |+|
loc x_111 |+| loc x_1001 |+| loc x_1011 |+| loc x_1101) h0 h1 /\
(let _x_10 = SI.qsquare_times (qas_nat h0 f) 1 in
let _x_11 = S.qmul _x_10 (qas_nat h0 f) in
let _x_101 = S.qmul _x_10 _x_11 in
let _x_111 = S.qmul _x_10 _x_101 in
let _x_1001 = S.qmul _x_10 _x_111 in
let _x_1011 = S.qmul _x_10 _x_1001 in
let _x_1101 = S.qmul _x_10 _x_1011 in
qas_nat h1 x_10 == _x_10 /\ qe_lt_q h1 x_10 /\
qas_nat h1 x_11 == _x_11 /\ qe_lt_q h1 x_11 /\
qas_nat h1 x_101 == _x_101 /\ qe_lt_q h1 x_101 /\
qas_nat h1 x_111 == _x_111 /\ qe_lt_q h1 x_111 /\
qas_nat h1 x_1001 == _x_1001 /\ qe_lt_q h1 x_1001 /\
qas_nat h1 x_1011 == _x_1011 /\ qe_lt_q h1 x_1011 /\
qas_nat h1 x_1101 == _x_1101 /\ qe_lt_q h1 x_1101)) | val qinv1 (f x_10 x_11 x_101 x_111 x_1001 x_1011 x_1101:qelem) : Stack unit
(requires fun h ->
live h f /\ live h x_10 /\ live h x_11 /\ live h x_101 /\
live h x_111 /\ live h x_1001 /\ live h x_1011 /\ live h x_1101 /\
disjoint f x_10 /\ disjoint f x_11 /\ disjoint f x_101 /\
disjoint f x_111 /\ disjoint f x_1001 /\ disjoint f x_1011 /\
disjoint f x_1101 /\ disjoint x_10 x_11 /\ disjoint x_10 x_101 /\
disjoint x_10 x_111 /\ disjoint x_10 x_1001 /\ disjoint x_10 x_1011 /\
disjoint x_10 x_1101 /\ disjoint x_11 x_101 /\ disjoint x_11 x_111 /\
disjoint x_11 x_1001 /\ disjoint x_11 x_1011 /\ disjoint x_11 x_1101 /\
disjoint x_101 x_111 /\ disjoint x_101 x_1001 /\ disjoint x_101 x_1011 /\
disjoint x_101 x_1101 /\ disjoint x_111 x_1001 /\ disjoint x_111 x_1011 /\
disjoint x_111 x_1101 /\ disjoint x_1001 x_1011 /\ disjoint x_1001 x_1101 /\
disjoint x_1011 x_1101 /\ qe_lt_q h f)
(ensures fun h0 _ h1 ->
modifies (loc x_10 |+| loc x_11 |+| loc x_101 |+|
loc x_111 |+| loc x_1001 |+| loc x_1011 |+| loc x_1101) h0 h1 /\
(let _x_10 = SI.qsquare_times (qas_nat h0 f) 1 in
let _x_11 = S.qmul _x_10 (qas_nat h0 f) in
let _x_101 = S.qmul _x_10 _x_11 in
let _x_111 = S.qmul _x_10 _x_101 in
let _x_1001 = S.qmul _x_10 _x_111 in
let _x_1011 = S.qmul _x_10 _x_1001 in
let _x_1101 = S.qmul _x_10 _x_1011 in
qas_nat h1 x_10 == _x_10 /\ qe_lt_q h1 x_10 /\
qas_nat h1 x_11 == _x_11 /\ qe_lt_q h1 x_11 /\
qas_nat h1 x_101 == _x_101 /\ qe_lt_q h1 x_101 /\
qas_nat h1 x_111 == _x_111 /\ qe_lt_q h1 x_111 /\
qas_nat h1 x_1001 == _x_1001 /\ qe_lt_q h1 x_1001 /\
qas_nat h1 x_1011 == _x_1011 /\ qe_lt_q h1 x_1011 /\
qas_nat h1 x_1101 == _x_1101 /\ qe_lt_q h1 x_1101)) | let qinv1 f x_10 x_11 x_101 x_111 x_1001 x_1011 x_1101 =
let h0 = ST.get () in
qsquare_times x_10 f 1ul;
let h1 = ST.get () in
assert (qas_nat h1 x_10 == SI.qsquare_times (qas_nat h0 f) 1);
qmul x_11 x_10 f;
let h2 = ST.get () in
assert (qas_nat h2 x_11 == S.qmul (qas_nat h1 x_10) (qas_nat h0 f));
qmul x_101 x_10 x_11;
let h3 = ST.get () in
assert (qas_nat h3 x_101 == S.qmul (qas_nat h1 x_10) (qas_nat h2 x_11));
qmul x_111 x_10 x_101;
let h4 = ST.get () in
assert (qas_nat h4 x_111 == S.qmul (qas_nat h1 x_10) (qas_nat h3 x_101));
qmul x_1001 x_10 x_111;
let h5 = ST.get () in
assert (qas_nat h5 x_1001 == S.qmul (qas_nat h1 x_10) (qas_nat h4 x_111));
qmul x_1011 x_10 x_1001;
let h6 = ST.get () in
assert (qas_nat h6 x_1011 == S.qmul (qas_nat h1 x_10) (qas_nat h5 x_1001));
qmul x_1101 x_10 x_1011;
let h7 = ST.get () in
assert (qas_nat h7 x_1101 == S.qmul (qas_nat h1 x_10) (qas_nat h6 x_1011)) | {
"file_name": "code/k256/Hacl.Impl.K256.Qinv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 76,
"end_line": 157,
"start_col": 0,
"start_line": 129
} | module Hacl.Impl.K256.Qinv
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.K256.Scalar
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Spec.K256
module SI = Hacl.Spec.K256.Qinv
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module SD = Hacl.Spec.Bignum.Definitions
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
unfold
let linv_ctx (a:LSeq.lseq uint64 0) : Type0 = True
unfold
let linv (a:LSeq.lseq uint64 4) : Type0 =
SD.bn_v #U64 #4 a < S.q
unfold
let refl (a:LSeq.lseq uint64 4{linv a}) : GTot S.qelem =
SD.bn_v #U64 #4 a
inline_for_extraction noextract
let mk_to_k256_scalar_comm_monoid : BE.to_comm_monoid U64 4ul 0ul = {
BE.a_spec = S.qelem;
BE.comm_monoid = SI.nat_mod_comm_monoid;
BE.linv_ctx = linv_ctx;
BE.linv = linv;
BE.refl = refl;
}
inline_for_extraction noextract
val one_mod : BE.lone_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let one_mod ctx one = make_u64_4 one (u64 1, u64 0, u64 0, u64 0)
inline_for_extraction noextract
val mul_mod : BE.lmul_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let mul_mod ctx x y xy = qmul xy x y
inline_for_extraction noextract
val sqr_mod : BE.lsqr_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let sqr_mod ctx x xx = qsqr xx x
inline_for_extraction noextract
let mk_k256_scalar_concrete_ops : BE.concrete_ops U64 4ul 0ul = {
BE.to = mk_to_k256_scalar_comm_monoid;
BE.lone = one_mod;
BE.lmul = mul_mod;
BE.lsqr = sqr_mod;
}
val qsquare_times_in_place (out:qelem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ qe_lt_q h out)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\ qe_lt_q h1 out /\
qas_nat h1 out == SI.qsquare_times (qas_nat h0 out) (v b))
[@CInline]
let qsquare_times_in_place out b =
let h0 = ST.get () in
SE.exp_pow2_lemma SI.mk_nat_mod_concrete_ops (qas_nat h0 out) (v b);
BE.lexp_pow2_in_place 4ul 0ul mk_k256_scalar_concrete_ops (null uint64) out b
val qsquare_times (out a:qelem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ live h a /\ disjoint out a /\
qe_lt_q h a)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\ qe_lt_q h1 a /\
qas_nat h1 out == SI.qsquare_times (qas_nat h0 a) (v b))
[@CInline]
let qsquare_times out a b =
let h0 = ST.get () in
SE.exp_pow2_lemma SI.mk_nat_mod_concrete_ops (qas_nat h0 a) (v b);
BE.lexp_pow2 4ul 0ul mk_k256_scalar_concrete_ops (null uint64) a b out
inline_for_extraction noextract
val qinv1 (f x_10 x_11 x_101 x_111 x_1001 x_1011 x_1101:qelem) : Stack unit
(requires fun h ->
live h f /\ live h x_10 /\ live h x_11 /\ live h x_101 /\
live h x_111 /\ live h x_1001 /\ live h x_1011 /\ live h x_1101 /\
disjoint f x_10 /\ disjoint f x_11 /\ disjoint f x_101 /\
disjoint f x_111 /\ disjoint f x_1001 /\ disjoint f x_1011 /\
disjoint f x_1101 /\ disjoint x_10 x_11 /\ disjoint x_10 x_101 /\
disjoint x_10 x_111 /\ disjoint x_10 x_1001 /\ disjoint x_10 x_1011 /\
disjoint x_10 x_1101 /\ disjoint x_11 x_101 /\ disjoint x_11 x_111 /\
disjoint x_11 x_1001 /\ disjoint x_11 x_1011 /\ disjoint x_11 x_1101 /\
disjoint x_101 x_111 /\ disjoint x_101 x_1001 /\ disjoint x_101 x_1011 /\
disjoint x_101 x_1101 /\ disjoint x_111 x_1001 /\ disjoint x_111 x_1011 /\
disjoint x_111 x_1101 /\ disjoint x_1001 x_1011 /\ disjoint x_1001 x_1101 /\
disjoint x_1011 x_1101 /\ qe_lt_q h f)
(ensures fun h0 _ h1 ->
modifies (loc x_10 |+| loc x_11 |+| loc x_101 |+|
loc x_111 |+| loc x_1001 |+| loc x_1011 |+| loc x_1101) h0 h1 /\
(let _x_10 = SI.qsquare_times (qas_nat h0 f) 1 in
let _x_11 = S.qmul _x_10 (qas_nat h0 f) in
let _x_101 = S.qmul _x_10 _x_11 in
let _x_111 = S.qmul _x_10 _x_101 in
let _x_1001 = S.qmul _x_10 _x_111 in
let _x_1011 = S.qmul _x_10 _x_1001 in
let _x_1101 = S.qmul _x_10 _x_1011 in
qas_nat h1 x_10 == _x_10 /\ qe_lt_q h1 x_10 /\
qas_nat h1 x_11 == _x_11 /\ qe_lt_q h1 x_11 /\
qas_nat h1 x_101 == _x_101 /\ qe_lt_q h1 x_101 /\
qas_nat h1 x_111 == _x_111 /\ qe_lt_q h1 x_111 /\
qas_nat h1 x_1001 == _x_1001 /\ qe_lt_q h1 x_1001 /\
qas_nat h1 x_1011 == _x_1011 /\ qe_lt_q h1 x_1011 /\
qas_nat h1 x_1101 == _x_1101 /\ qe_lt_q h1 x_1101)) | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.K256.Qinv.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.K256.Scalar.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.K256.Qinv.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "SD"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Qinv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.K256.Scalar",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
f: Hacl.K256.Scalar.qelem ->
x_10: Hacl.K256.Scalar.qelem ->
x_11: Hacl.K256.Scalar.qelem ->
x_101: Hacl.K256.Scalar.qelem ->
x_111: Hacl.K256.Scalar.qelem ->
x_1001: Hacl.K256.Scalar.qelem ->
x_1011: Hacl.K256.Scalar.qelem ->
x_1101: Hacl.K256.Scalar.qelem
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.K256.Scalar.qelem",
"Prims._assert",
"Prims.eq2",
"Prims.nat",
"Hacl.K256.Scalar.qas_nat",
"Spec.K256.PointOps.qmul",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Hacl.K256.Scalar.qmul",
"Hacl.Spec.K256.Qinv.qsquare_times",
"Hacl.Impl.K256.Qinv.qsquare_times",
"FStar.UInt32.__uint_to_t"
] | [] | false | true | false | false | false | let qinv1 f x_10 x_11 x_101 x_111 x_1001 x_1011 x_1101 =
| let h0 = ST.get () in
qsquare_times x_10 f 1ul;
let h1 = ST.get () in
assert (qas_nat h1 x_10 == SI.qsquare_times (qas_nat h0 f) 1);
qmul x_11 x_10 f;
let h2 = ST.get () in
assert (qas_nat h2 x_11 == S.qmul (qas_nat h1 x_10) (qas_nat h0 f));
qmul x_101 x_10 x_11;
let h3 = ST.get () in
assert (qas_nat h3 x_101 == S.qmul (qas_nat h1 x_10) (qas_nat h2 x_11));
qmul x_111 x_10 x_101;
let h4 = ST.get () in
assert (qas_nat h4 x_111 == S.qmul (qas_nat h1 x_10) (qas_nat h3 x_101));
qmul x_1001 x_10 x_111;
let h5 = ST.get () in
assert (qas_nat h5 x_1001 == S.qmul (qas_nat h1 x_10) (qas_nat h4 x_111));
qmul x_1011 x_10 x_1001;
let h6 = ST.get () in
assert (qas_nat h6 x_1011 == S.qmul (qas_nat h1 x_10) (qas_nat h5 x_1001));
qmul x_1101 x_10 x_1011;
let h7 = ST.get () in
assert (qas_nat h7 x_1101 == S.qmul (qas_nat h1 x_10) (qas_nat h6 x_1011)) | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.bn_mod_pow2 | val bn_mod_pow2: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} -> lbignum t i | val bn_mod_pow2: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} -> lbignum t i | let bn_mod_pow2 #t #aLen a i = sub a 0 i | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 40,
"end_line": 205,
"start_col": 0,
"start_line": 205
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2)
let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2)
val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t
let bn_get_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[i] j
val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j))
let bn_get_ith_bit_aux_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = b.[i] >>. size j in
calc (==) {
v b.[i] / pow2 j;
(==) { bn_eval_index b i }
(bn_v b / pow2 (pbits * i) % pow2 pbits) / pow2 j;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b / pow2 (pbits * i)) j pbits }
(bn_v b / pow2 (pbits * i) / pow2 j) % pow2 (pbits - j);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b) (pow2 (pbits * i)) (pow2 j) }
(bn_v b / (pow2 (pbits * i) * pow2 j)) % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_plus (pbits * i) j }
(bn_v b / pow2 (pbits * i + j)) % pow2 (pbits - j);
(==) { Math.Lemmas.euclidean_div_axiom ind pbits }
(bn_v b / pow2 ind) % pow2 (pbits - j);
};
assert (v res == (bn_v b / pow2 ind) % pow2 (pbits - j))
val bn_get_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} ->
Lemma (v (bn_get_ith_bit b i) == (bn_v b / pow2 i % 2))
let bn_get_ith_bit_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = limb_get_ith_bit b.[i] j in
limb_get_ith_bit_lemma b.[i] j;
calc (==) {
v b.[i] / pow2 j % 2;
(==) { bn_get_ith_bit_aux_lemma b ind }
(bn_v b / pow2 ind) % pow2 (pbits - j) % 2;
(==) { assert_norm (pow2 1 = 2);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 ind) 1 (pbits - j) }
(bn_v b / pow2 ind) % 2;
};
assert (v res == bn_v b / pow2 ind % 2)
val bn_set_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> lbignum t len
let bn_set_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
let inp = input.[i] <- input.[i] |. (uint #t 1 <<. size j) in
inp
val bn_set_ith_bit_lemma_aux: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a + b * pow2 c < pow2 (c + d) /\ a < pow2 c)
(ensures b < pow2 d)
let bn_set_ith_bit_lemma_aux a b c d =
Math.Lemmas.lemma_div_lt_nat (a + b * pow2 c) (c + d) c;
assert ((a + b * pow2 c) / pow2 c < pow2 d);
Math.Lemmas.lemma_div_plus a b (pow2 c);
assert (a / pow2 c + b < pow2 d);
Math.Lemmas.small_division_lemma_1 a (pow2 c)
val bn_lt_pow2_index_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} -> Lemma
(requires bn_v b < pow2 ind)
(ensures (let i = ind / bits t in v b.[i] < pow2 (ind % bits t) /\
bn_v b == bn_v (slice b 0 i) + pow2 (i * bits t) * v b.[i] /\
bn_v (slice b (i + 1) len) = 0))
let bn_lt_pow2_index_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
Math.Lemmas.euclidean_division_definition ind (pbits);
assert (bn_v b < pow2 (i * pbits + j));
Math.Lemmas.pow2_lt_compat (i * pbits + pbits) (i * pbits + j);
assert (bn_v b < pow2 (i * pbits + pbits));
bn_eval_split_i #t #len b (i + 1);
bn_eval_bound (slice b 0 (i + 1)) (i + 1);
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 (i + 1))) (bn_v (slice b (i + 1) len)) (pbits * (i + 1)) 0;
assert (bn_v b == bn_v (slice b 0 (i + 1)));
bn_eval_split_i #t #(i + 1) (slice b 0 (i + 1)) i;
bn_eval1 (slice b i (i + 1));
assert (bn_v b == bn_v (slice b 0 i) + pow2 (i * pbits) * v b.[i]);
bn_eval_bound #t #i (slice b 0 i) i;
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 i)) (v b.[i]) (i * pbits) j;
assert (v b.[i] < pow2 j)
val bn_set_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> Lemma
(requires bn_v b < pow2 i)
(ensures bn_v (bn_set_ith_bit b i) == bn_v b + pow2 i)
let bn_set_ith_bit_lemma #t #len input ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
bn_lt_pow2_index_lemma #t #len input ind;
assert (v input.[i] < pow2 j);
let b = uint #t 1 <<. size j in
let inp = input.[i] <- input.[i] |. b in
FStar.Math.Lemmas.pow2_lt_compat pbits j;
FStar.Math.Lemmas.modulo_lemma (pow2 j) (pow2 pbits);
assert (v b == pow2 j);
logor_disjoint (input.[i]) b j;
assert (v inp.[i] == v input.[i] + v b);
calc (==) {
bn_v inp;
(==) { bn_eval_split_i #t #len inp (i + 1);
bn_eval_extensionality_j (slice inp (i + 1) len) (slice input (i + 1) len) (len - i - 1) }
bn_v (slice inp 0 (i + 1));
(==) { bn_eval_split_i #t #(i + 1) (slice inp 0 (i + 1)) i }
bn_v (slice inp 0 i) + pow2 (i * pbits) * bn_v (slice inp i (i + 1));
(==) { bn_eval1 (slice inp i (i + 1)) }
bn_v (slice inp 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { bn_eval_extensionality_j input inp i }
bn_v (slice input 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { }
bn_v (slice input 0 i) + pow2 (i * pbits) * (v input.[i] + v b);
(==) { Math.Lemmas.distributivity_add_right (pow2 (i * pbits)) (v input.[i]) (v b) }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 (i * pbits) * v b;
(==) { Math.Lemmas.pow2_plus (i * pbits) j; Math.Lemmas.euclidean_division_definition ind pbits }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 ind;
(==) { }
bn_v input + pow2 ind;
}
///
/// % pow2 and / pow2
///
val bn_div_pow2: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i <= len} -> lbignum t (len - i)
let bn_div_pow2 #t #len b i =
slice b i len
val bn_div_pow2_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i < len} ->
Lemma (bn_v (bn_div_pow2 b i) == bn_v b / pow2 (bits t * i))
let bn_div_pow2_lemma #t #len c i =
let pbits = bits t in
calc (==) {
bn_v c / pow2 (pbits * i);
(==) { bn_eval_split_i c i }
(bn_v (slice c 0 i) + pow2 (pbits * i) * bn_v (slice c i len)) / pow2 (pbits * i);
(==) { Math.Lemmas.division_addition_lemma (bn_v (slice c 0 i)) (pow2 (pbits * i)) (bn_v (slice c i len)) }
bn_v (slice c 0 i) / pow2 (pbits * i) + bn_v (slice c i len);
(==) { bn_eval_bound (slice c 0 i) i; Math.Lemmas.small_division_lemma_1 (bn_v (slice c 0 i)) (pow2 (pbits * i)) }
bn_v (slice c i len);
};
assert (bn_v (slice c i len) == bn_v c / pow2 (pbits * i)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> i: Prims.nat{i <= aLen}
-> Hacl.Spec.Bignum.Definitions.lbignum t i | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.Sequence.sub",
"Hacl.Spec.Bignum.Definitions.limb"
] | [] | false | false | false | false | false | let bn_mod_pow2 #t #aLen a i =
| sub a 0 i | false |
Hacl.Impl.K256.Qinv.fst | Hacl.Impl.K256.Qinv.qinv2 | val qinv2 (x_11 x_1011 x_1101 x6 x8 x14: qelem) : Stack unit
(requires fun h ->
live h x_11 /\ live h x_1011 /\ live h x_1101 /\
live h x6 /\ live h x8 /\ live h x14 /\
disjoint x_11 x6 /\ disjoint x_11 x8 /\ disjoint x_11 x14 /\
disjoint x_1011 x6 /\ disjoint x_1011 x8 /\ disjoint x_1011 x14 /\
disjoint x_1101 x6 /\ disjoint x_1101 x8 /\ disjoint x_1101 x14 /\
disjoint x6 x8 /\ disjoint x6 x14 /\ disjoint x8 x14 /\
qe_lt_q h x_11 /\ qe_lt_q h x_1011 /\ qe_lt_q h x_1101)
(ensures fun h0 _ h1 -> modifies (loc x6 |+| loc x8 |+| loc x14) h0 h1 /\
(let _x6 = S.qmul (SI.qsquare_times (qas_nat h0 x_1101) 2) (qas_nat h0 x_1011) in
let _x8 = S.qmul (SI.qsquare_times _x6 2) (qas_nat h0 x_11) in
let _x14 = S.qmul (SI.qsquare_times _x8 6) _x6 in
qas_nat h1 x6 == _x6 /\ qe_lt_q h1 x6 /\
qas_nat h1 x8 == _x8 /\ qe_lt_q h1 x8 /\
qas_nat h1 x14 == _x14 /\ qe_lt_q h1 x14)) | val qinv2 (x_11 x_1011 x_1101 x6 x8 x14: qelem) : Stack unit
(requires fun h ->
live h x_11 /\ live h x_1011 /\ live h x_1101 /\
live h x6 /\ live h x8 /\ live h x14 /\
disjoint x_11 x6 /\ disjoint x_11 x8 /\ disjoint x_11 x14 /\
disjoint x_1011 x6 /\ disjoint x_1011 x8 /\ disjoint x_1011 x14 /\
disjoint x_1101 x6 /\ disjoint x_1101 x8 /\ disjoint x_1101 x14 /\
disjoint x6 x8 /\ disjoint x6 x14 /\ disjoint x8 x14 /\
qe_lt_q h x_11 /\ qe_lt_q h x_1011 /\ qe_lt_q h x_1101)
(ensures fun h0 _ h1 -> modifies (loc x6 |+| loc x8 |+| loc x14) h0 h1 /\
(let _x6 = S.qmul (SI.qsquare_times (qas_nat h0 x_1101) 2) (qas_nat h0 x_1011) in
let _x8 = S.qmul (SI.qsquare_times _x6 2) (qas_nat h0 x_11) in
let _x14 = S.qmul (SI.qsquare_times _x8 6) _x6 in
qas_nat h1 x6 == _x6 /\ qe_lt_q h1 x6 /\
qas_nat h1 x8 == _x8 /\ qe_lt_q h1 x8 /\
qas_nat h1 x14 == _x14 /\ qe_lt_q h1 x14)) | let qinv2 x_11 x_1011 x_1101 x6 x8 x14 =
let h0 = ST.get () in
qsquare_times x6 x_1101 2ul;
qmul x6 x6 x_1011;
let h1 = ST.get () in
assert (qas_nat h1 x6 == S.qmul (SI.qsquare_times (qas_nat h0 x_1101) 2) (qas_nat h0 x_1011));
qsquare_times x8 x6 2ul;
qmul x8 x8 x_11;
let h2 = ST.get () in
assert (qas_nat h2 x8 == S.qmul (SI.qsquare_times (qas_nat h1 x6) 2) (qas_nat h0 x_11));
qsquare_times x14 x8 6ul;
qmul x14 x14 x6;
let h3 = ST.get () in
assert (qas_nat h3 x14 == S.qmul (SI.qsquare_times (qas_nat h2 x8) 6) (qas_nat h1 x6)) | {
"file_name": "code/k256/Hacl.Impl.K256.Qinv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 88,
"end_line": 193,
"start_col": 0,
"start_line": 178
} | module Hacl.Impl.K256.Qinv
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.K256.Scalar
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Spec.K256
module SI = Hacl.Spec.K256.Qinv
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module SD = Hacl.Spec.Bignum.Definitions
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
unfold
let linv_ctx (a:LSeq.lseq uint64 0) : Type0 = True
unfold
let linv (a:LSeq.lseq uint64 4) : Type0 =
SD.bn_v #U64 #4 a < S.q
unfold
let refl (a:LSeq.lseq uint64 4{linv a}) : GTot S.qelem =
SD.bn_v #U64 #4 a
inline_for_extraction noextract
let mk_to_k256_scalar_comm_monoid : BE.to_comm_monoid U64 4ul 0ul = {
BE.a_spec = S.qelem;
BE.comm_monoid = SI.nat_mod_comm_monoid;
BE.linv_ctx = linv_ctx;
BE.linv = linv;
BE.refl = refl;
}
inline_for_extraction noextract
val one_mod : BE.lone_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let one_mod ctx one = make_u64_4 one (u64 1, u64 0, u64 0, u64 0)
inline_for_extraction noextract
val mul_mod : BE.lmul_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let mul_mod ctx x y xy = qmul xy x y
inline_for_extraction noextract
val sqr_mod : BE.lsqr_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let sqr_mod ctx x xx = qsqr xx x
inline_for_extraction noextract
let mk_k256_scalar_concrete_ops : BE.concrete_ops U64 4ul 0ul = {
BE.to = mk_to_k256_scalar_comm_monoid;
BE.lone = one_mod;
BE.lmul = mul_mod;
BE.lsqr = sqr_mod;
}
val qsquare_times_in_place (out:qelem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ qe_lt_q h out)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\ qe_lt_q h1 out /\
qas_nat h1 out == SI.qsquare_times (qas_nat h0 out) (v b))
[@CInline]
let qsquare_times_in_place out b =
let h0 = ST.get () in
SE.exp_pow2_lemma SI.mk_nat_mod_concrete_ops (qas_nat h0 out) (v b);
BE.lexp_pow2_in_place 4ul 0ul mk_k256_scalar_concrete_ops (null uint64) out b
val qsquare_times (out a:qelem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ live h a /\ disjoint out a /\
qe_lt_q h a)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\ qe_lt_q h1 a /\
qas_nat h1 out == SI.qsquare_times (qas_nat h0 a) (v b))
[@CInline]
let qsquare_times out a b =
let h0 = ST.get () in
SE.exp_pow2_lemma SI.mk_nat_mod_concrete_ops (qas_nat h0 a) (v b);
BE.lexp_pow2 4ul 0ul mk_k256_scalar_concrete_ops (null uint64) a b out
inline_for_extraction noextract
val qinv1 (f x_10 x_11 x_101 x_111 x_1001 x_1011 x_1101:qelem) : Stack unit
(requires fun h ->
live h f /\ live h x_10 /\ live h x_11 /\ live h x_101 /\
live h x_111 /\ live h x_1001 /\ live h x_1011 /\ live h x_1101 /\
disjoint f x_10 /\ disjoint f x_11 /\ disjoint f x_101 /\
disjoint f x_111 /\ disjoint f x_1001 /\ disjoint f x_1011 /\
disjoint f x_1101 /\ disjoint x_10 x_11 /\ disjoint x_10 x_101 /\
disjoint x_10 x_111 /\ disjoint x_10 x_1001 /\ disjoint x_10 x_1011 /\
disjoint x_10 x_1101 /\ disjoint x_11 x_101 /\ disjoint x_11 x_111 /\
disjoint x_11 x_1001 /\ disjoint x_11 x_1011 /\ disjoint x_11 x_1101 /\
disjoint x_101 x_111 /\ disjoint x_101 x_1001 /\ disjoint x_101 x_1011 /\
disjoint x_101 x_1101 /\ disjoint x_111 x_1001 /\ disjoint x_111 x_1011 /\
disjoint x_111 x_1101 /\ disjoint x_1001 x_1011 /\ disjoint x_1001 x_1101 /\
disjoint x_1011 x_1101 /\ qe_lt_q h f)
(ensures fun h0 _ h1 ->
modifies (loc x_10 |+| loc x_11 |+| loc x_101 |+|
loc x_111 |+| loc x_1001 |+| loc x_1011 |+| loc x_1101) h0 h1 /\
(let _x_10 = SI.qsquare_times (qas_nat h0 f) 1 in
let _x_11 = S.qmul _x_10 (qas_nat h0 f) in
let _x_101 = S.qmul _x_10 _x_11 in
let _x_111 = S.qmul _x_10 _x_101 in
let _x_1001 = S.qmul _x_10 _x_111 in
let _x_1011 = S.qmul _x_10 _x_1001 in
let _x_1101 = S.qmul _x_10 _x_1011 in
qas_nat h1 x_10 == _x_10 /\ qe_lt_q h1 x_10 /\
qas_nat h1 x_11 == _x_11 /\ qe_lt_q h1 x_11 /\
qas_nat h1 x_101 == _x_101 /\ qe_lt_q h1 x_101 /\
qas_nat h1 x_111 == _x_111 /\ qe_lt_q h1 x_111 /\
qas_nat h1 x_1001 == _x_1001 /\ qe_lt_q h1 x_1001 /\
qas_nat h1 x_1011 == _x_1011 /\ qe_lt_q h1 x_1011 /\
qas_nat h1 x_1101 == _x_1101 /\ qe_lt_q h1 x_1101))
let qinv1 f x_10 x_11 x_101 x_111 x_1001 x_1011 x_1101 =
let h0 = ST.get () in
qsquare_times x_10 f 1ul;
let h1 = ST.get () in
assert (qas_nat h1 x_10 == SI.qsquare_times (qas_nat h0 f) 1);
qmul x_11 x_10 f;
let h2 = ST.get () in
assert (qas_nat h2 x_11 == S.qmul (qas_nat h1 x_10) (qas_nat h0 f));
qmul x_101 x_10 x_11;
let h3 = ST.get () in
assert (qas_nat h3 x_101 == S.qmul (qas_nat h1 x_10) (qas_nat h2 x_11));
qmul x_111 x_10 x_101;
let h4 = ST.get () in
assert (qas_nat h4 x_111 == S.qmul (qas_nat h1 x_10) (qas_nat h3 x_101));
qmul x_1001 x_10 x_111;
let h5 = ST.get () in
assert (qas_nat h5 x_1001 == S.qmul (qas_nat h1 x_10) (qas_nat h4 x_111));
qmul x_1011 x_10 x_1001;
let h6 = ST.get () in
assert (qas_nat h6 x_1011 == S.qmul (qas_nat h1 x_10) (qas_nat h5 x_1001));
qmul x_1101 x_10 x_1011;
let h7 = ST.get () in
assert (qas_nat h7 x_1101 == S.qmul (qas_nat h1 x_10) (qas_nat h6 x_1011))
inline_for_extraction noextract
val qinv2 (x_11 x_1011 x_1101 x6 x8 x14: qelem) : Stack unit
(requires fun h ->
live h x_11 /\ live h x_1011 /\ live h x_1101 /\
live h x6 /\ live h x8 /\ live h x14 /\
disjoint x_11 x6 /\ disjoint x_11 x8 /\ disjoint x_11 x14 /\
disjoint x_1011 x6 /\ disjoint x_1011 x8 /\ disjoint x_1011 x14 /\
disjoint x_1101 x6 /\ disjoint x_1101 x8 /\ disjoint x_1101 x14 /\
disjoint x6 x8 /\ disjoint x6 x14 /\ disjoint x8 x14 /\
qe_lt_q h x_11 /\ qe_lt_q h x_1011 /\ qe_lt_q h x_1101)
(ensures fun h0 _ h1 -> modifies (loc x6 |+| loc x8 |+| loc x14) h0 h1 /\
(let _x6 = S.qmul (SI.qsquare_times (qas_nat h0 x_1101) 2) (qas_nat h0 x_1011) in
let _x8 = S.qmul (SI.qsquare_times _x6 2) (qas_nat h0 x_11) in
let _x14 = S.qmul (SI.qsquare_times _x8 6) _x6 in
qas_nat h1 x6 == _x6 /\ qe_lt_q h1 x6 /\
qas_nat h1 x8 == _x8 /\ qe_lt_q h1 x8 /\
qas_nat h1 x14 == _x14 /\ qe_lt_q h1 x14)) | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.K256.Qinv.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.K256.Scalar.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.K256.Qinv.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "SD"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Qinv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.K256.Scalar",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
x_11: Hacl.K256.Scalar.qelem ->
x_1011: Hacl.K256.Scalar.qelem ->
x_1101: Hacl.K256.Scalar.qelem ->
x6: Hacl.K256.Scalar.qelem ->
x8: Hacl.K256.Scalar.qelem ->
x14: Hacl.K256.Scalar.qelem
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.K256.Scalar.qelem",
"Prims._assert",
"Prims.eq2",
"Prims.nat",
"Hacl.K256.Scalar.qas_nat",
"Spec.K256.PointOps.qmul",
"Hacl.Spec.K256.Qinv.qsquare_times",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Hacl.K256.Scalar.qmul",
"Hacl.Impl.K256.Qinv.qsquare_times",
"FStar.UInt32.__uint_to_t"
] | [] | false | true | false | false | false | let qinv2 x_11 x_1011 x_1101 x6 x8 x14 =
| let h0 = ST.get () in
qsquare_times x6 x_1101 2ul;
qmul x6 x6 x_1011;
let h1 = ST.get () in
assert (qas_nat h1 x6 == S.qmul (SI.qsquare_times (qas_nat h0 x_1101) 2) (qas_nat h0 x_1011));
qsquare_times x8 x6 2ul;
qmul x8 x8 x_11;
let h2 = ST.get () in
assert (qas_nat h2 x8 == S.qmul (SI.qsquare_times (qas_nat h1 x6) 2) (qas_nat h0 x_11));
qsquare_times x14 x8 6ul;
qmul x14 x14 x6;
let h3 = ST.get () in
assert (qas_nat h3 x14 == S.qmul (SI.qsquare_times (qas_nat h2 x8) 6) (qas_nat h1 x6)) | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.cswap2 | val cswap2:
#t:limb_t
-> #len:size_nat
-> bit:limb t
-> b1:lbignum t len
-> b2:lbignum t len ->
tuple2 (lbignum t len) (lbignum t len) | val cswap2:
#t:limb_t
-> #len:size_nat
-> bit:limb t
-> b1:lbignum t len
-> b2:lbignum t len ->
tuple2 (lbignum t len) (lbignum t len) | let cswap2 #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.repeati len (cswap2_f #t #len mask) (b1, b2) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 52,
"end_line": 278,
"start_col": 0,
"start_line": 276
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2)
let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2)
val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t
let bn_get_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[i] j
val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j))
let bn_get_ith_bit_aux_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = b.[i] >>. size j in
calc (==) {
v b.[i] / pow2 j;
(==) { bn_eval_index b i }
(bn_v b / pow2 (pbits * i) % pow2 pbits) / pow2 j;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b / pow2 (pbits * i)) j pbits }
(bn_v b / pow2 (pbits * i) / pow2 j) % pow2 (pbits - j);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b) (pow2 (pbits * i)) (pow2 j) }
(bn_v b / (pow2 (pbits * i) * pow2 j)) % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_plus (pbits * i) j }
(bn_v b / pow2 (pbits * i + j)) % pow2 (pbits - j);
(==) { Math.Lemmas.euclidean_div_axiom ind pbits }
(bn_v b / pow2 ind) % pow2 (pbits - j);
};
assert (v res == (bn_v b / pow2 ind) % pow2 (pbits - j))
val bn_get_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} ->
Lemma (v (bn_get_ith_bit b i) == (bn_v b / pow2 i % 2))
let bn_get_ith_bit_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = limb_get_ith_bit b.[i] j in
limb_get_ith_bit_lemma b.[i] j;
calc (==) {
v b.[i] / pow2 j % 2;
(==) { bn_get_ith_bit_aux_lemma b ind }
(bn_v b / pow2 ind) % pow2 (pbits - j) % 2;
(==) { assert_norm (pow2 1 = 2);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 ind) 1 (pbits - j) }
(bn_v b / pow2 ind) % 2;
};
assert (v res == bn_v b / pow2 ind % 2)
val bn_set_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> lbignum t len
let bn_set_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
let inp = input.[i] <- input.[i] |. (uint #t 1 <<. size j) in
inp
val bn_set_ith_bit_lemma_aux: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a + b * pow2 c < pow2 (c + d) /\ a < pow2 c)
(ensures b < pow2 d)
let bn_set_ith_bit_lemma_aux a b c d =
Math.Lemmas.lemma_div_lt_nat (a + b * pow2 c) (c + d) c;
assert ((a + b * pow2 c) / pow2 c < pow2 d);
Math.Lemmas.lemma_div_plus a b (pow2 c);
assert (a / pow2 c + b < pow2 d);
Math.Lemmas.small_division_lemma_1 a (pow2 c)
val bn_lt_pow2_index_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} -> Lemma
(requires bn_v b < pow2 ind)
(ensures (let i = ind / bits t in v b.[i] < pow2 (ind % bits t) /\
bn_v b == bn_v (slice b 0 i) + pow2 (i * bits t) * v b.[i] /\
bn_v (slice b (i + 1) len) = 0))
let bn_lt_pow2_index_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
Math.Lemmas.euclidean_division_definition ind (pbits);
assert (bn_v b < pow2 (i * pbits + j));
Math.Lemmas.pow2_lt_compat (i * pbits + pbits) (i * pbits + j);
assert (bn_v b < pow2 (i * pbits + pbits));
bn_eval_split_i #t #len b (i + 1);
bn_eval_bound (slice b 0 (i + 1)) (i + 1);
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 (i + 1))) (bn_v (slice b (i + 1) len)) (pbits * (i + 1)) 0;
assert (bn_v b == bn_v (slice b 0 (i + 1)));
bn_eval_split_i #t #(i + 1) (slice b 0 (i + 1)) i;
bn_eval1 (slice b i (i + 1));
assert (bn_v b == bn_v (slice b 0 i) + pow2 (i * pbits) * v b.[i]);
bn_eval_bound #t #i (slice b 0 i) i;
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 i)) (v b.[i]) (i * pbits) j;
assert (v b.[i] < pow2 j)
val bn_set_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> Lemma
(requires bn_v b < pow2 i)
(ensures bn_v (bn_set_ith_bit b i) == bn_v b + pow2 i)
let bn_set_ith_bit_lemma #t #len input ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
bn_lt_pow2_index_lemma #t #len input ind;
assert (v input.[i] < pow2 j);
let b = uint #t 1 <<. size j in
let inp = input.[i] <- input.[i] |. b in
FStar.Math.Lemmas.pow2_lt_compat pbits j;
FStar.Math.Lemmas.modulo_lemma (pow2 j) (pow2 pbits);
assert (v b == pow2 j);
logor_disjoint (input.[i]) b j;
assert (v inp.[i] == v input.[i] + v b);
calc (==) {
bn_v inp;
(==) { bn_eval_split_i #t #len inp (i + 1);
bn_eval_extensionality_j (slice inp (i + 1) len) (slice input (i + 1) len) (len - i - 1) }
bn_v (slice inp 0 (i + 1));
(==) { bn_eval_split_i #t #(i + 1) (slice inp 0 (i + 1)) i }
bn_v (slice inp 0 i) + pow2 (i * pbits) * bn_v (slice inp i (i + 1));
(==) { bn_eval1 (slice inp i (i + 1)) }
bn_v (slice inp 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { bn_eval_extensionality_j input inp i }
bn_v (slice input 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { }
bn_v (slice input 0 i) + pow2 (i * pbits) * (v input.[i] + v b);
(==) { Math.Lemmas.distributivity_add_right (pow2 (i * pbits)) (v input.[i]) (v b) }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 (i * pbits) * v b;
(==) { Math.Lemmas.pow2_plus (i * pbits) j; Math.Lemmas.euclidean_division_definition ind pbits }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 ind;
(==) { }
bn_v input + pow2 ind;
}
///
/// % pow2 and / pow2
///
val bn_div_pow2: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i <= len} -> lbignum t (len - i)
let bn_div_pow2 #t #len b i =
slice b i len
val bn_div_pow2_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i < len} ->
Lemma (bn_v (bn_div_pow2 b i) == bn_v b / pow2 (bits t * i))
let bn_div_pow2_lemma #t #len c i =
let pbits = bits t in
calc (==) {
bn_v c / pow2 (pbits * i);
(==) { bn_eval_split_i c i }
(bn_v (slice c 0 i) + pow2 (pbits * i) * bn_v (slice c i len)) / pow2 (pbits * i);
(==) { Math.Lemmas.division_addition_lemma (bn_v (slice c 0 i)) (pow2 (pbits * i)) (bn_v (slice c i len)) }
bn_v (slice c 0 i) / pow2 (pbits * i) + bn_v (slice c i len);
(==) { bn_eval_bound (slice c 0 i) i; Math.Lemmas.small_division_lemma_1 (bn_v (slice c 0 i)) (pow2 (pbits * i)) }
bn_v (slice c i len);
};
assert (bn_v (slice c i len) == bn_v c / pow2 (pbits * i))
val bn_mod_pow2: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} -> lbignum t i
let bn_mod_pow2 #t #aLen a i = sub a 0 i
val bn_mod_pow2_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} ->
Lemma (bn_v (bn_mod_pow2 a i) == bn_v a % pow2 (bits t * i))
let bn_mod_pow2_lemma #t #aLen a i =
let pbits = bits t in
calc (==) {
bn_v a % pow2 (pbits * i);
(==) { bn_eval_split_i a i }
(bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v (slice a i aLen)) % pow2 (pbits * i);
(==) { Math.Lemmas.modulo_addition_lemma (bn_v (slice a 0 i)) (pow2 (pbits * i)) (bn_v (slice a i aLen)) }
(bn_v (slice a 0 i)) % pow2 (pbits * i);
(==) { bn_eval_bound (slice a 0 i) i; Math.Lemmas.small_mod (bn_v (slice a 0 i)) (pow2 (pbits * i)) }
bn_v (slice a 0 i);
}
///
/// Conditional swap
///
//the same as in curve25519
val lemma_cswap2_step:
#t:limb_t
-> bit:limb t{v bit <= 1}
-> p1:limb t
-> p2:limb t ->
Lemma
(let mask = uint #t 0 -. bit in
let dummy = mask &. (p1 ^. p2) in
let p1' = p1 ^. dummy in
let p2' = p2 ^. dummy in
if v bit = 1 then p1' == p2 /\ p2' == p1 else p1' == p1 /\ p2' == p2)
let lemma_cswap2_step #t bit p1 p2 =
let mask = uint #t 0 -. bit in
assert (v bit == 0 ==> v mask == 0);
assert (v bit == 1 ==> v mask == pow2 (bits t) - 1);
let dummy = mask &. (p1 ^. p2) in
logand_lemma mask (p1 ^. p2);
assert (v bit == 1 ==> v dummy == v (p1 ^. p2));
assert (v bit == 0 ==> v dummy == 0);
let p1' = p1 ^. dummy in
assert (v dummy == v (if v bit = 1 then (p1 ^. p2) else uint #t 0));
logxor_lemma p1 p2;
let p2' = p2 ^. dummy in
logxor_lemma p2 p1
val cswap2_f:
#t:limb_t
-> #len:size_nat
-> mask:limb t
-> i:nat{i < len}
-> tuple2 (lbignum t len) (lbignum t len) ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2_f #t #len mask i (p1, p2) =
let dummy = mask &. (p1.[i] ^. p2.[i]) in
let p1 = p1.[i] <- p1.[i] ^. dummy in
let p2 = p2.[i] <- p2.[i] ^. dummy in
(p1, p2)
val cswap2:
#t:limb_t
-> #len:size_nat
-> bit:limb t
-> b1:lbignum t len
-> b2:lbignum t len ->
tuple2 (lbignum t len) (lbignum t len) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
bit: Hacl.Spec.Bignum.Definitions.limb t ->
b1: Hacl.Spec.Bignum.Definitions.lbignum t len ->
b2: Hacl.Spec.Bignum.Definitions.lbignum t len
-> Hacl.Spec.Bignum.Definitions.lbignum t len * Hacl.Spec.Bignum.Definitions.lbignum t len | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Lib.LoopCombinators.repeati",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Lib.cswap2_f",
"FStar.Pervasives.Native.Mktuple2",
"Lib.IntTypes.int_t",
"Lib.IntTypes.SEC",
"Lib.IntTypes.op_Subtraction_Dot",
"Lib.IntTypes.uint"
] | [] | false | false | false | false | false | let cswap2 #t #len bit b1 b2 =
| let mask = uint #t 0 -. bit in
Loops.repeati len (cswap2_f #t #len mask) (b1, b2) | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.bn_get_top_index_f | val bn_get_top_index_f:
#t:limb_t
-> #len:size_nat
-> b:lbignum t len
-> i:nat{i < len}
-> priv:bn_get_top_index_t len i ->
bn_get_top_index_t len (i + 1) | val bn_get_top_index_f:
#t:limb_t
-> #len:size_nat
-> b:lbignum t len
-> i:nat{i < len}
-> priv:bn_get_top_index_t len i ->
bn_get_top_index_t len (i + 1) | let bn_get_top_index_f #t #len b i priv =
let mask = eq_mask b.[i] (zeros t SEC) in
if v mask = 0 then i else priv | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 32,
"end_line": 324,
"start_col": 0,
"start_line": 322
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2)
let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2)
val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t
let bn_get_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[i] j
val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j))
let bn_get_ith_bit_aux_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = b.[i] >>. size j in
calc (==) {
v b.[i] / pow2 j;
(==) { bn_eval_index b i }
(bn_v b / pow2 (pbits * i) % pow2 pbits) / pow2 j;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b / pow2 (pbits * i)) j pbits }
(bn_v b / pow2 (pbits * i) / pow2 j) % pow2 (pbits - j);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b) (pow2 (pbits * i)) (pow2 j) }
(bn_v b / (pow2 (pbits * i) * pow2 j)) % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_plus (pbits * i) j }
(bn_v b / pow2 (pbits * i + j)) % pow2 (pbits - j);
(==) { Math.Lemmas.euclidean_div_axiom ind pbits }
(bn_v b / pow2 ind) % pow2 (pbits - j);
};
assert (v res == (bn_v b / pow2 ind) % pow2 (pbits - j))
val bn_get_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} ->
Lemma (v (bn_get_ith_bit b i) == (bn_v b / pow2 i % 2))
let bn_get_ith_bit_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = limb_get_ith_bit b.[i] j in
limb_get_ith_bit_lemma b.[i] j;
calc (==) {
v b.[i] / pow2 j % 2;
(==) { bn_get_ith_bit_aux_lemma b ind }
(bn_v b / pow2 ind) % pow2 (pbits - j) % 2;
(==) { assert_norm (pow2 1 = 2);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 ind) 1 (pbits - j) }
(bn_v b / pow2 ind) % 2;
};
assert (v res == bn_v b / pow2 ind % 2)
val bn_set_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> lbignum t len
let bn_set_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
let inp = input.[i] <- input.[i] |. (uint #t 1 <<. size j) in
inp
val bn_set_ith_bit_lemma_aux: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a + b * pow2 c < pow2 (c + d) /\ a < pow2 c)
(ensures b < pow2 d)
let bn_set_ith_bit_lemma_aux a b c d =
Math.Lemmas.lemma_div_lt_nat (a + b * pow2 c) (c + d) c;
assert ((a + b * pow2 c) / pow2 c < pow2 d);
Math.Lemmas.lemma_div_plus a b (pow2 c);
assert (a / pow2 c + b < pow2 d);
Math.Lemmas.small_division_lemma_1 a (pow2 c)
val bn_lt_pow2_index_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} -> Lemma
(requires bn_v b < pow2 ind)
(ensures (let i = ind / bits t in v b.[i] < pow2 (ind % bits t) /\
bn_v b == bn_v (slice b 0 i) + pow2 (i * bits t) * v b.[i] /\
bn_v (slice b (i + 1) len) = 0))
let bn_lt_pow2_index_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
Math.Lemmas.euclidean_division_definition ind (pbits);
assert (bn_v b < pow2 (i * pbits + j));
Math.Lemmas.pow2_lt_compat (i * pbits + pbits) (i * pbits + j);
assert (bn_v b < pow2 (i * pbits + pbits));
bn_eval_split_i #t #len b (i + 1);
bn_eval_bound (slice b 0 (i + 1)) (i + 1);
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 (i + 1))) (bn_v (slice b (i + 1) len)) (pbits * (i + 1)) 0;
assert (bn_v b == bn_v (slice b 0 (i + 1)));
bn_eval_split_i #t #(i + 1) (slice b 0 (i + 1)) i;
bn_eval1 (slice b i (i + 1));
assert (bn_v b == bn_v (slice b 0 i) + pow2 (i * pbits) * v b.[i]);
bn_eval_bound #t #i (slice b 0 i) i;
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 i)) (v b.[i]) (i * pbits) j;
assert (v b.[i] < pow2 j)
val bn_set_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> Lemma
(requires bn_v b < pow2 i)
(ensures bn_v (bn_set_ith_bit b i) == bn_v b + pow2 i)
let bn_set_ith_bit_lemma #t #len input ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
bn_lt_pow2_index_lemma #t #len input ind;
assert (v input.[i] < pow2 j);
let b = uint #t 1 <<. size j in
let inp = input.[i] <- input.[i] |. b in
FStar.Math.Lemmas.pow2_lt_compat pbits j;
FStar.Math.Lemmas.modulo_lemma (pow2 j) (pow2 pbits);
assert (v b == pow2 j);
logor_disjoint (input.[i]) b j;
assert (v inp.[i] == v input.[i] + v b);
calc (==) {
bn_v inp;
(==) { bn_eval_split_i #t #len inp (i + 1);
bn_eval_extensionality_j (slice inp (i + 1) len) (slice input (i + 1) len) (len - i - 1) }
bn_v (slice inp 0 (i + 1));
(==) { bn_eval_split_i #t #(i + 1) (slice inp 0 (i + 1)) i }
bn_v (slice inp 0 i) + pow2 (i * pbits) * bn_v (slice inp i (i + 1));
(==) { bn_eval1 (slice inp i (i + 1)) }
bn_v (slice inp 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { bn_eval_extensionality_j input inp i }
bn_v (slice input 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { }
bn_v (slice input 0 i) + pow2 (i * pbits) * (v input.[i] + v b);
(==) { Math.Lemmas.distributivity_add_right (pow2 (i * pbits)) (v input.[i]) (v b) }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 (i * pbits) * v b;
(==) { Math.Lemmas.pow2_plus (i * pbits) j; Math.Lemmas.euclidean_division_definition ind pbits }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 ind;
(==) { }
bn_v input + pow2 ind;
}
///
/// % pow2 and / pow2
///
val bn_div_pow2: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i <= len} -> lbignum t (len - i)
let bn_div_pow2 #t #len b i =
slice b i len
val bn_div_pow2_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i < len} ->
Lemma (bn_v (bn_div_pow2 b i) == bn_v b / pow2 (bits t * i))
let bn_div_pow2_lemma #t #len c i =
let pbits = bits t in
calc (==) {
bn_v c / pow2 (pbits * i);
(==) { bn_eval_split_i c i }
(bn_v (slice c 0 i) + pow2 (pbits * i) * bn_v (slice c i len)) / pow2 (pbits * i);
(==) { Math.Lemmas.division_addition_lemma (bn_v (slice c 0 i)) (pow2 (pbits * i)) (bn_v (slice c i len)) }
bn_v (slice c 0 i) / pow2 (pbits * i) + bn_v (slice c i len);
(==) { bn_eval_bound (slice c 0 i) i; Math.Lemmas.small_division_lemma_1 (bn_v (slice c 0 i)) (pow2 (pbits * i)) }
bn_v (slice c i len);
};
assert (bn_v (slice c i len) == bn_v c / pow2 (pbits * i))
val bn_mod_pow2: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} -> lbignum t i
let bn_mod_pow2 #t #aLen a i = sub a 0 i
val bn_mod_pow2_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} ->
Lemma (bn_v (bn_mod_pow2 a i) == bn_v a % pow2 (bits t * i))
let bn_mod_pow2_lemma #t #aLen a i =
let pbits = bits t in
calc (==) {
bn_v a % pow2 (pbits * i);
(==) { bn_eval_split_i a i }
(bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v (slice a i aLen)) % pow2 (pbits * i);
(==) { Math.Lemmas.modulo_addition_lemma (bn_v (slice a 0 i)) (pow2 (pbits * i)) (bn_v (slice a i aLen)) }
(bn_v (slice a 0 i)) % pow2 (pbits * i);
(==) { bn_eval_bound (slice a 0 i) i; Math.Lemmas.small_mod (bn_v (slice a 0 i)) (pow2 (pbits * i)) }
bn_v (slice a 0 i);
}
///
/// Conditional swap
///
//the same as in curve25519
val lemma_cswap2_step:
#t:limb_t
-> bit:limb t{v bit <= 1}
-> p1:limb t
-> p2:limb t ->
Lemma
(let mask = uint #t 0 -. bit in
let dummy = mask &. (p1 ^. p2) in
let p1' = p1 ^. dummy in
let p2' = p2 ^. dummy in
if v bit = 1 then p1' == p2 /\ p2' == p1 else p1' == p1 /\ p2' == p2)
let lemma_cswap2_step #t bit p1 p2 =
let mask = uint #t 0 -. bit in
assert (v bit == 0 ==> v mask == 0);
assert (v bit == 1 ==> v mask == pow2 (bits t) - 1);
let dummy = mask &. (p1 ^. p2) in
logand_lemma mask (p1 ^. p2);
assert (v bit == 1 ==> v dummy == v (p1 ^. p2));
assert (v bit == 0 ==> v dummy == 0);
let p1' = p1 ^. dummy in
assert (v dummy == v (if v bit = 1 then (p1 ^. p2) else uint #t 0));
logxor_lemma p1 p2;
let p2' = p2 ^. dummy in
logxor_lemma p2 p1
val cswap2_f:
#t:limb_t
-> #len:size_nat
-> mask:limb t
-> i:nat{i < len}
-> tuple2 (lbignum t len) (lbignum t len) ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2_f #t #len mask i (p1, p2) =
let dummy = mask &. (p1.[i] ^. p2.[i]) in
let p1 = p1.[i] <- p1.[i] ^. dummy in
let p2 = p2.[i] <- p2.[i] ^. dummy in
(p1, p2)
val cswap2:
#t:limb_t
-> #len:size_nat
-> bit:limb t
-> b1:lbignum t len
-> b2:lbignum t len ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2 #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.repeati len (cswap2_f #t #len mask) (b1, b2)
val cswap2_lemma:
#t:limb_t
-> #len:size_nat
-> bit:limb t{v bit <= 1}
-> b1:lbignum t len
-> b2:lbignum t len ->
Lemma (let (p1, p2) = cswap2 bit b1 b2 in
(if v bit = 1 then p1 == b2 /\ p2 == b1 else p1 == b1 /\ p2 == b2))
let cswap2_lemma #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.eq_repeati0 len (cswap2_f #t #len mask) (b1, b2);
let (p1, p2) =
Loops.repeati_inductive #(tuple2 (lbignum t len) (lbignum t len)) len
(fun i (p1, p2) ->
(p1, p2) == Loops.repeati i (cswap2_f #t #len mask) (b1, b2) /\
(forall (k:nat{k < i}).
(if v bit = 1 then p1.[k] == b2.[k] /\ p2.[k] == b1.[k] else p1.[k] == b1.[k] /\ p2.[k] == b2.[k])) /\
(forall (k:nat{i <= k /\ k < len}). p1.[k] == b1.[k] /\ p2.[k] == b2.[k]))
(fun i (p1, p2) ->
Loops.unfold_repeati (i + 1) (cswap2_f #t #len mask) (b1, b2) i;
lemma_cswap2_step bit p1.[i] p2.[i];
cswap2_f #t #len mask i (p1, p2)) (b1, b2) in
assert (if v bit = 1 then (eq_intro p1 b2; p1 == b2) else (eq_intro p1 b1; p1 == b1));
assert (if v bit = 1 then (eq_intro p2 b1; p2 == b1) else (eq_intro p2 b2; p2 == b2));
//eq_intro p1 (if v bit = 1 then b2 else b1);
//eq_intro p2 (if v bit = 1 then b1 else b2);
()
let bn_get_top_index_t (len:size_nat) (i:nat{i <= len}) = x:nat{x < len}
val bn_get_top_index_f:
#t:limb_t
-> #len:size_nat
-> b:lbignum t len
-> i:nat{i < len}
-> priv:bn_get_top_index_t len i ->
bn_get_top_index_t len (i + 1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: Hacl.Spec.Bignum.Definitions.lbignum t len ->
i: Prims.nat{i < len} ->
priv: Hacl.Spec.Bignum.Lib.bn_get_top_index_t len i
-> Hacl.Spec.Bignum.Lib.bn_get_top_index_t len (i + 1) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Lib.bn_get_top_index_t",
"Prims.op_Equality",
"Prims.int",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims.bool",
"Prims.op_Addition",
"Lib.IntTypes.int_t",
"Lib.IntTypes.eq_mask",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Bignum.Definitions.limb",
"Lib.IntTypes.zeros"
] | [] | false | false | false | false | false | let bn_get_top_index_f #t #len b i priv =
| let mask = eq_mask b.[ i ] (zeros t SEC) in
if v mask = 0 then i else priv | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.bn_get_top_index | val bn_get_top_index: #t:limb_t -> #len:size_pos -> b:lbignum t len -> res:size_nat{res < len} | val bn_get_top_index: #t:limb_t -> #len:size_pos -> b:lbignum t len -> res:size_nat{res < len} | let bn_get_top_index #t #len b =
Loops.repeat_gen len (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0 | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 80,
"end_line": 328,
"start_col": 0,
"start_line": 327
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2)
let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2)
val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t
let bn_get_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[i] j
val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j))
let bn_get_ith_bit_aux_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = b.[i] >>. size j in
calc (==) {
v b.[i] / pow2 j;
(==) { bn_eval_index b i }
(bn_v b / pow2 (pbits * i) % pow2 pbits) / pow2 j;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b / pow2 (pbits * i)) j pbits }
(bn_v b / pow2 (pbits * i) / pow2 j) % pow2 (pbits - j);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b) (pow2 (pbits * i)) (pow2 j) }
(bn_v b / (pow2 (pbits * i) * pow2 j)) % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_plus (pbits * i) j }
(bn_v b / pow2 (pbits * i + j)) % pow2 (pbits - j);
(==) { Math.Lemmas.euclidean_div_axiom ind pbits }
(bn_v b / pow2 ind) % pow2 (pbits - j);
};
assert (v res == (bn_v b / pow2 ind) % pow2 (pbits - j))
val bn_get_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} ->
Lemma (v (bn_get_ith_bit b i) == (bn_v b / pow2 i % 2))
let bn_get_ith_bit_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = limb_get_ith_bit b.[i] j in
limb_get_ith_bit_lemma b.[i] j;
calc (==) {
v b.[i] / pow2 j % 2;
(==) { bn_get_ith_bit_aux_lemma b ind }
(bn_v b / pow2 ind) % pow2 (pbits - j) % 2;
(==) { assert_norm (pow2 1 = 2);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 ind) 1 (pbits - j) }
(bn_v b / pow2 ind) % 2;
};
assert (v res == bn_v b / pow2 ind % 2)
val bn_set_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> lbignum t len
let bn_set_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
let inp = input.[i] <- input.[i] |. (uint #t 1 <<. size j) in
inp
val bn_set_ith_bit_lemma_aux: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a + b * pow2 c < pow2 (c + d) /\ a < pow2 c)
(ensures b < pow2 d)
let bn_set_ith_bit_lemma_aux a b c d =
Math.Lemmas.lemma_div_lt_nat (a + b * pow2 c) (c + d) c;
assert ((a + b * pow2 c) / pow2 c < pow2 d);
Math.Lemmas.lemma_div_plus a b (pow2 c);
assert (a / pow2 c + b < pow2 d);
Math.Lemmas.small_division_lemma_1 a (pow2 c)
val bn_lt_pow2_index_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} -> Lemma
(requires bn_v b < pow2 ind)
(ensures (let i = ind / bits t in v b.[i] < pow2 (ind % bits t) /\
bn_v b == bn_v (slice b 0 i) + pow2 (i * bits t) * v b.[i] /\
bn_v (slice b (i + 1) len) = 0))
let bn_lt_pow2_index_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
Math.Lemmas.euclidean_division_definition ind (pbits);
assert (bn_v b < pow2 (i * pbits + j));
Math.Lemmas.pow2_lt_compat (i * pbits + pbits) (i * pbits + j);
assert (bn_v b < pow2 (i * pbits + pbits));
bn_eval_split_i #t #len b (i + 1);
bn_eval_bound (slice b 0 (i + 1)) (i + 1);
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 (i + 1))) (bn_v (slice b (i + 1) len)) (pbits * (i + 1)) 0;
assert (bn_v b == bn_v (slice b 0 (i + 1)));
bn_eval_split_i #t #(i + 1) (slice b 0 (i + 1)) i;
bn_eval1 (slice b i (i + 1));
assert (bn_v b == bn_v (slice b 0 i) + pow2 (i * pbits) * v b.[i]);
bn_eval_bound #t #i (slice b 0 i) i;
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 i)) (v b.[i]) (i * pbits) j;
assert (v b.[i] < pow2 j)
val bn_set_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> Lemma
(requires bn_v b < pow2 i)
(ensures bn_v (bn_set_ith_bit b i) == bn_v b + pow2 i)
let bn_set_ith_bit_lemma #t #len input ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
bn_lt_pow2_index_lemma #t #len input ind;
assert (v input.[i] < pow2 j);
let b = uint #t 1 <<. size j in
let inp = input.[i] <- input.[i] |. b in
FStar.Math.Lemmas.pow2_lt_compat pbits j;
FStar.Math.Lemmas.modulo_lemma (pow2 j) (pow2 pbits);
assert (v b == pow2 j);
logor_disjoint (input.[i]) b j;
assert (v inp.[i] == v input.[i] + v b);
calc (==) {
bn_v inp;
(==) { bn_eval_split_i #t #len inp (i + 1);
bn_eval_extensionality_j (slice inp (i + 1) len) (slice input (i + 1) len) (len - i - 1) }
bn_v (slice inp 0 (i + 1));
(==) { bn_eval_split_i #t #(i + 1) (slice inp 0 (i + 1)) i }
bn_v (slice inp 0 i) + pow2 (i * pbits) * bn_v (slice inp i (i + 1));
(==) { bn_eval1 (slice inp i (i + 1)) }
bn_v (slice inp 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { bn_eval_extensionality_j input inp i }
bn_v (slice input 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { }
bn_v (slice input 0 i) + pow2 (i * pbits) * (v input.[i] + v b);
(==) { Math.Lemmas.distributivity_add_right (pow2 (i * pbits)) (v input.[i]) (v b) }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 (i * pbits) * v b;
(==) { Math.Lemmas.pow2_plus (i * pbits) j; Math.Lemmas.euclidean_division_definition ind pbits }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 ind;
(==) { }
bn_v input + pow2 ind;
}
///
/// % pow2 and / pow2
///
val bn_div_pow2: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i <= len} -> lbignum t (len - i)
let bn_div_pow2 #t #len b i =
slice b i len
val bn_div_pow2_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i < len} ->
Lemma (bn_v (bn_div_pow2 b i) == bn_v b / pow2 (bits t * i))
let bn_div_pow2_lemma #t #len c i =
let pbits = bits t in
calc (==) {
bn_v c / pow2 (pbits * i);
(==) { bn_eval_split_i c i }
(bn_v (slice c 0 i) + pow2 (pbits * i) * bn_v (slice c i len)) / pow2 (pbits * i);
(==) { Math.Lemmas.division_addition_lemma (bn_v (slice c 0 i)) (pow2 (pbits * i)) (bn_v (slice c i len)) }
bn_v (slice c 0 i) / pow2 (pbits * i) + bn_v (slice c i len);
(==) { bn_eval_bound (slice c 0 i) i; Math.Lemmas.small_division_lemma_1 (bn_v (slice c 0 i)) (pow2 (pbits * i)) }
bn_v (slice c i len);
};
assert (bn_v (slice c i len) == bn_v c / pow2 (pbits * i))
val bn_mod_pow2: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} -> lbignum t i
let bn_mod_pow2 #t #aLen a i = sub a 0 i
val bn_mod_pow2_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} ->
Lemma (bn_v (bn_mod_pow2 a i) == bn_v a % pow2 (bits t * i))
let bn_mod_pow2_lemma #t #aLen a i =
let pbits = bits t in
calc (==) {
bn_v a % pow2 (pbits * i);
(==) { bn_eval_split_i a i }
(bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v (slice a i aLen)) % pow2 (pbits * i);
(==) { Math.Lemmas.modulo_addition_lemma (bn_v (slice a 0 i)) (pow2 (pbits * i)) (bn_v (slice a i aLen)) }
(bn_v (slice a 0 i)) % pow2 (pbits * i);
(==) { bn_eval_bound (slice a 0 i) i; Math.Lemmas.small_mod (bn_v (slice a 0 i)) (pow2 (pbits * i)) }
bn_v (slice a 0 i);
}
///
/// Conditional swap
///
//the same as in curve25519
val lemma_cswap2_step:
#t:limb_t
-> bit:limb t{v bit <= 1}
-> p1:limb t
-> p2:limb t ->
Lemma
(let mask = uint #t 0 -. bit in
let dummy = mask &. (p1 ^. p2) in
let p1' = p1 ^. dummy in
let p2' = p2 ^. dummy in
if v bit = 1 then p1' == p2 /\ p2' == p1 else p1' == p1 /\ p2' == p2)
let lemma_cswap2_step #t bit p1 p2 =
let mask = uint #t 0 -. bit in
assert (v bit == 0 ==> v mask == 0);
assert (v bit == 1 ==> v mask == pow2 (bits t) - 1);
let dummy = mask &. (p1 ^. p2) in
logand_lemma mask (p1 ^. p2);
assert (v bit == 1 ==> v dummy == v (p1 ^. p2));
assert (v bit == 0 ==> v dummy == 0);
let p1' = p1 ^. dummy in
assert (v dummy == v (if v bit = 1 then (p1 ^. p2) else uint #t 0));
logxor_lemma p1 p2;
let p2' = p2 ^. dummy in
logxor_lemma p2 p1
val cswap2_f:
#t:limb_t
-> #len:size_nat
-> mask:limb t
-> i:nat{i < len}
-> tuple2 (lbignum t len) (lbignum t len) ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2_f #t #len mask i (p1, p2) =
let dummy = mask &. (p1.[i] ^. p2.[i]) in
let p1 = p1.[i] <- p1.[i] ^. dummy in
let p2 = p2.[i] <- p2.[i] ^. dummy in
(p1, p2)
val cswap2:
#t:limb_t
-> #len:size_nat
-> bit:limb t
-> b1:lbignum t len
-> b2:lbignum t len ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2 #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.repeati len (cswap2_f #t #len mask) (b1, b2)
val cswap2_lemma:
#t:limb_t
-> #len:size_nat
-> bit:limb t{v bit <= 1}
-> b1:lbignum t len
-> b2:lbignum t len ->
Lemma (let (p1, p2) = cswap2 bit b1 b2 in
(if v bit = 1 then p1 == b2 /\ p2 == b1 else p1 == b1 /\ p2 == b2))
let cswap2_lemma #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.eq_repeati0 len (cswap2_f #t #len mask) (b1, b2);
let (p1, p2) =
Loops.repeati_inductive #(tuple2 (lbignum t len) (lbignum t len)) len
(fun i (p1, p2) ->
(p1, p2) == Loops.repeati i (cswap2_f #t #len mask) (b1, b2) /\
(forall (k:nat{k < i}).
(if v bit = 1 then p1.[k] == b2.[k] /\ p2.[k] == b1.[k] else p1.[k] == b1.[k] /\ p2.[k] == b2.[k])) /\
(forall (k:nat{i <= k /\ k < len}). p1.[k] == b1.[k] /\ p2.[k] == b2.[k]))
(fun i (p1, p2) ->
Loops.unfold_repeati (i + 1) (cswap2_f #t #len mask) (b1, b2) i;
lemma_cswap2_step bit p1.[i] p2.[i];
cswap2_f #t #len mask i (p1, p2)) (b1, b2) in
assert (if v bit = 1 then (eq_intro p1 b2; p1 == b2) else (eq_intro p1 b1; p1 == b1));
assert (if v bit = 1 then (eq_intro p2 b1; p2 == b1) else (eq_intro p2 b2; p2 == b2));
//eq_intro p1 (if v bit = 1 then b2 else b1);
//eq_intro p2 (if v bit = 1 then b1 else b2);
()
let bn_get_top_index_t (len:size_nat) (i:nat{i <= len}) = x:nat{x < len}
val bn_get_top_index_f:
#t:limb_t
-> #len:size_nat
-> b:lbignum t len
-> i:nat{i < len}
-> priv:bn_get_top_index_t len i ->
bn_get_top_index_t len (i + 1)
let bn_get_top_index_f #t #len b i priv =
let mask = eq_mask b.[i] (zeros t SEC) in
if v mask = 0 then i else priv | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b: Hacl.Spec.Bignum.Definitions.lbignum t len -> res: Lib.IntTypes.size_nat{res < len} | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Lib.LoopCombinators.repeat_gen",
"Hacl.Spec.Bignum.Lib.bn_get_top_index_t",
"Hacl.Spec.Bignum.Lib.bn_get_top_index_f",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThan"
] | [] | false | false | false | false | false | let bn_get_top_index #t #len b =
| Loops.repeat_gen len (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0 | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.cswap2_f | val cswap2_f:
#t:limb_t
-> #len:size_nat
-> mask:limb t
-> i:nat{i < len}
-> tuple2 (lbignum t len) (lbignum t len) ->
tuple2 (lbignum t len) (lbignum t len) | val cswap2_f:
#t:limb_t
-> #len:size_nat
-> mask:limb t
-> i:nat{i < len}
-> tuple2 (lbignum t len) (lbignum t len) ->
tuple2 (lbignum t len) (lbignum t len) | let cswap2_f #t #len mask i (p1, p2) =
let dummy = mask &. (p1.[i] ^. p2.[i]) in
let p1 = p1.[i] <- p1.[i] ^. dummy in
let p2 = p2.[i] <- p2.[i] ^. dummy in
(p1, p2) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 265,
"start_col": 0,
"start_line": 261
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2)
let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2)
val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t
let bn_get_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[i] j
val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j))
let bn_get_ith_bit_aux_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = b.[i] >>. size j in
calc (==) {
v b.[i] / pow2 j;
(==) { bn_eval_index b i }
(bn_v b / pow2 (pbits * i) % pow2 pbits) / pow2 j;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b / pow2 (pbits * i)) j pbits }
(bn_v b / pow2 (pbits * i) / pow2 j) % pow2 (pbits - j);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b) (pow2 (pbits * i)) (pow2 j) }
(bn_v b / (pow2 (pbits * i) * pow2 j)) % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_plus (pbits * i) j }
(bn_v b / pow2 (pbits * i + j)) % pow2 (pbits - j);
(==) { Math.Lemmas.euclidean_div_axiom ind pbits }
(bn_v b / pow2 ind) % pow2 (pbits - j);
};
assert (v res == (bn_v b / pow2 ind) % pow2 (pbits - j))
val bn_get_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} ->
Lemma (v (bn_get_ith_bit b i) == (bn_v b / pow2 i % 2))
let bn_get_ith_bit_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = limb_get_ith_bit b.[i] j in
limb_get_ith_bit_lemma b.[i] j;
calc (==) {
v b.[i] / pow2 j % 2;
(==) { bn_get_ith_bit_aux_lemma b ind }
(bn_v b / pow2 ind) % pow2 (pbits - j) % 2;
(==) { assert_norm (pow2 1 = 2);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 ind) 1 (pbits - j) }
(bn_v b / pow2 ind) % 2;
};
assert (v res == bn_v b / pow2 ind % 2)
val bn_set_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> lbignum t len
let bn_set_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
let inp = input.[i] <- input.[i] |. (uint #t 1 <<. size j) in
inp
val bn_set_ith_bit_lemma_aux: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a + b * pow2 c < pow2 (c + d) /\ a < pow2 c)
(ensures b < pow2 d)
let bn_set_ith_bit_lemma_aux a b c d =
Math.Lemmas.lemma_div_lt_nat (a + b * pow2 c) (c + d) c;
assert ((a + b * pow2 c) / pow2 c < pow2 d);
Math.Lemmas.lemma_div_plus a b (pow2 c);
assert (a / pow2 c + b < pow2 d);
Math.Lemmas.small_division_lemma_1 a (pow2 c)
val bn_lt_pow2_index_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} -> Lemma
(requires bn_v b < pow2 ind)
(ensures (let i = ind / bits t in v b.[i] < pow2 (ind % bits t) /\
bn_v b == bn_v (slice b 0 i) + pow2 (i * bits t) * v b.[i] /\
bn_v (slice b (i + 1) len) = 0))
let bn_lt_pow2_index_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
Math.Lemmas.euclidean_division_definition ind (pbits);
assert (bn_v b < pow2 (i * pbits + j));
Math.Lemmas.pow2_lt_compat (i * pbits + pbits) (i * pbits + j);
assert (bn_v b < pow2 (i * pbits + pbits));
bn_eval_split_i #t #len b (i + 1);
bn_eval_bound (slice b 0 (i + 1)) (i + 1);
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 (i + 1))) (bn_v (slice b (i + 1) len)) (pbits * (i + 1)) 0;
assert (bn_v b == bn_v (slice b 0 (i + 1)));
bn_eval_split_i #t #(i + 1) (slice b 0 (i + 1)) i;
bn_eval1 (slice b i (i + 1));
assert (bn_v b == bn_v (slice b 0 i) + pow2 (i * pbits) * v b.[i]);
bn_eval_bound #t #i (slice b 0 i) i;
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 i)) (v b.[i]) (i * pbits) j;
assert (v b.[i] < pow2 j)
val bn_set_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> Lemma
(requires bn_v b < pow2 i)
(ensures bn_v (bn_set_ith_bit b i) == bn_v b + pow2 i)
let bn_set_ith_bit_lemma #t #len input ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
bn_lt_pow2_index_lemma #t #len input ind;
assert (v input.[i] < pow2 j);
let b = uint #t 1 <<. size j in
let inp = input.[i] <- input.[i] |. b in
FStar.Math.Lemmas.pow2_lt_compat pbits j;
FStar.Math.Lemmas.modulo_lemma (pow2 j) (pow2 pbits);
assert (v b == pow2 j);
logor_disjoint (input.[i]) b j;
assert (v inp.[i] == v input.[i] + v b);
calc (==) {
bn_v inp;
(==) { bn_eval_split_i #t #len inp (i + 1);
bn_eval_extensionality_j (slice inp (i + 1) len) (slice input (i + 1) len) (len - i - 1) }
bn_v (slice inp 0 (i + 1));
(==) { bn_eval_split_i #t #(i + 1) (slice inp 0 (i + 1)) i }
bn_v (slice inp 0 i) + pow2 (i * pbits) * bn_v (slice inp i (i + 1));
(==) { bn_eval1 (slice inp i (i + 1)) }
bn_v (slice inp 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { bn_eval_extensionality_j input inp i }
bn_v (slice input 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { }
bn_v (slice input 0 i) + pow2 (i * pbits) * (v input.[i] + v b);
(==) { Math.Lemmas.distributivity_add_right (pow2 (i * pbits)) (v input.[i]) (v b) }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 (i * pbits) * v b;
(==) { Math.Lemmas.pow2_plus (i * pbits) j; Math.Lemmas.euclidean_division_definition ind pbits }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 ind;
(==) { }
bn_v input + pow2 ind;
}
///
/// % pow2 and / pow2
///
val bn_div_pow2: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i <= len} -> lbignum t (len - i)
let bn_div_pow2 #t #len b i =
slice b i len
val bn_div_pow2_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i < len} ->
Lemma (bn_v (bn_div_pow2 b i) == bn_v b / pow2 (bits t * i))
let bn_div_pow2_lemma #t #len c i =
let pbits = bits t in
calc (==) {
bn_v c / pow2 (pbits * i);
(==) { bn_eval_split_i c i }
(bn_v (slice c 0 i) + pow2 (pbits * i) * bn_v (slice c i len)) / pow2 (pbits * i);
(==) { Math.Lemmas.division_addition_lemma (bn_v (slice c 0 i)) (pow2 (pbits * i)) (bn_v (slice c i len)) }
bn_v (slice c 0 i) / pow2 (pbits * i) + bn_v (slice c i len);
(==) { bn_eval_bound (slice c 0 i) i; Math.Lemmas.small_division_lemma_1 (bn_v (slice c 0 i)) (pow2 (pbits * i)) }
bn_v (slice c i len);
};
assert (bn_v (slice c i len) == bn_v c / pow2 (pbits * i))
val bn_mod_pow2: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} -> lbignum t i
let bn_mod_pow2 #t #aLen a i = sub a 0 i
val bn_mod_pow2_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} ->
Lemma (bn_v (bn_mod_pow2 a i) == bn_v a % pow2 (bits t * i))
let bn_mod_pow2_lemma #t #aLen a i =
let pbits = bits t in
calc (==) {
bn_v a % pow2 (pbits * i);
(==) { bn_eval_split_i a i }
(bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v (slice a i aLen)) % pow2 (pbits * i);
(==) { Math.Lemmas.modulo_addition_lemma (bn_v (slice a 0 i)) (pow2 (pbits * i)) (bn_v (slice a i aLen)) }
(bn_v (slice a 0 i)) % pow2 (pbits * i);
(==) { bn_eval_bound (slice a 0 i) i; Math.Lemmas.small_mod (bn_v (slice a 0 i)) (pow2 (pbits * i)) }
bn_v (slice a 0 i);
}
///
/// Conditional swap
///
//the same as in curve25519
val lemma_cswap2_step:
#t:limb_t
-> bit:limb t{v bit <= 1}
-> p1:limb t
-> p2:limb t ->
Lemma
(let mask = uint #t 0 -. bit in
let dummy = mask &. (p1 ^. p2) in
let p1' = p1 ^. dummy in
let p2' = p2 ^. dummy in
if v bit = 1 then p1' == p2 /\ p2' == p1 else p1' == p1 /\ p2' == p2)
let lemma_cswap2_step #t bit p1 p2 =
let mask = uint #t 0 -. bit in
assert (v bit == 0 ==> v mask == 0);
assert (v bit == 1 ==> v mask == pow2 (bits t) - 1);
let dummy = mask &. (p1 ^. p2) in
logand_lemma mask (p1 ^. p2);
assert (v bit == 1 ==> v dummy == v (p1 ^. p2));
assert (v bit == 0 ==> v dummy == 0);
let p1' = p1 ^. dummy in
assert (v dummy == v (if v bit = 1 then (p1 ^. p2) else uint #t 0));
logxor_lemma p1 p2;
let p2' = p2 ^. dummy in
logxor_lemma p2 p1
val cswap2_f:
#t:limb_t
-> #len:size_nat
-> mask:limb t
-> i:nat{i < len}
-> tuple2 (lbignum t len) (lbignum t len) ->
tuple2 (lbignum t len) (lbignum t len) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
mask: Hacl.Spec.Bignum.Definitions.limb t ->
i: Prims.nat{i < len} ->
_: (Hacl.Spec.Bignum.Definitions.lbignum t len * Hacl.Spec.Bignum.Definitions.lbignum t len)
-> Hacl.Spec.Bignum.Definitions.lbignum t len * Hacl.Spec.Bignum.Definitions.lbignum t len | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Definitions.lbignum",
"FStar.Pervasives.Native.Mktuple2",
"Lib.Sequence.lseq",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.upd",
"Lib.IntTypes.logxor",
"Lib.IntTypes.SEC",
"Lib.Sequence.index",
"Prims.l_Forall",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.l_imp",
"Prims.op_disEquality",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.op_String_Assignment",
"Lib.IntTypes.op_Hat_Dot",
"Lib.Sequence.op_String_Access",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Amp_Dot"
] | [] | false | false | false | false | false | let cswap2_f #t #len mask i (p1, p2) =
| let dummy = mask &. (p1.[ i ] ^. p2.[ i ]) in
let p1 = p1.[ i ] <- p1.[ i ] ^. dummy in
let p2 = p2.[ i ] <- p2.[ i ] ^. dummy in
(p1, p2) | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.lemma_cswap2_step | val lemma_cswap2_step:
#t:limb_t
-> bit:limb t{v bit <= 1}
-> p1:limb t
-> p2:limb t ->
Lemma
(let mask = uint #t 0 -. bit in
let dummy = mask &. (p1 ^. p2) in
let p1' = p1 ^. dummy in
let p2' = p2 ^. dummy in
if v bit = 1 then p1' == p2 /\ p2' == p1 else p1' == p1 /\ p2' == p2) | val lemma_cswap2_step:
#t:limb_t
-> bit:limb t{v bit <= 1}
-> p1:limb t
-> p2:limb t ->
Lemma
(let mask = uint #t 0 -. bit in
let dummy = mask &. (p1 ^. p2) in
let p1' = p1 ^. dummy in
let p2' = p2 ^. dummy in
if v bit = 1 then p1' == p2 /\ p2' == p1 else p1' == p1 /\ p2' == p2) | let lemma_cswap2_step #t bit p1 p2 =
let mask = uint #t 0 -. bit in
assert (v bit == 0 ==> v mask == 0);
assert (v bit == 1 ==> v mask == pow2 (bits t) - 1);
let dummy = mask &. (p1 ^. p2) in
logand_lemma mask (p1 ^. p2);
assert (v bit == 1 ==> v dummy == v (p1 ^. p2));
assert (v bit == 0 ==> v dummy == 0);
let p1' = p1 ^. dummy in
assert (v dummy == v (if v bit = 1 then (p1 ^. p2) else uint #t 0));
logxor_lemma p1 p2;
let p2' = p2 ^. dummy in
logxor_lemma p2 p1 | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 20,
"end_line": 250,
"start_col": 0,
"start_line": 238
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2)
let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2)
val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t
let bn_get_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[i] j
val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j))
let bn_get_ith_bit_aux_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = b.[i] >>. size j in
calc (==) {
v b.[i] / pow2 j;
(==) { bn_eval_index b i }
(bn_v b / pow2 (pbits * i) % pow2 pbits) / pow2 j;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b / pow2 (pbits * i)) j pbits }
(bn_v b / pow2 (pbits * i) / pow2 j) % pow2 (pbits - j);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b) (pow2 (pbits * i)) (pow2 j) }
(bn_v b / (pow2 (pbits * i) * pow2 j)) % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_plus (pbits * i) j }
(bn_v b / pow2 (pbits * i + j)) % pow2 (pbits - j);
(==) { Math.Lemmas.euclidean_div_axiom ind pbits }
(bn_v b / pow2 ind) % pow2 (pbits - j);
};
assert (v res == (bn_v b / pow2 ind) % pow2 (pbits - j))
val bn_get_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} ->
Lemma (v (bn_get_ith_bit b i) == (bn_v b / pow2 i % 2))
let bn_get_ith_bit_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = limb_get_ith_bit b.[i] j in
limb_get_ith_bit_lemma b.[i] j;
calc (==) {
v b.[i] / pow2 j % 2;
(==) { bn_get_ith_bit_aux_lemma b ind }
(bn_v b / pow2 ind) % pow2 (pbits - j) % 2;
(==) { assert_norm (pow2 1 = 2);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 ind) 1 (pbits - j) }
(bn_v b / pow2 ind) % 2;
};
assert (v res == bn_v b / pow2 ind % 2)
val bn_set_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> lbignum t len
let bn_set_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
let inp = input.[i] <- input.[i] |. (uint #t 1 <<. size j) in
inp
val bn_set_ith_bit_lemma_aux: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a + b * pow2 c < pow2 (c + d) /\ a < pow2 c)
(ensures b < pow2 d)
let bn_set_ith_bit_lemma_aux a b c d =
Math.Lemmas.lemma_div_lt_nat (a + b * pow2 c) (c + d) c;
assert ((a + b * pow2 c) / pow2 c < pow2 d);
Math.Lemmas.lemma_div_plus a b (pow2 c);
assert (a / pow2 c + b < pow2 d);
Math.Lemmas.small_division_lemma_1 a (pow2 c)
val bn_lt_pow2_index_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} -> Lemma
(requires bn_v b < pow2 ind)
(ensures (let i = ind / bits t in v b.[i] < pow2 (ind % bits t) /\
bn_v b == bn_v (slice b 0 i) + pow2 (i * bits t) * v b.[i] /\
bn_v (slice b (i + 1) len) = 0))
let bn_lt_pow2_index_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
Math.Lemmas.euclidean_division_definition ind (pbits);
assert (bn_v b < pow2 (i * pbits + j));
Math.Lemmas.pow2_lt_compat (i * pbits + pbits) (i * pbits + j);
assert (bn_v b < pow2 (i * pbits + pbits));
bn_eval_split_i #t #len b (i + 1);
bn_eval_bound (slice b 0 (i + 1)) (i + 1);
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 (i + 1))) (bn_v (slice b (i + 1) len)) (pbits * (i + 1)) 0;
assert (bn_v b == bn_v (slice b 0 (i + 1)));
bn_eval_split_i #t #(i + 1) (slice b 0 (i + 1)) i;
bn_eval1 (slice b i (i + 1));
assert (bn_v b == bn_v (slice b 0 i) + pow2 (i * pbits) * v b.[i]);
bn_eval_bound #t #i (slice b 0 i) i;
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 i)) (v b.[i]) (i * pbits) j;
assert (v b.[i] < pow2 j)
val bn_set_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> Lemma
(requires bn_v b < pow2 i)
(ensures bn_v (bn_set_ith_bit b i) == bn_v b + pow2 i)
let bn_set_ith_bit_lemma #t #len input ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
bn_lt_pow2_index_lemma #t #len input ind;
assert (v input.[i] < pow2 j);
let b = uint #t 1 <<. size j in
let inp = input.[i] <- input.[i] |. b in
FStar.Math.Lemmas.pow2_lt_compat pbits j;
FStar.Math.Lemmas.modulo_lemma (pow2 j) (pow2 pbits);
assert (v b == pow2 j);
logor_disjoint (input.[i]) b j;
assert (v inp.[i] == v input.[i] + v b);
calc (==) {
bn_v inp;
(==) { bn_eval_split_i #t #len inp (i + 1);
bn_eval_extensionality_j (slice inp (i + 1) len) (slice input (i + 1) len) (len - i - 1) }
bn_v (slice inp 0 (i + 1));
(==) { bn_eval_split_i #t #(i + 1) (slice inp 0 (i + 1)) i }
bn_v (slice inp 0 i) + pow2 (i * pbits) * bn_v (slice inp i (i + 1));
(==) { bn_eval1 (slice inp i (i + 1)) }
bn_v (slice inp 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { bn_eval_extensionality_j input inp i }
bn_v (slice input 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { }
bn_v (slice input 0 i) + pow2 (i * pbits) * (v input.[i] + v b);
(==) { Math.Lemmas.distributivity_add_right (pow2 (i * pbits)) (v input.[i]) (v b) }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 (i * pbits) * v b;
(==) { Math.Lemmas.pow2_plus (i * pbits) j; Math.Lemmas.euclidean_division_definition ind pbits }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 ind;
(==) { }
bn_v input + pow2 ind;
}
///
/// % pow2 and / pow2
///
val bn_div_pow2: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i <= len} -> lbignum t (len - i)
let bn_div_pow2 #t #len b i =
slice b i len
val bn_div_pow2_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i < len} ->
Lemma (bn_v (bn_div_pow2 b i) == bn_v b / pow2 (bits t * i))
let bn_div_pow2_lemma #t #len c i =
let pbits = bits t in
calc (==) {
bn_v c / pow2 (pbits * i);
(==) { bn_eval_split_i c i }
(bn_v (slice c 0 i) + pow2 (pbits * i) * bn_v (slice c i len)) / pow2 (pbits * i);
(==) { Math.Lemmas.division_addition_lemma (bn_v (slice c 0 i)) (pow2 (pbits * i)) (bn_v (slice c i len)) }
bn_v (slice c 0 i) / pow2 (pbits * i) + bn_v (slice c i len);
(==) { bn_eval_bound (slice c 0 i) i; Math.Lemmas.small_division_lemma_1 (bn_v (slice c 0 i)) (pow2 (pbits * i)) }
bn_v (slice c i len);
};
assert (bn_v (slice c i len) == bn_v c / pow2 (pbits * i))
val bn_mod_pow2: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} -> lbignum t i
let bn_mod_pow2 #t #aLen a i = sub a 0 i
val bn_mod_pow2_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} ->
Lemma (bn_v (bn_mod_pow2 a i) == bn_v a % pow2 (bits t * i))
let bn_mod_pow2_lemma #t #aLen a i =
let pbits = bits t in
calc (==) {
bn_v a % pow2 (pbits * i);
(==) { bn_eval_split_i a i }
(bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v (slice a i aLen)) % pow2 (pbits * i);
(==) { Math.Lemmas.modulo_addition_lemma (bn_v (slice a 0 i)) (pow2 (pbits * i)) (bn_v (slice a i aLen)) }
(bn_v (slice a 0 i)) % pow2 (pbits * i);
(==) { bn_eval_bound (slice a 0 i) i; Math.Lemmas.small_mod (bn_v (slice a 0 i)) (pow2 (pbits * i)) }
bn_v (slice a 0 i);
}
///
/// Conditional swap
///
//the same as in curve25519
val lemma_cswap2_step:
#t:limb_t
-> bit:limb t{v bit <= 1}
-> p1:limb t
-> p2:limb t ->
Lemma
(let mask = uint #t 0 -. bit in
let dummy = mask &. (p1 ^. p2) in
let p1' = p1 ^. dummy in
let p2' = p2 ^. dummy in
if v bit = 1 then p1' == p2 /\ p2' == p1 else p1' == p1 /\ p2' == p2) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
bit: Hacl.Spec.Bignum.Definitions.limb t {Lib.IntTypes.v bit <= 1} ->
p1: Hacl.Spec.Bignum.Definitions.limb t ->
p2: Hacl.Spec.Bignum.Definitions.limb t
-> FStar.Pervasives.Lemma
(ensures
(let mask = Lib.IntTypes.uint 0 -. bit in
let dummy = mask &. p1 ^. p2 in
let p1' = p1 ^. dummy in
let p2' = p2 ^. dummy in
(match Lib.IntTypes.v bit = 1 with
| true -> p1' == p2 /\ p2' == p1
| _ -> p1' == p1 /\ p2' == p2)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Lib.IntTypes.logxor_lemma",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Hat_Dot",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Lib.IntTypes.range_t",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"Lib.IntTypes.uint",
"Prims.l_imp",
"Lib.IntTypes.logand_lemma",
"Lib.IntTypes.op_Amp_Dot",
"Prims.op_Subtraction",
"Prims.pow2",
"Lib.IntTypes.bits",
"Lib.IntTypes.op_Subtraction_Dot"
] | [] | false | false | true | false | false | let lemma_cswap2_step #t bit p1 p2 =
| let mask = uint #t 0 -. bit in
assert (v bit == 0 ==> v mask == 0);
assert (v bit == 1 ==> v mask == pow2 (bits t) - 1);
let dummy = mask &. (p1 ^. p2) in
logand_lemma mask (p1 ^. p2);
assert (v bit == 1 ==> v dummy == v (p1 ^. p2));
assert (v bit == 0 ==> v dummy == 0);
let p1' = p1 ^. dummy in
assert (v dummy == v (if v bit = 1 then (p1 ^. p2) else uint #t 0));
logxor_lemma p1 p2;
let p2' = p2 ^. dummy in
logxor_lemma p2 p1 | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.bn_get_ith_bit_lemma | val bn_get_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} ->
Lemma (v (bn_get_ith_bit b i) == (bn_v b / pow2 i % 2)) | val bn_get_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} ->
Lemma (v (bn_get_ith_bit b i) == (bn_v b / pow2 i % 2)) | let bn_get_ith_bit_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = limb_get_ith_bit b.[i] j in
limb_get_ith_bit_lemma b.[i] j;
calc (==) {
v b.[i] / pow2 j % 2;
(==) { bn_get_ith_bit_aux_lemma b ind }
(bn_v b / pow2 ind) % pow2 (pbits - j) % 2;
(==) { assert_norm (pow2 1 = 2);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 ind) 1 (pbits - j) }
(bn_v b / pow2 ind) % 2;
};
assert (v res == bn_v b / pow2 ind % 2) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 41,
"end_line": 86,
"start_col": 0,
"start_line": 71
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2)
let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2)
val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t
let bn_get_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[i] j
val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j))
let bn_get_ith_bit_aux_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = b.[i] >>. size j in
calc (==) {
v b.[i] / pow2 j;
(==) { bn_eval_index b i }
(bn_v b / pow2 (pbits * i) % pow2 pbits) / pow2 j;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b / pow2 (pbits * i)) j pbits }
(bn_v b / pow2 (pbits * i) / pow2 j) % pow2 (pbits - j);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b) (pow2 (pbits * i)) (pow2 j) }
(bn_v b / (pow2 (pbits * i) * pow2 j)) % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_plus (pbits * i) j }
(bn_v b / pow2 (pbits * i + j)) % pow2 (pbits - j);
(==) { Math.Lemmas.euclidean_div_axiom ind pbits }
(bn_v b / pow2 ind) % pow2 (pbits - j);
};
assert (v res == (bn_v b / pow2 ind) % pow2 (pbits - j))
val bn_get_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} ->
Lemma (v (bn_get_ith_bit b i) == (bn_v b / pow2 i % 2)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: Hacl.Spec.Bignum.Definitions.lbignum t len ->
i: Lib.IntTypes.size_nat{i / Lib.IntTypes.bits t < len}
-> FStar.Pervasives.Lemma
(ensures
Lib.IntTypes.v (Hacl.Spec.Bignum.Lib.bn_get_ith_bit b i) ==
Hacl.Spec.Bignum.Definitions.bn_v b / Prims.pow2 i % 2) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Division",
"Lib.IntTypes.bits",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims.op_Modulus",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.pow2",
"Prims.unit",
"FStar.Calc.calc_finish",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"Prims.op_Subtraction",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Hacl.Spec.Bignum.Lib.bn_get_ith_bit_aux_lemma",
"Prims.squash",
"FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Hacl.Spec.Bignum.Lib.limb_get_ith_bit_lemma",
"Hacl.Spec.Bignum.Lib.limb_get_ith_bit"
] | [] | false | false | true | false | false | let bn_get_ith_bit_lemma #t #len b ind =
| let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = limb_get_ith_bit b.[ i ] j in
limb_get_ith_bit_lemma b.[ i ] j;
calc ( == ) {
v b.[ i ] / pow2 j % 2;
( == ) { bn_get_ith_bit_aux_lemma b ind }
(bn_v b / pow2 ind) % pow2 (pbits - j) % 2;
( == ) { (assert_norm (pow2 1 = 2);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 ind) 1 (pbits - j)) }
(bn_v b / pow2 ind) % 2;
};
assert (v res == bn_v b / pow2 ind % 2) | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.bn_get_bits | val bn_get_bits:
#t:limb_t
-> #nLen:size_nat
-> n:lbignum t nLen
-> i:size_nat
-> l:size_nat{l < bits t /\ i / bits t < nLen} ->
limb t | val bn_get_bits:
#t:limb_t
-> #nLen:size_nat
-> n:lbignum t nLen
-> i:size_nat
-> l:size_nat{l < bits t /\ i / bits t < nLen} ->
limb t | let bn_get_bits #t #nLen n ind l =
let mask_l = (uint #t #SEC 1 <<. size l) -. uint #t 1 in
bn_get_bits_limb n ind &. mask_l | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 34,
"end_line": 516,
"start_col": 0,
"start_line": 514
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2)
let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2)
val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t
let bn_get_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[i] j
val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j))
let bn_get_ith_bit_aux_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = b.[i] >>. size j in
calc (==) {
v b.[i] / pow2 j;
(==) { bn_eval_index b i }
(bn_v b / pow2 (pbits * i) % pow2 pbits) / pow2 j;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b / pow2 (pbits * i)) j pbits }
(bn_v b / pow2 (pbits * i) / pow2 j) % pow2 (pbits - j);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b) (pow2 (pbits * i)) (pow2 j) }
(bn_v b / (pow2 (pbits * i) * pow2 j)) % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_plus (pbits * i) j }
(bn_v b / pow2 (pbits * i + j)) % pow2 (pbits - j);
(==) { Math.Lemmas.euclidean_div_axiom ind pbits }
(bn_v b / pow2 ind) % pow2 (pbits - j);
};
assert (v res == (bn_v b / pow2 ind) % pow2 (pbits - j))
val bn_get_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} ->
Lemma (v (bn_get_ith_bit b i) == (bn_v b / pow2 i % 2))
let bn_get_ith_bit_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = limb_get_ith_bit b.[i] j in
limb_get_ith_bit_lemma b.[i] j;
calc (==) {
v b.[i] / pow2 j % 2;
(==) { bn_get_ith_bit_aux_lemma b ind }
(bn_v b / pow2 ind) % pow2 (pbits - j) % 2;
(==) { assert_norm (pow2 1 = 2);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 ind) 1 (pbits - j) }
(bn_v b / pow2 ind) % 2;
};
assert (v res == bn_v b / pow2 ind % 2)
val bn_set_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> lbignum t len
let bn_set_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
let inp = input.[i] <- input.[i] |. (uint #t 1 <<. size j) in
inp
val bn_set_ith_bit_lemma_aux: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a + b * pow2 c < pow2 (c + d) /\ a < pow2 c)
(ensures b < pow2 d)
let bn_set_ith_bit_lemma_aux a b c d =
Math.Lemmas.lemma_div_lt_nat (a + b * pow2 c) (c + d) c;
assert ((a + b * pow2 c) / pow2 c < pow2 d);
Math.Lemmas.lemma_div_plus a b (pow2 c);
assert (a / pow2 c + b < pow2 d);
Math.Lemmas.small_division_lemma_1 a (pow2 c)
val bn_lt_pow2_index_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} -> Lemma
(requires bn_v b < pow2 ind)
(ensures (let i = ind / bits t in v b.[i] < pow2 (ind % bits t) /\
bn_v b == bn_v (slice b 0 i) + pow2 (i * bits t) * v b.[i] /\
bn_v (slice b (i + 1) len) = 0))
let bn_lt_pow2_index_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
Math.Lemmas.euclidean_division_definition ind (pbits);
assert (bn_v b < pow2 (i * pbits + j));
Math.Lemmas.pow2_lt_compat (i * pbits + pbits) (i * pbits + j);
assert (bn_v b < pow2 (i * pbits + pbits));
bn_eval_split_i #t #len b (i + 1);
bn_eval_bound (slice b 0 (i + 1)) (i + 1);
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 (i + 1))) (bn_v (slice b (i + 1) len)) (pbits * (i + 1)) 0;
assert (bn_v b == bn_v (slice b 0 (i + 1)));
bn_eval_split_i #t #(i + 1) (slice b 0 (i + 1)) i;
bn_eval1 (slice b i (i + 1));
assert (bn_v b == bn_v (slice b 0 i) + pow2 (i * pbits) * v b.[i]);
bn_eval_bound #t #i (slice b 0 i) i;
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 i)) (v b.[i]) (i * pbits) j;
assert (v b.[i] < pow2 j)
val bn_set_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> Lemma
(requires bn_v b < pow2 i)
(ensures bn_v (bn_set_ith_bit b i) == bn_v b + pow2 i)
let bn_set_ith_bit_lemma #t #len input ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
bn_lt_pow2_index_lemma #t #len input ind;
assert (v input.[i] < pow2 j);
let b = uint #t 1 <<. size j in
let inp = input.[i] <- input.[i] |. b in
FStar.Math.Lemmas.pow2_lt_compat pbits j;
FStar.Math.Lemmas.modulo_lemma (pow2 j) (pow2 pbits);
assert (v b == pow2 j);
logor_disjoint (input.[i]) b j;
assert (v inp.[i] == v input.[i] + v b);
calc (==) {
bn_v inp;
(==) { bn_eval_split_i #t #len inp (i + 1);
bn_eval_extensionality_j (slice inp (i + 1) len) (slice input (i + 1) len) (len - i - 1) }
bn_v (slice inp 0 (i + 1));
(==) { bn_eval_split_i #t #(i + 1) (slice inp 0 (i + 1)) i }
bn_v (slice inp 0 i) + pow2 (i * pbits) * bn_v (slice inp i (i + 1));
(==) { bn_eval1 (slice inp i (i + 1)) }
bn_v (slice inp 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { bn_eval_extensionality_j input inp i }
bn_v (slice input 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { }
bn_v (slice input 0 i) + pow2 (i * pbits) * (v input.[i] + v b);
(==) { Math.Lemmas.distributivity_add_right (pow2 (i * pbits)) (v input.[i]) (v b) }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 (i * pbits) * v b;
(==) { Math.Lemmas.pow2_plus (i * pbits) j; Math.Lemmas.euclidean_division_definition ind pbits }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 ind;
(==) { }
bn_v input + pow2 ind;
}
///
/// % pow2 and / pow2
///
val bn_div_pow2: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i <= len} -> lbignum t (len - i)
let bn_div_pow2 #t #len b i =
slice b i len
val bn_div_pow2_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i < len} ->
Lemma (bn_v (bn_div_pow2 b i) == bn_v b / pow2 (bits t * i))
let bn_div_pow2_lemma #t #len c i =
let pbits = bits t in
calc (==) {
bn_v c / pow2 (pbits * i);
(==) { bn_eval_split_i c i }
(bn_v (slice c 0 i) + pow2 (pbits * i) * bn_v (slice c i len)) / pow2 (pbits * i);
(==) { Math.Lemmas.division_addition_lemma (bn_v (slice c 0 i)) (pow2 (pbits * i)) (bn_v (slice c i len)) }
bn_v (slice c 0 i) / pow2 (pbits * i) + bn_v (slice c i len);
(==) { bn_eval_bound (slice c 0 i) i; Math.Lemmas.small_division_lemma_1 (bn_v (slice c 0 i)) (pow2 (pbits * i)) }
bn_v (slice c i len);
};
assert (bn_v (slice c i len) == bn_v c / pow2 (pbits * i))
val bn_mod_pow2: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} -> lbignum t i
let bn_mod_pow2 #t #aLen a i = sub a 0 i
val bn_mod_pow2_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} ->
Lemma (bn_v (bn_mod_pow2 a i) == bn_v a % pow2 (bits t * i))
let bn_mod_pow2_lemma #t #aLen a i =
let pbits = bits t in
calc (==) {
bn_v a % pow2 (pbits * i);
(==) { bn_eval_split_i a i }
(bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v (slice a i aLen)) % pow2 (pbits * i);
(==) { Math.Lemmas.modulo_addition_lemma (bn_v (slice a 0 i)) (pow2 (pbits * i)) (bn_v (slice a i aLen)) }
(bn_v (slice a 0 i)) % pow2 (pbits * i);
(==) { bn_eval_bound (slice a 0 i) i; Math.Lemmas.small_mod (bn_v (slice a 0 i)) (pow2 (pbits * i)) }
bn_v (slice a 0 i);
}
///
/// Conditional swap
///
//the same as in curve25519
val lemma_cswap2_step:
#t:limb_t
-> bit:limb t{v bit <= 1}
-> p1:limb t
-> p2:limb t ->
Lemma
(let mask = uint #t 0 -. bit in
let dummy = mask &. (p1 ^. p2) in
let p1' = p1 ^. dummy in
let p2' = p2 ^. dummy in
if v bit = 1 then p1' == p2 /\ p2' == p1 else p1' == p1 /\ p2' == p2)
let lemma_cswap2_step #t bit p1 p2 =
let mask = uint #t 0 -. bit in
assert (v bit == 0 ==> v mask == 0);
assert (v bit == 1 ==> v mask == pow2 (bits t) - 1);
let dummy = mask &. (p1 ^. p2) in
logand_lemma mask (p1 ^. p2);
assert (v bit == 1 ==> v dummy == v (p1 ^. p2));
assert (v bit == 0 ==> v dummy == 0);
let p1' = p1 ^. dummy in
assert (v dummy == v (if v bit = 1 then (p1 ^. p2) else uint #t 0));
logxor_lemma p1 p2;
let p2' = p2 ^. dummy in
logxor_lemma p2 p1
val cswap2_f:
#t:limb_t
-> #len:size_nat
-> mask:limb t
-> i:nat{i < len}
-> tuple2 (lbignum t len) (lbignum t len) ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2_f #t #len mask i (p1, p2) =
let dummy = mask &. (p1.[i] ^. p2.[i]) in
let p1 = p1.[i] <- p1.[i] ^. dummy in
let p2 = p2.[i] <- p2.[i] ^. dummy in
(p1, p2)
val cswap2:
#t:limb_t
-> #len:size_nat
-> bit:limb t
-> b1:lbignum t len
-> b2:lbignum t len ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2 #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.repeati len (cswap2_f #t #len mask) (b1, b2)
val cswap2_lemma:
#t:limb_t
-> #len:size_nat
-> bit:limb t{v bit <= 1}
-> b1:lbignum t len
-> b2:lbignum t len ->
Lemma (let (p1, p2) = cswap2 bit b1 b2 in
(if v bit = 1 then p1 == b2 /\ p2 == b1 else p1 == b1 /\ p2 == b2))
let cswap2_lemma #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.eq_repeati0 len (cswap2_f #t #len mask) (b1, b2);
let (p1, p2) =
Loops.repeati_inductive #(tuple2 (lbignum t len) (lbignum t len)) len
(fun i (p1, p2) ->
(p1, p2) == Loops.repeati i (cswap2_f #t #len mask) (b1, b2) /\
(forall (k:nat{k < i}).
(if v bit = 1 then p1.[k] == b2.[k] /\ p2.[k] == b1.[k] else p1.[k] == b1.[k] /\ p2.[k] == b2.[k])) /\
(forall (k:nat{i <= k /\ k < len}). p1.[k] == b1.[k] /\ p2.[k] == b2.[k]))
(fun i (p1, p2) ->
Loops.unfold_repeati (i + 1) (cswap2_f #t #len mask) (b1, b2) i;
lemma_cswap2_step bit p1.[i] p2.[i];
cswap2_f #t #len mask i (p1, p2)) (b1, b2) in
assert (if v bit = 1 then (eq_intro p1 b2; p1 == b2) else (eq_intro p1 b1; p1 == b1));
assert (if v bit = 1 then (eq_intro p2 b1; p2 == b1) else (eq_intro p2 b2; p2 == b2));
//eq_intro p1 (if v bit = 1 then b2 else b1);
//eq_intro p2 (if v bit = 1 then b1 else b2);
()
let bn_get_top_index_t (len:size_nat) (i:nat{i <= len}) = x:nat{x < len}
val bn_get_top_index_f:
#t:limb_t
-> #len:size_nat
-> b:lbignum t len
-> i:nat{i < len}
-> priv:bn_get_top_index_t len i ->
bn_get_top_index_t len (i + 1)
let bn_get_top_index_f #t #len b i priv =
let mask = eq_mask b.[i] (zeros t SEC) in
if v mask = 0 then i else priv
val bn_get_top_index: #t:limb_t -> #len:size_pos -> b:lbignum t len -> res:size_nat{res < len}
let bn_get_top_index #t #len b =
Loops.repeat_gen len (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0
val bn_get_top_index_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (let ind = bn_get_top_index #t #len b in
ind < len /\ (ind > 0 ==> v b.[ind] <> 0) /\ (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0))
let bn_get_top_index_lemma #t #len b =
Loops.eq_repeat_gen0 len (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0;
let res =
Loops.repeati_inductive #size_nat len
(fun i priv ->
priv == Loops.repeat_gen i (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0 /\
priv < len /\ (priv > 0 ==> v b.[priv] <> 0) /\ (forall (k:nat{priv < k /\ k < i}). v b.[k] = 0))
(fun i priv ->
Loops.unfold_repeat_gen (i + 1) (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0 i;
let mask = eq_mask b.[i] (zeros t SEC) in
eq_mask_lemma b.[i] (zeros t SEC);
assert (if v mask = 0 then v b.[i] <> 0 else v b.[i] = 0);
let res = if v mask = 0 then i else priv in
res) 0 in
()
val bn_get_top_index_eval_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len -> ind:nat -> Lemma
(requires
ind < len /\ (ind > 0 ==> v b.[ind] <> 0) /\ (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0))
(ensures
bn_v b == bn_v (slice b 0 ind) + pow2 (bits t * ind) * v b.[ind])
let bn_get_top_index_eval_lemma #t #len b ind =
let pbits = bits t in
assert (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0);
bn_eval_split_i b (ind + 1);
assert (bn_v b == bn_v (slice b 0 (ind + 1)) + pow2 (pbits * (ind + 1)) * bn_v (slice b (ind + 1) len));
eq_intro (slice b (ind + 1) len) (create (len - ind - 1) (uint #t 0));
bn_eval_zeroes #t (len - ind - 1) (len - ind - 1);
assert (bn_v b == bn_v (slice b 0 (ind + 1)));
bn_eval_split_i (slice b 0 (ind + 1)) ind;
assert (bn_v b == bn_v (slice b 0 ind) + pow2 (pbits * ind) * bn_v (slice b ind (ind + 1)));
bn_eval1 (slice b ind (ind + 1));
assert (bn_v b == bn_v (slice b 0 ind) + pow2 (pbits * ind) * v b.[ind])
val bn_low_bound_bits:
#t:limb_t
-> #len:size_pos{bits t * len <= max_size_t}
-> b:lbignum t len ->
res:size_nat{res / bits t < len}
let bn_low_bound_bits #t #len b =
bits t * bn_get_top_index b
val bn_low_bound_bits_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len -> Lemma
(requires 1 < bn_v b /\ bits t * len <= max_size_t /\ bn_v b % 2 = 1)
(ensures pow2 (bn_low_bound_bits b) < bn_v b)
let bn_low_bound_bits_lemma #t #len b =
let ind = bn_get_top_index #t #len b in
bn_get_top_index_lemma #t #len b;
bn_get_top_index_eval_lemma #t #len b ind;
assert (pow2 (bn_low_bound_bits b) <= bn_v b);
if ind = 0 then
assert_norm (pow2 0 = 1)
else
Math.Lemmas.pow2_multiplication_modulo_lemma_1 1 1 (bn_low_bound_bits b)
val bn_get_bits_limb:
#t:limb_t
-> #nLen:size_nat
-> n:lbignum t nLen
-> ind:size_nat{ind / bits t < nLen} ->
limb t
let bn_get_bits_limb #t #nLen n ind =
let i = ind / bits t in
let j = ind % bits t in
let p1 = n.[i] >>. size j in
let p2 = if i + 1 < nLen && 0 < j then p1 |. (n.[i + 1] <<. (size (bits t - j))) else p1 in
p2
val bn_get_bits_limb_aux_lemma:
#t:limb_t
-> #nLen:size_nat
-> n:lbignum t nLen
-> ind:size_nat{ind / bits t < nLen} ->
Lemma (
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let p1 = n.[i] >>. size j in
bn_v n / pow2 ind % pow2 pbits == bn_v n / pow2 ((i + 1) * pbits) % pow2 pbits * pow2 (pbits - j) % pow2 pbits + v p1)
let bn_get_bits_limb_aux_lemma #t #nLen n ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let p1 = n.[i] >>. size j in
let res = bn_v n / pow2 ind % pow2 pbits in
calc (==) {
bn_v n / pow2 ind % pow2 pbits;
(==) { Math.Lemmas.euclidean_division_definition res (pow2 (pbits - j)) }
res / pow2 (pbits - j) * pow2 (pbits - j) + res % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v n / pow2 ind) (pbits - j) pbits }
res / pow2 (pbits - j) * pow2 (pbits - j) + bn_v n / pow2 ind % pow2 (pbits - j);
(==) { bn_get_ith_bit_aux_lemma n ind }
res / pow2 (pbits - j) * pow2 (pbits - j) + v p1;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v n / pow2 ind) (pbits - j) pbits }
bn_v n / pow2 ind / pow2 (pbits - j) % pow2 j * pow2 (pbits - j) + v p1;
(==) { Math.Lemmas.division_multiplication_lemma (bn_v n) (pow2 ind) (pow2 (pbits - j)) }
bn_v n / (pow2 ind * pow2 (pbits - j)) % pow2 j * pow2 (pbits - j) + v p1;
(==) { Math.Lemmas.pow2_plus ind (pbits - j) }
bn_v n / pow2 (ind + pbits - j) % pow2 j * pow2 (pbits - j) + v p1;
(==) { Math.Lemmas.euclidean_division_definition ind pbits }
bn_v n / pow2 (i * pbits + pbits) % pow2 j * pow2 (pbits - j) + v p1;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (bn_v n / pow2 (i * pbits + pbits)) pbits (pbits - j) }
bn_v n / pow2 (i * pbits + pbits) * pow2 (pbits - j) % pow2 pbits + v p1;
(==) { Math.Lemmas.distributivity_add_left i 1 pbits }
bn_v n / pow2 ((i + 1) * pbits) * pow2 (pbits - j) % pow2 pbits + v p1;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (bn_v n / pow2 ((i + 1) * pbits)) (pow2 (pbits - j)) (pow2 pbits) }
bn_v n / pow2 ((i + 1) * pbits) % pow2 pbits * pow2 (pbits - j) % pow2 pbits + v p1;
}
val bn_get_bits_limb_lemma:
#t:limb_t
-> #nLen:size_nat
-> n:lbignum t nLen
-> ind:size_nat{ind / bits t < nLen} ->
Lemma (v (bn_get_bits_limb n ind) == bn_v n / pow2 ind % pow2 (bits t))
#push-options "--z3rlimit 100"
let bn_get_bits_limb_lemma #t #nLen n ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
assert (i == ind / bits t);
assert (i < nLen);
let p1 = n.[i] >>. size j in
let res = bn_v n / pow2 ind % pow2 pbits in
bn_get_ith_bit_aux_lemma n ind;
assert (v p1 == bn_v n / pow2 ind % pow2 (pbits - j));
if j = 0 then () else begin
bn_get_bits_limb_aux_lemma n ind;
if i + 1 < nLen then begin
let p2 = n.[i + 1] <<. (size (pbits - j)) in
calc (==) {
v p2 % pow2 (pbits - j);
(==) { }
v n.[i + 1] * pow2 (pbits - j) % pow2 pbits % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (v n.[i + 1] * pow2 (pbits - j)) (pbits - j) pbits }
v n.[i + 1] * pow2 (pbits - j) % pow2 (pbits - j);
(==) { Math.Lemmas.multiple_modulo_lemma (v n.[i + 1]) (pow2 (pbits - j)) }
0;
};
let p3 = p1 |. p2 in
logor_disjoint p1 p2 (pbits - j);
assert (v p3 == v p1 + v p2);
bn_eval_index n (i + 1);
assert (res == v p1 + v p2);
assert (ind / bits t + 1 < nLen && 0 < ind % bits t) end
else begin
bn_eval_bound n nLen;
assert (bn_v n < pow2 (nLen * pbits));
Math.Lemmas.lemma_div_lt_nat (bn_v n) (nLen * pbits) ((i + 1) * pbits);
Math.Lemmas.pow2_minus (nLen * pbits) ((i + 1) * pbits);
assert (bn_v n / pow2 ((i + 1) * pbits) < pow2 0);
assert_norm (pow2 0 = 1);
assert (res == v p1)
end
end
#pop-options
val bn_get_bits:
#t:limb_t
-> #nLen:size_nat
-> n:lbignum t nLen
-> i:size_nat
-> l:size_nat{l < bits t /\ i / bits t < nLen} ->
limb t | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
n: Hacl.Spec.Bignum.Definitions.lbignum t nLen ->
i: Lib.IntTypes.size_nat ->
l: Lib.IntTypes.size_nat{l < Lib.IntTypes.bits t /\ i / Lib.IntTypes.bits t < nLen}
-> Hacl.Spec.Bignum.Definitions.limb t | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.bits",
"Prims.op_Division",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.SEC",
"Hacl.Spec.Bignum.Lib.bn_get_bits_limb",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Subtraction_Dot",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.IntTypes.uint",
"Lib.IntTypes.size",
"Hacl.Spec.Bignum.Definitions.limb"
] | [] | false | false | false | false | false | let bn_get_bits #t #nLen n ind l =
| let mask_l = (uint #t #SEC 1 <<. size l) -. uint #t 1 in
bn_get_bits_limb n ind &. mask_l | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.bn_low_bound_bits | val bn_low_bound_bits:
#t:limb_t
-> #len:size_pos{bits t * len <= max_size_t}
-> b:lbignum t len ->
res:size_nat{res / bits t < len} | val bn_low_bound_bits:
#t:limb_t
-> #len:size_pos{bits t * len <= max_size_t}
-> b:lbignum t len ->
res:size_nat{res / bits t < len} | let bn_low_bound_bits #t #len b =
bits t * bn_get_top_index b | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 29,
"end_line": 379,
"start_col": 0,
"start_line": 378
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2)
let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2)
val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t
let bn_get_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[i] j
val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j))
let bn_get_ith_bit_aux_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = b.[i] >>. size j in
calc (==) {
v b.[i] / pow2 j;
(==) { bn_eval_index b i }
(bn_v b / pow2 (pbits * i) % pow2 pbits) / pow2 j;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b / pow2 (pbits * i)) j pbits }
(bn_v b / pow2 (pbits * i) / pow2 j) % pow2 (pbits - j);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b) (pow2 (pbits * i)) (pow2 j) }
(bn_v b / (pow2 (pbits * i) * pow2 j)) % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_plus (pbits * i) j }
(bn_v b / pow2 (pbits * i + j)) % pow2 (pbits - j);
(==) { Math.Lemmas.euclidean_div_axiom ind pbits }
(bn_v b / pow2 ind) % pow2 (pbits - j);
};
assert (v res == (bn_v b / pow2 ind) % pow2 (pbits - j))
val bn_get_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} ->
Lemma (v (bn_get_ith_bit b i) == (bn_v b / pow2 i % 2))
let bn_get_ith_bit_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = limb_get_ith_bit b.[i] j in
limb_get_ith_bit_lemma b.[i] j;
calc (==) {
v b.[i] / pow2 j % 2;
(==) { bn_get_ith_bit_aux_lemma b ind }
(bn_v b / pow2 ind) % pow2 (pbits - j) % 2;
(==) { assert_norm (pow2 1 = 2);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 ind) 1 (pbits - j) }
(bn_v b / pow2 ind) % 2;
};
assert (v res == bn_v b / pow2 ind % 2)
val bn_set_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> lbignum t len
let bn_set_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
let inp = input.[i] <- input.[i] |. (uint #t 1 <<. size j) in
inp
val bn_set_ith_bit_lemma_aux: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a + b * pow2 c < pow2 (c + d) /\ a < pow2 c)
(ensures b < pow2 d)
let bn_set_ith_bit_lemma_aux a b c d =
Math.Lemmas.lemma_div_lt_nat (a + b * pow2 c) (c + d) c;
assert ((a + b * pow2 c) / pow2 c < pow2 d);
Math.Lemmas.lemma_div_plus a b (pow2 c);
assert (a / pow2 c + b < pow2 d);
Math.Lemmas.small_division_lemma_1 a (pow2 c)
val bn_lt_pow2_index_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} -> Lemma
(requires bn_v b < pow2 ind)
(ensures (let i = ind / bits t in v b.[i] < pow2 (ind % bits t) /\
bn_v b == bn_v (slice b 0 i) + pow2 (i * bits t) * v b.[i] /\
bn_v (slice b (i + 1) len) = 0))
let bn_lt_pow2_index_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
Math.Lemmas.euclidean_division_definition ind (pbits);
assert (bn_v b < pow2 (i * pbits + j));
Math.Lemmas.pow2_lt_compat (i * pbits + pbits) (i * pbits + j);
assert (bn_v b < pow2 (i * pbits + pbits));
bn_eval_split_i #t #len b (i + 1);
bn_eval_bound (slice b 0 (i + 1)) (i + 1);
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 (i + 1))) (bn_v (slice b (i + 1) len)) (pbits * (i + 1)) 0;
assert (bn_v b == bn_v (slice b 0 (i + 1)));
bn_eval_split_i #t #(i + 1) (slice b 0 (i + 1)) i;
bn_eval1 (slice b i (i + 1));
assert (bn_v b == bn_v (slice b 0 i) + pow2 (i * pbits) * v b.[i]);
bn_eval_bound #t #i (slice b 0 i) i;
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 i)) (v b.[i]) (i * pbits) j;
assert (v b.[i] < pow2 j)
val bn_set_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> Lemma
(requires bn_v b < pow2 i)
(ensures bn_v (bn_set_ith_bit b i) == bn_v b + pow2 i)
let bn_set_ith_bit_lemma #t #len input ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
bn_lt_pow2_index_lemma #t #len input ind;
assert (v input.[i] < pow2 j);
let b = uint #t 1 <<. size j in
let inp = input.[i] <- input.[i] |. b in
FStar.Math.Lemmas.pow2_lt_compat pbits j;
FStar.Math.Lemmas.modulo_lemma (pow2 j) (pow2 pbits);
assert (v b == pow2 j);
logor_disjoint (input.[i]) b j;
assert (v inp.[i] == v input.[i] + v b);
calc (==) {
bn_v inp;
(==) { bn_eval_split_i #t #len inp (i + 1);
bn_eval_extensionality_j (slice inp (i + 1) len) (slice input (i + 1) len) (len - i - 1) }
bn_v (slice inp 0 (i + 1));
(==) { bn_eval_split_i #t #(i + 1) (slice inp 0 (i + 1)) i }
bn_v (slice inp 0 i) + pow2 (i * pbits) * bn_v (slice inp i (i + 1));
(==) { bn_eval1 (slice inp i (i + 1)) }
bn_v (slice inp 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { bn_eval_extensionality_j input inp i }
bn_v (slice input 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { }
bn_v (slice input 0 i) + pow2 (i * pbits) * (v input.[i] + v b);
(==) { Math.Lemmas.distributivity_add_right (pow2 (i * pbits)) (v input.[i]) (v b) }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 (i * pbits) * v b;
(==) { Math.Lemmas.pow2_plus (i * pbits) j; Math.Lemmas.euclidean_division_definition ind pbits }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 ind;
(==) { }
bn_v input + pow2 ind;
}
///
/// % pow2 and / pow2
///
val bn_div_pow2: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i <= len} -> lbignum t (len - i)
let bn_div_pow2 #t #len b i =
slice b i len
val bn_div_pow2_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i < len} ->
Lemma (bn_v (bn_div_pow2 b i) == bn_v b / pow2 (bits t * i))
let bn_div_pow2_lemma #t #len c i =
let pbits = bits t in
calc (==) {
bn_v c / pow2 (pbits * i);
(==) { bn_eval_split_i c i }
(bn_v (slice c 0 i) + pow2 (pbits * i) * bn_v (slice c i len)) / pow2 (pbits * i);
(==) { Math.Lemmas.division_addition_lemma (bn_v (slice c 0 i)) (pow2 (pbits * i)) (bn_v (slice c i len)) }
bn_v (slice c 0 i) / pow2 (pbits * i) + bn_v (slice c i len);
(==) { bn_eval_bound (slice c 0 i) i; Math.Lemmas.small_division_lemma_1 (bn_v (slice c 0 i)) (pow2 (pbits * i)) }
bn_v (slice c i len);
};
assert (bn_v (slice c i len) == bn_v c / pow2 (pbits * i))
val bn_mod_pow2: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} -> lbignum t i
let bn_mod_pow2 #t #aLen a i = sub a 0 i
val bn_mod_pow2_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} ->
Lemma (bn_v (bn_mod_pow2 a i) == bn_v a % pow2 (bits t * i))
let bn_mod_pow2_lemma #t #aLen a i =
let pbits = bits t in
calc (==) {
bn_v a % pow2 (pbits * i);
(==) { bn_eval_split_i a i }
(bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v (slice a i aLen)) % pow2 (pbits * i);
(==) { Math.Lemmas.modulo_addition_lemma (bn_v (slice a 0 i)) (pow2 (pbits * i)) (bn_v (slice a i aLen)) }
(bn_v (slice a 0 i)) % pow2 (pbits * i);
(==) { bn_eval_bound (slice a 0 i) i; Math.Lemmas.small_mod (bn_v (slice a 0 i)) (pow2 (pbits * i)) }
bn_v (slice a 0 i);
}
///
/// Conditional swap
///
//the same as in curve25519
val lemma_cswap2_step:
#t:limb_t
-> bit:limb t{v bit <= 1}
-> p1:limb t
-> p2:limb t ->
Lemma
(let mask = uint #t 0 -. bit in
let dummy = mask &. (p1 ^. p2) in
let p1' = p1 ^. dummy in
let p2' = p2 ^. dummy in
if v bit = 1 then p1' == p2 /\ p2' == p1 else p1' == p1 /\ p2' == p2)
let lemma_cswap2_step #t bit p1 p2 =
let mask = uint #t 0 -. bit in
assert (v bit == 0 ==> v mask == 0);
assert (v bit == 1 ==> v mask == pow2 (bits t) - 1);
let dummy = mask &. (p1 ^. p2) in
logand_lemma mask (p1 ^. p2);
assert (v bit == 1 ==> v dummy == v (p1 ^. p2));
assert (v bit == 0 ==> v dummy == 0);
let p1' = p1 ^. dummy in
assert (v dummy == v (if v bit = 1 then (p1 ^. p2) else uint #t 0));
logxor_lemma p1 p2;
let p2' = p2 ^. dummy in
logxor_lemma p2 p1
val cswap2_f:
#t:limb_t
-> #len:size_nat
-> mask:limb t
-> i:nat{i < len}
-> tuple2 (lbignum t len) (lbignum t len) ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2_f #t #len mask i (p1, p2) =
let dummy = mask &. (p1.[i] ^. p2.[i]) in
let p1 = p1.[i] <- p1.[i] ^. dummy in
let p2 = p2.[i] <- p2.[i] ^. dummy in
(p1, p2)
val cswap2:
#t:limb_t
-> #len:size_nat
-> bit:limb t
-> b1:lbignum t len
-> b2:lbignum t len ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2 #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.repeati len (cswap2_f #t #len mask) (b1, b2)
val cswap2_lemma:
#t:limb_t
-> #len:size_nat
-> bit:limb t{v bit <= 1}
-> b1:lbignum t len
-> b2:lbignum t len ->
Lemma (let (p1, p2) = cswap2 bit b1 b2 in
(if v bit = 1 then p1 == b2 /\ p2 == b1 else p1 == b1 /\ p2 == b2))
let cswap2_lemma #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.eq_repeati0 len (cswap2_f #t #len mask) (b1, b2);
let (p1, p2) =
Loops.repeati_inductive #(tuple2 (lbignum t len) (lbignum t len)) len
(fun i (p1, p2) ->
(p1, p2) == Loops.repeati i (cswap2_f #t #len mask) (b1, b2) /\
(forall (k:nat{k < i}).
(if v bit = 1 then p1.[k] == b2.[k] /\ p2.[k] == b1.[k] else p1.[k] == b1.[k] /\ p2.[k] == b2.[k])) /\
(forall (k:nat{i <= k /\ k < len}). p1.[k] == b1.[k] /\ p2.[k] == b2.[k]))
(fun i (p1, p2) ->
Loops.unfold_repeati (i + 1) (cswap2_f #t #len mask) (b1, b2) i;
lemma_cswap2_step bit p1.[i] p2.[i];
cswap2_f #t #len mask i (p1, p2)) (b1, b2) in
assert (if v bit = 1 then (eq_intro p1 b2; p1 == b2) else (eq_intro p1 b1; p1 == b1));
assert (if v bit = 1 then (eq_intro p2 b1; p2 == b1) else (eq_intro p2 b2; p2 == b2));
//eq_intro p1 (if v bit = 1 then b2 else b1);
//eq_intro p2 (if v bit = 1 then b1 else b2);
()
let bn_get_top_index_t (len:size_nat) (i:nat{i <= len}) = x:nat{x < len}
val bn_get_top_index_f:
#t:limb_t
-> #len:size_nat
-> b:lbignum t len
-> i:nat{i < len}
-> priv:bn_get_top_index_t len i ->
bn_get_top_index_t len (i + 1)
let bn_get_top_index_f #t #len b i priv =
let mask = eq_mask b.[i] (zeros t SEC) in
if v mask = 0 then i else priv
val bn_get_top_index: #t:limb_t -> #len:size_pos -> b:lbignum t len -> res:size_nat{res < len}
let bn_get_top_index #t #len b =
Loops.repeat_gen len (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0
val bn_get_top_index_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (let ind = bn_get_top_index #t #len b in
ind < len /\ (ind > 0 ==> v b.[ind] <> 0) /\ (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0))
let bn_get_top_index_lemma #t #len b =
Loops.eq_repeat_gen0 len (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0;
let res =
Loops.repeati_inductive #size_nat len
(fun i priv ->
priv == Loops.repeat_gen i (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0 /\
priv < len /\ (priv > 0 ==> v b.[priv] <> 0) /\ (forall (k:nat{priv < k /\ k < i}). v b.[k] = 0))
(fun i priv ->
Loops.unfold_repeat_gen (i + 1) (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0 i;
let mask = eq_mask b.[i] (zeros t SEC) in
eq_mask_lemma b.[i] (zeros t SEC);
assert (if v mask = 0 then v b.[i] <> 0 else v b.[i] = 0);
let res = if v mask = 0 then i else priv in
res) 0 in
()
val bn_get_top_index_eval_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len -> ind:nat -> Lemma
(requires
ind < len /\ (ind > 0 ==> v b.[ind] <> 0) /\ (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0))
(ensures
bn_v b == bn_v (slice b 0 ind) + pow2 (bits t * ind) * v b.[ind])
let bn_get_top_index_eval_lemma #t #len b ind =
let pbits = bits t in
assert (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0);
bn_eval_split_i b (ind + 1);
assert (bn_v b == bn_v (slice b 0 (ind + 1)) + pow2 (pbits * (ind + 1)) * bn_v (slice b (ind + 1) len));
eq_intro (slice b (ind + 1) len) (create (len - ind - 1) (uint #t 0));
bn_eval_zeroes #t (len - ind - 1) (len - ind - 1);
assert (bn_v b == bn_v (slice b 0 (ind + 1)));
bn_eval_split_i (slice b 0 (ind + 1)) ind;
assert (bn_v b == bn_v (slice b 0 ind) + pow2 (pbits * ind) * bn_v (slice b ind (ind + 1)));
bn_eval1 (slice b ind (ind + 1));
assert (bn_v b == bn_v (slice b 0 ind) + pow2 (pbits * ind) * v b.[ind])
val bn_low_bound_bits:
#t:limb_t
-> #len:size_pos{bits t * len <= max_size_t}
-> b:lbignum t len ->
res:size_nat{res / bits t < len} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b: Hacl.Spec.Bignum.Definitions.lbignum t len
-> res: Lib.IntTypes.size_nat{res / Lib.IntTypes.bits t < len} | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.bits",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Lib.bn_get_top_index",
"Lib.IntTypes.size_nat",
"Prims.op_LessThan",
"Prims.op_Division"
] | [] | false | false | false | false | false | let bn_low_bound_bits #t #len b =
| bits t * bn_get_top_index b | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.bn_low_bound_bits_lemma | val bn_low_bound_bits_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len -> Lemma
(requires 1 < bn_v b /\ bits t * len <= max_size_t /\ bn_v b % 2 = 1)
(ensures pow2 (bn_low_bound_bits b) < bn_v b) | val bn_low_bound_bits_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len -> Lemma
(requires 1 < bn_v b /\ bits t * len <= max_size_t /\ bn_v b % 2 = 1)
(ensures pow2 (bn_low_bound_bits b) < bn_v b) | let bn_low_bound_bits_lemma #t #len b =
let ind = bn_get_top_index #t #len b in
bn_get_top_index_lemma #t #len b;
bn_get_top_index_eval_lemma #t #len b ind;
assert (pow2 (bn_low_bound_bits b) <= bn_v b);
if ind = 0 then
assert_norm (pow2 0 = 1)
else
Math.Lemmas.pow2_multiplication_modulo_lemma_1 1 1 (bn_low_bound_bits b) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 76,
"end_line": 394,
"start_col": 0,
"start_line": 386
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2)
let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2)
val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t
let bn_get_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[i] j
val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j))
let bn_get_ith_bit_aux_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = b.[i] >>. size j in
calc (==) {
v b.[i] / pow2 j;
(==) { bn_eval_index b i }
(bn_v b / pow2 (pbits * i) % pow2 pbits) / pow2 j;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b / pow2 (pbits * i)) j pbits }
(bn_v b / pow2 (pbits * i) / pow2 j) % pow2 (pbits - j);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b) (pow2 (pbits * i)) (pow2 j) }
(bn_v b / (pow2 (pbits * i) * pow2 j)) % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_plus (pbits * i) j }
(bn_v b / pow2 (pbits * i + j)) % pow2 (pbits - j);
(==) { Math.Lemmas.euclidean_div_axiom ind pbits }
(bn_v b / pow2 ind) % pow2 (pbits - j);
};
assert (v res == (bn_v b / pow2 ind) % pow2 (pbits - j))
val bn_get_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} ->
Lemma (v (bn_get_ith_bit b i) == (bn_v b / pow2 i % 2))
let bn_get_ith_bit_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = limb_get_ith_bit b.[i] j in
limb_get_ith_bit_lemma b.[i] j;
calc (==) {
v b.[i] / pow2 j % 2;
(==) { bn_get_ith_bit_aux_lemma b ind }
(bn_v b / pow2 ind) % pow2 (pbits - j) % 2;
(==) { assert_norm (pow2 1 = 2);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 ind) 1 (pbits - j) }
(bn_v b / pow2 ind) % 2;
};
assert (v res == bn_v b / pow2 ind % 2)
val bn_set_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> lbignum t len
let bn_set_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
let inp = input.[i] <- input.[i] |. (uint #t 1 <<. size j) in
inp
val bn_set_ith_bit_lemma_aux: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a + b * pow2 c < pow2 (c + d) /\ a < pow2 c)
(ensures b < pow2 d)
let bn_set_ith_bit_lemma_aux a b c d =
Math.Lemmas.lemma_div_lt_nat (a + b * pow2 c) (c + d) c;
assert ((a + b * pow2 c) / pow2 c < pow2 d);
Math.Lemmas.lemma_div_plus a b (pow2 c);
assert (a / pow2 c + b < pow2 d);
Math.Lemmas.small_division_lemma_1 a (pow2 c)
val bn_lt_pow2_index_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} -> Lemma
(requires bn_v b < pow2 ind)
(ensures (let i = ind / bits t in v b.[i] < pow2 (ind % bits t) /\
bn_v b == bn_v (slice b 0 i) + pow2 (i * bits t) * v b.[i] /\
bn_v (slice b (i + 1) len) = 0))
let bn_lt_pow2_index_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
Math.Lemmas.euclidean_division_definition ind (pbits);
assert (bn_v b < pow2 (i * pbits + j));
Math.Lemmas.pow2_lt_compat (i * pbits + pbits) (i * pbits + j);
assert (bn_v b < pow2 (i * pbits + pbits));
bn_eval_split_i #t #len b (i + 1);
bn_eval_bound (slice b 0 (i + 1)) (i + 1);
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 (i + 1))) (bn_v (slice b (i + 1) len)) (pbits * (i + 1)) 0;
assert (bn_v b == bn_v (slice b 0 (i + 1)));
bn_eval_split_i #t #(i + 1) (slice b 0 (i + 1)) i;
bn_eval1 (slice b i (i + 1));
assert (bn_v b == bn_v (slice b 0 i) + pow2 (i * pbits) * v b.[i]);
bn_eval_bound #t #i (slice b 0 i) i;
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 i)) (v b.[i]) (i * pbits) j;
assert (v b.[i] < pow2 j)
val bn_set_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> Lemma
(requires bn_v b < pow2 i)
(ensures bn_v (bn_set_ith_bit b i) == bn_v b + pow2 i)
let bn_set_ith_bit_lemma #t #len input ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
bn_lt_pow2_index_lemma #t #len input ind;
assert (v input.[i] < pow2 j);
let b = uint #t 1 <<. size j in
let inp = input.[i] <- input.[i] |. b in
FStar.Math.Lemmas.pow2_lt_compat pbits j;
FStar.Math.Lemmas.modulo_lemma (pow2 j) (pow2 pbits);
assert (v b == pow2 j);
logor_disjoint (input.[i]) b j;
assert (v inp.[i] == v input.[i] + v b);
calc (==) {
bn_v inp;
(==) { bn_eval_split_i #t #len inp (i + 1);
bn_eval_extensionality_j (slice inp (i + 1) len) (slice input (i + 1) len) (len - i - 1) }
bn_v (slice inp 0 (i + 1));
(==) { bn_eval_split_i #t #(i + 1) (slice inp 0 (i + 1)) i }
bn_v (slice inp 0 i) + pow2 (i * pbits) * bn_v (slice inp i (i + 1));
(==) { bn_eval1 (slice inp i (i + 1)) }
bn_v (slice inp 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { bn_eval_extensionality_j input inp i }
bn_v (slice input 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { }
bn_v (slice input 0 i) + pow2 (i * pbits) * (v input.[i] + v b);
(==) { Math.Lemmas.distributivity_add_right (pow2 (i * pbits)) (v input.[i]) (v b) }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 (i * pbits) * v b;
(==) { Math.Lemmas.pow2_plus (i * pbits) j; Math.Lemmas.euclidean_division_definition ind pbits }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 ind;
(==) { }
bn_v input + pow2 ind;
}
///
/// % pow2 and / pow2
///
val bn_div_pow2: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i <= len} -> lbignum t (len - i)
let bn_div_pow2 #t #len b i =
slice b i len
val bn_div_pow2_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i < len} ->
Lemma (bn_v (bn_div_pow2 b i) == bn_v b / pow2 (bits t * i))
let bn_div_pow2_lemma #t #len c i =
let pbits = bits t in
calc (==) {
bn_v c / pow2 (pbits * i);
(==) { bn_eval_split_i c i }
(bn_v (slice c 0 i) + pow2 (pbits * i) * bn_v (slice c i len)) / pow2 (pbits * i);
(==) { Math.Lemmas.division_addition_lemma (bn_v (slice c 0 i)) (pow2 (pbits * i)) (bn_v (slice c i len)) }
bn_v (slice c 0 i) / pow2 (pbits * i) + bn_v (slice c i len);
(==) { bn_eval_bound (slice c 0 i) i; Math.Lemmas.small_division_lemma_1 (bn_v (slice c 0 i)) (pow2 (pbits * i)) }
bn_v (slice c i len);
};
assert (bn_v (slice c i len) == bn_v c / pow2 (pbits * i))
val bn_mod_pow2: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} -> lbignum t i
let bn_mod_pow2 #t #aLen a i = sub a 0 i
val bn_mod_pow2_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} ->
Lemma (bn_v (bn_mod_pow2 a i) == bn_v a % pow2 (bits t * i))
let bn_mod_pow2_lemma #t #aLen a i =
let pbits = bits t in
calc (==) {
bn_v a % pow2 (pbits * i);
(==) { bn_eval_split_i a i }
(bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v (slice a i aLen)) % pow2 (pbits * i);
(==) { Math.Lemmas.modulo_addition_lemma (bn_v (slice a 0 i)) (pow2 (pbits * i)) (bn_v (slice a i aLen)) }
(bn_v (slice a 0 i)) % pow2 (pbits * i);
(==) { bn_eval_bound (slice a 0 i) i; Math.Lemmas.small_mod (bn_v (slice a 0 i)) (pow2 (pbits * i)) }
bn_v (slice a 0 i);
}
///
/// Conditional swap
///
//the same as in curve25519
val lemma_cswap2_step:
#t:limb_t
-> bit:limb t{v bit <= 1}
-> p1:limb t
-> p2:limb t ->
Lemma
(let mask = uint #t 0 -. bit in
let dummy = mask &. (p1 ^. p2) in
let p1' = p1 ^. dummy in
let p2' = p2 ^. dummy in
if v bit = 1 then p1' == p2 /\ p2' == p1 else p1' == p1 /\ p2' == p2)
let lemma_cswap2_step #t bit p1 p2 =
let mask = uint #t 0 -. bit in
assert (v bit == 0 ==> v mask == 0);
assert (v bit == 1 ==> v mask == pow2 (bits t) - 1);
let dummy = mask &. (p1 ^. p2) in
logand_lemma mask (p1 ^. p2);
assert (v bit == 1 ==> v dummy == v (p1 ^. p2));
assert (v bit == 0 ==> v dummy == 0);
let p1' = p1 ^. dummy in
assert (v dummy == v (if v bit = 1 then (p1 ^. p2) else uint #t 0));
logxor_lemma p1 p2;
let p2' = p2 ^. dummy in
logxor_lemma p2 p1
val cswap2_f:
#t:limb_t
-> #len:size_nat
-> mask:limb t
-> i:nat{i < len}
-> tuple2 (lbignum t len) (lbignum t len) ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2_f #t #len mask i (p1, p2) =
let dummy = mask &. (p1.[i] ^. p2.[i]) in
let p1 = p1.[i] <- p1.[i] ^. dummy in
let p2 = p2.[i] <- p2.[i] ^. dummy in
(p1, p2)
val cswap2:
#t:limb_t
-> #len:size_nat
-> bit:limb t
-> b1:lbignum t len
-> b2:lbignum t len ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2 #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.repeati len (cswap2_f #t #len mask) (b1, b2)
val cswap2_lemma:
#t:limb_t
-> #len:size_nat
-> bit:limb t{v bit <= 1}
-> b1:lbignum t len
-> b2:lbignum t len ->
Lemma (let (p1, p2) = cswap2 bit b1 b2 in
(if v bit = 1 then p1 == b2 /\ p2 == b1 else p1 == b1 /\ p2 == b2))
let cswap2_lemma #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.eq_repeati0 len (cswap2_f #t #len mask) (b1, b2);
let (p1, p2) =
Loops.repeati_inductive #(tuple2 (lbignum t len) (lbignum t len)) len
(fun i (p1, p2) ->
(p1, p2) == Loops.repeati i (cswap2_f #t #len mask) (b1, b2) /\
(forall (k:nat{k < i}).
(if v bit = 1 then p1.[k] == b2.[k] /\ p2.[k] == b1.[k] else p1.[k] == b1.[k] /\ p2.[k] == b2.[k])) /\
(forall (k:nat{i <= k /\ k < len}). p1.[k] == b1.[k] /\ p2.[k] == b2.[k]))
(fun i (p1, p2) ->
Loops.unfold_repeati (i + 1) (cswap2_f #t #len mask) (b1, b2) i;
lemma_cswap2_step bit p1.[i] p2.[i];
cswap2_f #t #len mask i (p1, p2)) (b1, b2) in
assert (if v bit = 1 then (eq_intro p1 b2; p1 == b2) else (eq_intro p1 b1; p1 == b1));
assert (if v bit = 1 then (eq_intro p2 b1; p2 == b1) else (eq_intro p2 b2; p2 == b2));
//eq_intro p1 (if v bit = 1 then b2 else b1);
//eq_intro p2 (if v bit = 1 then b1 else b2);
()
let bn_get_top_index_t (len:size_nat) (i:nat{i <= len}) = x:nat{x < len}
val bn_get_top_index_f:
#t:limb_t
-> #len:size_nat
-> b:lbignum t len
-> i:nat{i < len}
-> priv:bn_get_top_index_t len i ->
bn_get_top_index_t len (i + 1)
let bn_get_top_index_f #t #len b i priv =
let mask = eq_mask b.[i] (zeros t SEC) in
if v mask = 0 then i else priv
val bn_get_top_index: #t:limb_t -> #len:size_pos -> b:lbignum t len -> res:size_nat{res < len}
let bn_get_top_index #t #len b =
Loops.repeat_gen len (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0
val bn_get_top_index_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (let ind = bn_get_top_index #t #len b in
ind < len /\ (ind > 0 ==> v b.[ind] <> 0) /\ (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0))
let bn_get_top_index_lemma #t #len b =
Loops.eq_repeat_gen0 len (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0;
let res =
Loops.repeati_inductive #size_nat len
(fun i priv ->
priv == Loops.repeat_gen i (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0 /\
priv < len /\ (priv > 0 ==> v b.[priv] <> 0) /\ (forall (k:nat{priv < k /\ k < i}). v b.[k] = 0))
(fun i priv ->
Loops.unfold_repeat_gen (i + 1) (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0 i;
let mask = eq_mask b.[i] (zeros t SEC) in
eq_mask_lemma b.[i] (zeros t SEC);
assert (if v mask = 0 then v b.[i] <> 0 else v b.[i] = 0);
let res = if v mask = 0 then i else priv in
res) 0 in
()
val bn_get_top_index_eval_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len -> ind:nat -> Lemma
(requires
ind < len /\ (ind > 0 ==> v b.[ind] <> 0) /\ (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0))
(ensures
bn_v b == bn_v (slice b 0 ind) + pow2 (bits t * ind) * v b.[ind])
let bn_get_top_index_eval_lemma #t #len b ind =
let pbits = bits t in
assert (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0);
bn_eval_split_i b (ind + 1);
assert (bn_v b == bn_v (slice b 0 (ind + 1)) + pow2 (pbits * (ind + 1)) * bn_v (slice b (ind + 1) len));
eq_intro (slice b (ind + 1) len) (create (len - ind - 1) (uint #t 0));
bn_eval_zeroes #t (len - ind - 1) (len - ind - 1);
assert (bn_v b == bn_v (slice b 0 (ind + 1)));
bn_eval_split_i (slice b 0 (ind + 1)) ind;
assert (bn_v b == bn_v (slice b 0 ind) + pow2 (pbits * ind) * bn_v (slice b ind (ind + 1)));
bn_eval1 (slice b ind (ind + 1));
assert (bn_v b == bn_v (slice b 0 ind) + pow2 (pbits * ind) * v b.[ind])
val bn_low_bound_bits:
#t:limb_t
-> #len:size_pos{bits t * len <= max_size_t}
-> b:lbignum t len ->
res:size_nat{res / bits t < len}
let bn_low_bound_bits #t #len b =
bits t * bn_get_top_index b
val bn_low_bound_bits_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len -> Lemma
(requires 1 < bn_v b /\ bits t * len <= max_size_t /\ bn_v b % 2 = 1)
(ensures pow2 (bn_low_bound_bits b) < bn_v b) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b: Hacl.Spec.Bignum.Definitions.lbignum t len
-> FStar.Pervasives.Lemma
(requires
1 < Hacl.Spec.Bignum.Definitions.bn_v b /\
Lib.IntTypes.bits t * len <= Lib.IntTypes.max_size_t /\
Hacl.Spec.Bignum.Definitions.bn_v b % 2 = 1)
(ensures
Prims.pow2 (Hacl.Spec.Bignum.Lib.bn_low_bound_bits b) < Hacl.Spec.Bignum.Definitions.bn_v b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Equality",
"Prims.int",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.pow2",
"Prims.bool",
"FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1",
"Hacl.Spec.Bignum.Lib.bn_low_bound_bits",
"Prims.unit",
"Prims._assert",
"Prims.op_LessThanOrEqual",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Hacl.Spec.Bignum.Lib.bn_get_top_index_eval_lemma",
"Hacl.Spec.Bignum.Lib.bn_get_top_index_lemma",
"Prims.nat",
"Prims.op_Subtraction",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Lib.bn_get_top_index"
] | [] | false | false | true | false | false | let bn_low_bound_bits_lemma #t #len b =
| let ind = bn_get_top_index #t #len b in
bn_get_top_index_lemma #t #len b;
bn_get_top_index_eval_lemma #t #len b ind;
assert (pow2 (bn_low_bound_bits b) <= bn_v b);
if ind = 0
then assert_norm (pow2 0 = 1)
else Math.Lemmas.pow2_multiplication_modulo_lemma_1 1 1 (bn_low_bound_bits b) | false |
Hacl.Impl.K256.Qinv.fst | Hacl.Impl.K256.Qinv.qinv3 | val qinv3 (tmp x14: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h x14 /\ disjoint tmp x14 /\
qe_lt_q h x14)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r0_r1 (qas_nat h0 x14) /\
qe_lt_q h1 tmp) | val qinv3 (tmp x14: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h x14 /\ disjoint tmp x14 /\
qe_lt_q h x14)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r0_r1 (qas_nat h0 x14) /\
qe_lt_q h1 tmp) | let qinv3 tmp x14 =
push_frame ();
let x56 = create_qelem () in
let h0 = ST.get () in
qsquare_times tmp x14 14ul;
qmul tmp tmp x14; //tmp = x28
let h1 = ST.get () in
assert (qas_nat h1 tmp == S.qmul (SI.qsquare_times (qas_nat h0 x14) 14) (qas_nat h0 x14));
qsquare_times x56 tmp 28ul;
qmul x56 x56 tmp;
let h2 = ST.get () in
assert (qas_nat h2 x56 == S.qmul (SI.qsquare_times (qas_nat h1 tmp) 28) (qas_nat h1 tmp));
qsquare_times tmp x56 56ul; //tmp = r0
qmul tmp tmp x56;
let h3 = ST.get () in
assert (qas_nat h3 tmp == S.qmul (SI.qsquare_times (qas_nat h2 x56) 56) (qas_nat h2 x56));
qsquare_times_in_place tmp 14ul; //tmp = r1
qmul tmp tmp x14;
let h4 = ST.get () in
assert (qas_nat h4 tmp == S.qmul (SI.qsquare_times (qas_nat h3 tmp) 14) (qas_nat h0 x14));
pop_frame () | {
"file_name": "code/k256/Hacl.Impl.K256.Qinv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 14,
"end_line": 229,
"start_col": 0,
"start_line": 205
} | module Hacl.Impl.K256.Qinv
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.K256.Scalar
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Spec.K256
module SI = Hacl.Spec.K256.Qinv
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module SD = Hacl.Spec.Bignum.Definitions
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
unfold
let linv_ctx (a:LSeq.lseq uint64 0) : Type0 = True
unfold
let linv (a:LSeq.lseq uint64 4) : Type0 =
SD.bn_v #U64 #4 a < S.q
unfold
let refl (a:LSeq.lseq uint64 4{linv a}) : GTot S.qelem =
SD.bn_v #U64 #4 a
inline_for_extraction noextract
let mk_to_k256_scalar_comm_monoid : BE.to_comm_monoid U64 4ul 0ul = {
BE.a_spec = S.qelem;
BE.comm_monoid = SI.nat_mod_comm_monoid;
BE.linv_ctx = linv_ctx;
BE.linv = linv;
BE.refl = refl;
}
inline_for_extraction noextract
val one_mod : BE.lone_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let one_mod ctx one = make_u64_4 one (u64 1, u64 0, u64 0, u64 0)
inline_for_extraction noextract
val mul_mod : BE.lmul_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let mul_mod ctx x y xy = qmul xy x y
inline_for_extraction noextract
val sqr_mod : BE.lsqr_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let sqr_mod ctx x xx = qsqr xx x
inline_for_extraction noextract
let mk_k256_scalar_concrete_ops : BE.concrete_ops U64 4ul 0ul = {
BE.to = mk_to_k256_scalar_comm_monoid;
BE.lone = one_mod;
BE.lmul = mul_mod;
BE.lsqr = sqr_mod;
}
val qsquare_times_in_place (out:qelem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ qe_lt_q h out)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\ qe_lt_q h1 out /\
qas_nat h1 out == SI.qsquare_times (qas_nat h0 out) (v b))
[@CInline]
let qsquare_times_in_place out b =
let h0 = ST.get () in
SE.exp_pow2_lemma SI.mk_nat_mod_concrete_ops (qas_nat h0 out) (v b);
BE.lexp_pow2_in_place 4ul 0ul mk_k256_scalar_concrete_ops (null uint64) out b
val qsquare_times (out a:qelem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ live h a /\ disjoint out a /\
qe_lt_q h a)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\ qe_lt_q h1 a /\
qas_nat h1 out == SI.qsquare_times (qas_nat h0 a) (v b))
[@CInline]
let qsquare_times out a b =
let h0 = ST.get () in
SE.exp_pow2_lemma SI.mk_nat_mod_concrete_ops (qas_nat h0 a) (v b);
BE.lexp_pow2 4ul 0ul mk_k256_scalar_concrete_ops (null uint64) a b out
inline_for_extraction noextract
val qinv1 (f x_10 x_11 x_101 x_111 x_1001 x_1011 x_1101:qelem) : Stack unit
(requires fun h ->
live h f /\ live h x_10 /\ live h x_11 /\ live h x_101 /\
live h x_111 /\ live h x_1001 /\ live h x_1011 /\ live h x_1101 /\
disjoint f x_10 /\ disjoint f x_11 /\ disjoint f x_101 /\
disjoint f x_111 /\ disjoint f x_1001 /\ disjoint f x_1011 /\
disjoint f x_1101 /\ disjoint x_10 x_11 /\ disjoint x_10 x_101 /\
disjoint x_10 x_111 /\ disjoint x_10 x_1001 /\ disjoint x_10 x_1011 /\
disjoint x_10 x_1101 /\ disjoint x_11 x_101 /\ disjoint x_11 x_111 /\
disjoint x_11 x_1001 /\ disjoint x_11 x_1011 /\ disjoint x_11 x_1101 /\
disjoint x_101 x_111 /\ disjoint x_101 x_1001 /\ disjoint x_101 x_1011 /\
disjoint x_101 x_1101 /\ disjoint x_111 x_1001 /\ disjoint x_111 x_1011 /\
disjoint x_111 x_1101 /\ disjoint x_1001 x_1011 /\ disjoint x_1001 x_1101 /\
disjoint x_1011 x_1101 /\ qe_lt_q h f)
(ensures fun h0 _ h1 ->
modifies (loc x_10 |+| loc x_11 |+| loc x_101 |+|
loc x_111 |+| loc x_1001 |+| loc x_1011 |+| loc x_1101) h0 h1 /\
(let _x_10 = SI.qsquare_times (qas_nat h0 f) 1 in
let _x_11 = S.qmul _x_10 (qas_nat h0 f) in
let _x_101 = S.qmul _x_10 _x_11 in
let _x_111 = S.qmul _x_10 _x_101 in
let _x_1001 = S.qmul _x_10 _x_111 in
let _x_1011 = S.qmul _x_10 _x_1001 in
let _x_1101 = S.qmul _x_10 _x_1011 in
qas_nat h1 x_10 == _x_10 /\ qe_lt_q h1 x_10 /\
qas_nat h1 x_11 == _x_11 /\ qe_lt_q h1 x_11 /\
qas_nat h1 x_101 == _x_101 /\ qe_lt_q h1 x_101 /\
qas_nat h1 x_111 == _x_111 /\ qe_lt_q h1 x_111 /\
qas_nat h1 x_1001 == _x_1001 /\ qe_lt_q h1 x_1001 /\
qas_nat h1 x_1011 == _x_1011 /\ qe_lt_q h1 x_1011 /\
qas_nat h1 x_1101 == _x_1101 /\ qe_lt_q h1 x_1101))
let qinv1 f x_10 x_11 x_101 x_111 x_1001 x_1011 x_1101 =
let h0 = ST.get () in
qsquare_times x_10 f 1ul;
let h1 = ST.get () in
assert (qas_nat h1 x_10 == SI.qsquare_times (qas_nat h0 f) 1);
qmul x_11 x_10 f;
let h2 = ST.get () in
assert (qas_nat h2 x_11 == S.qmul (qas_nat h1 x_10) (qas_nat h0 f));
qmul x_101 x_10 x_11;
let h3 = ST.get () in
assert (qas_nat h3 x_101 == S.qmul (qas_nat h1 x_10) (qas_nat h2 x_11));
qmul x_111 x_10 x_101;
let h4 = ST.get () in
assert (qas_nat h4 x_111 == S.qmul (qas_nat h1 x_10) (qas_nat h3 x_101));
qmul x_1001 x_10 x_111;
let h5 = ST.get () in
assert (qas_nat h5 x_1001 == S.qmul (qas_nat h1 x_10) (qas_nat h4 x_111));
qmul x_1011 x_10 x_1001;
let h6 = ST.get () in
assert (qas_nat h6 x_1011 == S.qmul (qas_nat h1 x_10) (qas_nat h5 x_1001));
qmul x_1101 x_10 x_1011;
let h7 = ST.get () in
assert (qas_nat h7 x_1101 == S.qmul (qas_nat h1 x_10) (qas_nat h6 x_1011))
inline_for_extraction noextract
val qinv2 (x_11 x_1011 x_1101 x6 x8 x14: qelem) : Stack unit
(requires fun h ->
live h x_11 /\ live h x_1011 /\ live h x_1101 /\
live h x6 /\ live h x8 /\ live h x14 /\
disjoint x_11 x6 /\ disjoint x_11 x8 /\ disjoint x_11 x14 /\
disjoint x_1011 x6 /\ disjoint x_1011 x8 /\ disjoint x_1011 x14 /\
disjoint x_1101 x6 /\ disjoint x_1101 x8 /\ disjoint x_1101 x14 /\
disjoint x6 x8 /\ disjoint x6 x14 /\ disjoint x8 x14 /\
qe_lt_q h x_11 /\ qe_lt_q h x_1011 /\ qe_lt_q h x_1101)
(ensures fun h0 _ h1 -> modifies (loc x6 |+| loc x8 |+| loc x14) h0 h1 /\
(let _x6 = S.qmul (SI.qsquare_times (qas_nat h0 x_1101) 2) (qas_nat h0 x_1011) in
let _x8 = S.qmul (SI.qsquare_times _x6 2) (qas_nat h0 x_11) in
let _x14 = S.qmul (SI.qsquare_times _x8 6) _x6 in
qas_nat h1 x6 == _x6 /\ qe_lt_q h1 x6 /\
qas_nat h1 x8 == _x8 /\ qe_lt_q h1 x8 /\
qas_nat h1 x14 == _x14 /\ qe_lt_q h1 x14))
let qinv2 x_11 x_1011 x_1101 x6 x8 x14 =
let h0 = ST.get () in
qsquare_times x6 x_1101 2ul;
qmul x6 x6 x_1011;
let h1 = ST.get () in
assert (qas_nat h1 x6 == S.qmul (SI.qsquare_times (qas_nat h0 x_1101) 2) (qas_nat h0 x_1011));
qsquare_times x8 x6 2ul;
qmul x8 x8 x_11;
let h2 = ST.get () in
assert (qas_nat h2 x8 == S.qmul (SI.qsquare_times (qas_nat h1 x6) 2) (qas_nat h0 x_11));
qsquare_times x14 x8 6ul;
qmul x14 x14 x6;
let h3 = ST.get () in
assert (qas_nat h3 x14 == S.qmul (SI.qsquare_times (qas_nat h2 x8) 6) (qas_nat h1 x6))
inline_for_extraction noextract
val qinv3 (tmp x14: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h x14 /\ disjoint tmp x14 /\
qe_lt_q h x14)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r0_r1 (qas_nat h0 x14) /\
qe_lt_q h1 tmp) | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.K256.Qinv.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.K256.Scalar.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.K256.Qinv.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "SD"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Qinv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.K256.Scalar",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | tmp: Hacl.K256.Scalar.qelem -> x14: Hacl.K256.Scalar.qelem -> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.K256.Scalar.qelem",
"FStar.HyperStack.ST.pop_frame",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.nat",
"Hacl.K256.Scalar.qas_nat",
"Spec.K256.PointOps.qmul",
"Hacl.Spec.K256.Qinv.qsquare_times",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Hacl.K256.Scalar.qmul",
"Hacl.Impl.K256.Qinv.qsquare_times_in_place",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.K256.Qinv.qsquare_times",
"Hacl.K256.Scalar.create_qelem",
"FStar.HyperStack.ST.push_frame"
] | [] | false | true | false | false | false | let qinv3 tmp x14 =
| push_frame ();
let x56 = create_qelem () in
let h0 = ST.get () in
qsquare_times tmp x14 14ul;
qmul tmp tmp x14;
let h1 = ST.get () in
assert (qas_nat h1 tmp == S.qmul (SI.qsquare_times (qas_nat h0 x14) 14) (qas_nat h0 x14));
qsquare_times x56 tmp 28ul;
qmul x56 x56 tmp;
let h2 = ST.get () in
assert (qas_nat h2 x56 == S.qmul (SI.qsquare_times (qas_nat h1 tmp) 28) (qas_nat h1 tmp));
qsquare_times tmp x56 56ul;
qmul tmp tmp x56;
let h3 = ST.get () in
assert (qas_nat h3 tmp == S.qmul (SI.qsquare_times (qas_nat h2 x56) 56) (qas_nat h2 x56));
qsquare_times_in_place tmp 14ul;
qmul tmp tmp x14;
let h4 = ST.get () in
assert (qas_nat h4 tmp == S.qmul (SI.qsquare_times (qas_nat h3 tmp) 14) (qas_nat h0 x14));
pop_frame () | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.bn_lt_pow2_index_lemma | val bn_lt_pow2_index_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} -> Lemma
(requires bn_v b < pow2 ind)
(ensures (let i = ind / bits t in v b.[i] < pow2 (ind % bits t) /\
bn_v b == bn_v (slice b 0 i) + pow2 (i * bits t) * v b.[i] /\
bn_v (slice b (i + 1) len) = 0)) | val bn_lt_pow2_index_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} -> Lemma
(requires bn_v b < pow2 ind)
(ensures (let i = ind / bits t in v b.[i] < pow2 (ind % bits t) /\
bn_v b == bn_v (slice b 0 i) + pow2 (i * bits t) * v b.[i] /\
bn_v (slice b (i + 1) len) = 0)) | let bn_lt_pow2_index_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
Math.Lemmas.euclidean_division_definition ind (pbits);
assert (bn_v b < pow2 (i * pbits + j));
Math.Lemmas.pow2_lt_compat (i * pbits + pbits) (i * pbits + j);
assert (bn_v b < pow2 (i * pbits + pbits));
bn_eval_split_i #t #len b (i + 1);
bn_eval_bound (slice b 0 (i + 1)) (i + 1);
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 (i + 1))) (bn_v (slice b (i + 1) len)) (pbits * (i + 1)) 0;
assert (bn_v b == bn_v (slice b 0 (i + 1)));
bn_eval_split_i #t #(i + 1) (slice b 0 (i + 1)) i;
bn_eval1 (slice b i (i + 1));
assert (bn_v b == bn_v (slice b 0 i) + pow2 (i * pbits) * v b.[i]);
bn_eval_bound #t #i (slice b 0 i) i;
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 i)) (v b.[i]) (i * pbits) j;
assert (v b.[i] < pow2 j) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 27,
"end_line": 135,
"start_col": 0,
"start_line": 115
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2)
let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2)
val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t
let bn_get_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[i] j
val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j))
let bn_get_ith_bit_aux_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = b.[i] >>. size j in
calc (==) {
v b.[i] / pow2 j;
(==) { bn_eval_index b i }
(bn_v b / pow2 (pbits * i) % pow2 pbits) / pow2 j;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b / pow2 (pbits * i)) j pbits }
(bn_v b / pow2 (pbits * i) / pow2 j) % pow2 (pbits - j);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b) (pow2 (pbits * i)) (pow2 j) }
(bn_v b / (pow2 (pbits * i) * pow2 j)) % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_plus (pbits * i) j }
(bn_v b / pow2 (pbits * i + j)) % pow2 (pbits - j);
(==) { Math.Lemmas.euclidean_div_axiom ind pbits }
(bn_v b / pow2 ind) % pow2 (pbits - j);
};
assert (v res == (bn_v b / pow2 ind) % pow2 (pbits - j))
val bn_get_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} ->
Lemma (v (bn_get_ith_bit b i) == (bn_v b / pow2 i % 2))
let bn_get_ith_bit_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = limb_get_ith_bit b.[i] j in
limb_get_ith_bit_lemma b.[i] j;
calc (==) {
v b.[i] / pow2 j % 2;
(==) { bn_get_ith_bit_aux_lemma b ind }
(bn_v b / pow2 ind) % pow2 (pbits - j) % 2;
(==) { assert_norm (pow2 1 = 2);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 ind) 1 (pbits - j) }
(bn_v b / pow2 ind) % 2;
};
assert (v res == bn_v b / pow2 ind % 2)
val bn_set_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> lbignum t len
let bn_set_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
let inp = input.[i] <- input.[i] |. (uint #t 1 <<. size j) in
inp
val bn_set_ith_bit_lemma_aux: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a + b * pow2 c < pow2 (c + d) /\ a < pow2 c)
(ensures b < pow2 d)
let bn_set_ith_bit_lemma_aux a b c d =
Math.Lemmas.lemma_div_lt_nat (a + b * pow2 c) (c + d) c;
assert ((a + b * pow2 c) / pow2 c < pow2 d);
Math.Lemmas.lemma_div_plus a b (pow2 c);
assert (a / pow2 c + b < pow2 d);
Math.Lemmas.small_division_lemma_1 a (pow2 c)
val bn_lt_pow2_index_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} -> Lemma
(requires bn_v b < pow2 ind)
(ensures (let i = ind / bits t in v b.[i] < pow2 (ind % bits t) /\
bn_v b == bn_v (slice b 0 i) + pow2 (i * bits t) * v b.[i] /\
bn_v (slice b (i + 1) len) = 0)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: Hacl.Spec.Bignum.Definitions.lbignum t len ->
ind: Lib.IntTypes.size_nat{ind / Lib.IntTypes.bits t < len}
-> FStar.Pervasives.Lemma (requires Hacl.Spec.Bignum.Definitions.bn_v b < Prims.pow2 ind)
(ensures
(let i = ind / Lib.IntTypes.bits t in
Lib.IntTypes.v b.[ i ] < Prims.pow2 (ind % Lib.IntTypes.bits t) /\
Hacl.Spec.Bignum.Definitions.bn_v b ==
Hacl.Spec.Bignum.Definitions.bn_v (Lib.Sequence.slice b 0 i) +
Prims.pow2 (i * Lib.IntTypes.bits t) * Lib.IntTypes.v b.[ i ] /\
Hacl.Spec.Bignum.Definitions.bn_v (Lib.Sequence.slice b (i + 1) len) = 0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Division",
"Lib.IntTypes.bits",
"Prims._assert",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.pow2",
"Prims.unit",
"Hacl.Spec.Bignum.Lib.bn_set_ith_bit_lemma_aux",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.op_Subtraction",
"Lib.Sequence.slice",
"FStar.Mul.op_Star",
"Hacl.Spec.Bignum.Definitions.bn_eval_bound",
"Prims.eq2",
"Prims.int",
"Prims.op_Addition",
"Hacl.Spec.Bignum.Definitions.bn_eval1",
"Hacl.Spec.Bignum.Definitions.bn_eval_split_i",
"Prims.nat",
"FStar.Math.Lemmas.pow2_lt_compat",
"FStar.Math.Lemmas.euclidean_division_definition",
"Prims.op_Modulus"
] | [] | true | false | true | false | false | let bn_lt_pow2_index_lemma #t #len b ind =
| let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
Math.Lemmas.euclidean_division_definition ind (pbits);
assert (bn_v b < pow2 (i * pbits + j));
Math.Lemmas.pow2_lt_compat (i * pbits + pbits) (i * pbits + j);
assert (bn_v b < pow2 (i * pbits + pbits));
bn_eval_split_i #t #len b (i + 1);
bn_eval_bound (slice b 0 (i + 1)) (i + 1);
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 (i + 1))) (bn_v (slice b (i + 1) len)) (pbits * (i + 1)) 0;
assert (bn_v b == bn_v (slice b 0 (i + 1)));
bn_eval_split_i #t #(i + 1) (slice b 0 (i + 1)) i;
bn_eval1 (slice b i (i + 1));
assert (bn_v b == bn_v (slice b 0 i) + pow2 (i * pbits) * v b.[ i ]);
bn_eval_bound #t #i (slice b 0 i) i;
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 i)) (v b.[ i ]) (i * pbits) j;
assert (v b.[ i ] < pow2 j) | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.bn_get_bits_limb | val bn_get_bits_limb:
#t:limb_t
-> #nLen:size_nat
-> n:lbignum t nLen
-> ind:size_nat{ind / bits t < nLen} ->
limb t | val bn_get_bits_limb:
#t:limb_t
-> #nLen:size_nat
-> n:lbignum t nLen
-> ind:size_nat{ind / bits t < nLen} ->
limb t | let bn_get_bits_limb #t #nLen n ind =
let i = ind / bits t in
let j = ind % bits t in
let p1 = n.[i] >>. size j in
let p2 = if i + 1 < nLen && 0 < j then p1 |. (n.[i + 1] <<. (size (bits t - j))) else p1 in
p2 | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 409,
"start_col": 0,
"start_line": 404
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2)
let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2)
val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t
let bn_get_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[i] j
val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j))
let bn_get_ith_bit_aux_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = b.[i] >>. size j in
calc (==) {
v b.[i] / pow2 j;
(==) { bn_eval_index b i }
(bn_v b / pow2 (pbits * i) % pow2 pbits) / pow2 j;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b / pow2 (pbits * i)) j pbits }
(bn_v b / pow2 (pbits * i) / pow2 j) % pow2 (pbits - j);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b) (pow2 (pbits * i)) (pow2 j) }
(bn_v b / (pow2 (pbits * i) * pow2 j)) % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_plus (pbits * i) j }
(bn_v b / pow2 (pbits * i + j)) % pow2 (pbits - j);
(==) { Math.Lemmas.euclidean_div_axiom ind pbits }
(bn_v b / pow2 ind) % pow2 (pbits - j);
};
assert (v res == (bn_v b / pow2 ind) % pow2 (pbits - j))
val bn_get_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} ->
Lemma (v (bn_get_ith_bit b i) == (bn_v b / pow2 i % 2))
let bn_get_ith_bit_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = limb_get_ith_bit b.[i] j in
limb_get_ith_bit_lemma b.[i] j;
calc (==) {
v b.[i] / pow2 j % 2;
(==) { bn_get_ith_bit_aux_lemma b ind }
(bn_v b / pow2 ind) % pow2 (pbits - j) % 2;
(==) { assert_norm (pow2 1 = 2);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 ind) 1 (pbits - j) }
(bn_v b / pow2 ind) % 2;
};
assert (v res == bn_v b / pow2 ind % 2)
val bn_set_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> lbignum t len
let bn_set_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
let inp = input.[i] <- input.[i] |. (uint #t 1 <<. size j) in
inp
val bn_set_ith_bit_lemma_aux: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a + b * pow2 c < pow2 (c + d) /\ a < pow2 c)
(ensures b < pow2 d)
let bn_set_ith_bit_lemma_aux a b c d =
Math.Lemmas.lemma_div_lt_nat (a + b * pow2 c) (c + d) c;
assert ((a + b * pow2 c) / pow2 c < pow2 d);
Math.Lemmas.lemma_div_plus a b (pow2 c);
assert (a / pow2 c + b < pow2 d);
Math.Lemmas.small_division_lemma_1 a (pow2 c)
val bn_lt_pow2_index_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} -> Lemma
(requires bn_v b < pow2 ind)
(ensures (let i = ind / bits t in v b.[i] < pow2 (ind % bits t) /\
bn_v b == bn_v (slice b 0 i) + pow2 (i * bits t) * v b.[i] /\
bn_v (slice b (i + 1) len) = 0))
let bn_lt_pow2_index_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
Math.Lemmas.euclidean_division_definition ind (pbits);
assert (bn_v b < pow2 (i * pbits + j));
Math.Lemmas.pow2_lt_compat (i * pbits + pbits) (i * pbits + j);
assert (bn_v b < pow2 (i * pbits + pbits));
bn_eval_split_i #t #len b (i + 1);
bn_eval_bound (slice b 0 (i + 1)) (i + 1);
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 (i + 1))) (bn_v (slice b (i + 1) len)) (pbits * (i + 1)) 0;
assert (bn_v b == bn_v (slice b 0 (i + 1)));
bn_eval_split_i #t #(i + 1) (slice b 0 (i + 1)) i;
bn_eval1 (slice b i (i + 1));
assert (bn_v b == bn_v (slice b 0 i) + pow2 (i * pbits) * v b.[i]);
bn_eval_bound #t #i (slice b 0 i) i;
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 i)) (v b.[i]) (i * pbits) j;
assert (v b.[i] < pow2 j)
val bn_set_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> Lemma
(requires bn_v b < pow2 i)
(ensures bn_v (bn_set_ith_bit b i) == bn_v b + pow2 i)
let bn_set_ith_bit_lemma #t #len input ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
bn_lt_pow2_index_lemma #t #len input ind;
assert (v input.[i] < pow2 j);
let b = uint #t 1 <<. size j in
let inp = input.[i] <- input.[i] |. b in
FStar.Math.Lemmas.pow2_lt_compat pbits j;
FStar.Math.Lemmas.modulo_lemma (pow2 j) (pow2 pbits);
assert (v b == pow2 j);
logor_disjoint (input.[i]) b j;
assert (v inp.[i] == v input.[i] + v b);
calc (==) {
bn_v inp;
(==) { bn_eval_split_i #t #len inp (i + 1);
bn_eval_extensionality_j (slice inp (i + 1) len) (slice input (i + 1) len) (len - i - 1) }
bn_v (slice inp 0 (i + 1));
(==) { bn_eval_split_i #t #(i + 1) (slice inp 0 (i + 1)) i }
bn_v (slice inp 0 i) + pow2 (i * pbits) * bn_v (slice inp i (i + 1));
(==) { bn_eval1 (slice inp i (i + 1)) }
bn_v (slice inp 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { bn_eval_extensionality_j input inp i }
bn_v (slice input 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { }
bn_v (slice input 0 i) + pow2 (i * pbits) * (v input.[i] + v b);
(==) { Math.Lemmas.distributivity_add_right (pow2 (i * pbits)) (v input.[i]) (v b) }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 (i * pbits) * v b;
(==) { Math.Lemmas.pow2_plus (i * pbits) j; Math.Lemmas.euclidean_division_definition ind pbits }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 ind;
(==) { }
bn_v input + pow2 ind;
}
///
/// % pow2 and / pow2
///
val bn_div_pow2: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i <= len} -> lbignum t (len - i)
let bn_div_pow2 #t #len b i =
slice b i len
val bn_div_pow2_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i < len} ->
Lemma (bn_v (bn_div_pow2 b i) == bn_v b / pow2 (bits t * i))
let bn_div_pow2_lemma #t #len c i =
let pbits = bits t in
calc (==) {
bn_v c / pow2 (pbits * i);
(==) { bn_eval_split_i c i }
(bn_v (slice c 0 i) + pow2 (pbits * i) * bn_v (slice c i len)) / pow2 (pbits * i);
(==) { Math.Lemmas.division_addition_lemma (bn_v (slice c 0 i)) (pow2 (pbits * i)) (bn_v (slice c i len)) }
bn_v (slice c 0 i) / pow2 (pbits * i) + bn_v (slice c i len);
(==) { bn_eval_bound (slice c 0 i) i; Math.Lemmas.small_division_lemma_1 (bn_v (slice c 0 i)) (pow2 (pbits * i)) }
bn_v (slice c i len);
};
assert (bn_v (slice c i len) == bn_v c / pow2 (pbits * i))
val bn_mod_pow2: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} -> lbignum t i
let bn_mod_pow2 #t #aLen a i = sub a 0 i
val bn_mod_pow2_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} ->
Lemma (bn_v (bn_mod_pow2 a i) == bn_v a % pow2 (bits t * i))
let bn_mod_pow2_lemma #t #aLen a i =
let pbits = bits t in
calc (==) {
bn_v a % pow2 (pbits * i);
(==) { bn_eval_split_i a i }
(bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v (slice a i aLen)) % pow2 (pbits * i);
(==) { Math.Lemmas.modulo_addition_lemma (bn_v (slice a 0 i)) (pow2 (pbits * i)) (bn_v (slice a i aLen)) }
(bn_v (slice a 0 i)) % pow2 (pbits * i);
(==) { bn_eval_bound (slice a 0 i) i; Math.Lemmas.small_mod (bn_v (slice a 0 i)) (pow2 (pbits * i)) }
bn_v (slice a 0 i);
}
///
/// Conditional swap
///
//the same as in curve25519
val lemma_cswap2_step:
#t:limb_t
-> bit:limb t{v bit <= 1}
-> p1:limb t
-> p2:limb t ->
Lemma
(let mask = uint #t 0 -. bit in
let dummy = mask &. (p1 ^. p2) in
let p1' = p1 ^. dummy in
let p2' = p2 ^. dummy in
if v bit = 1 then p1' == p2 /\ p2' == p1 else p1' == p1 /\ p2' == p2)
let lemma_cswap2_step #t bit p1 p2 =
let mask = uint #t 0 -. bit in
assert (v bit == 0 ==> v mask == 0);
assert (v bit == 1 ==> v mask == pow2 (bits t) - 1);
let dummy = mask &. (p1 ^. p2) in
logand_lemma mask (p1 ^. p2);
assert (v bit == 1 ==> v dummy == v (p1 ^. p2));
assert (v bit == 0 ==> v dummy == 0);
let p1' = p1 ^. dummy in
assert (v dummy == v (if v bit = 1 then (p1 ^. p2) else uint #t 0));
logxor_lemma p1 p2;
let p2' = p2 ^. dummy in
logxor_lemma p2 p1
val cswap2_f:
#t:limb_t
-> #len:size_nat
-> mask:limb t
-> i:nat{i < len}
-> tuple2 (lbignum t len) (lbignum t len) ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2_f #t #len mask i (p1, p2) =
let dummy = mask &. (p1.[i] ^. p2.[i]) in
let p1 = p1.[i] <- p1.[i] ^. dummy in
let p2 = p2.[i] <- p2.[i] ^. dummy in
(p1, p2)
val cswap2:
#t:limb_t
-> #len:size_nat
-> bit:limb t
-> b1:lbignum t len
-> b2:lbignum t len ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2 #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.repeati len (cswap2_f #t #len mask) (b1, b2)
val cswap2_lemma:
#t:limb_t
-> #len:size_nat
-> bit:limb t{v bit <= 1}
-> b1:lbignum t len
-> b2:lbignum t len ->
Lemma (let (p1, p2) = cswap2 bit b1 b2 in
(if v bit = 1 then p1 == b2 /\ p2 == b1 else p1 == b1 /\ p2 == b2))
let cswap2_lemma #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.eq_repeati0 len (cswap2_f #t #len mask) (b1, b2);
let (p1, p2) =
Loops.repeati_inductive #(tuple2 (lbignum t len) (lbignum t len)) len
(fun i (p1, p2) ->
(p1, p2) == Loops.repeati i (cswap2_f #t #len mask) (b1, b2) /\
(forall (k:nat{k < i}).
(if v bit = 1 then p1.[k] == b2.[k] /\ p2.[k] == b1.[k] else p1.[k] == b1.[k] /\ p2.[k] == b2.[k])) /\
(forall (k:nat{i <= k /\ k < len}). p1.[k] == b1.[k] /\ p2.[k] == b2.[k]))
(fun i (p1, p2) ->
Loops.unfold_repeati (i + 1) (cswap2_f #t #len mask) (b1, b2) i;
lemma_cswap2_step bit p1.[i] p2.[i];
cswap2_f #t #len mask i (p1, p2)) (b1, b2) in
assert (if v bit = 1 then (eq_intro p1 b2; p1 == b2) else (eq_intro p1 b1; p1 == b1));
assert (if v bit = 1 then (eq_intro p2 b1; p2 == b1) else (eq_intro p2 b2; p2 == b2));
//eq_intro p1 (if v bit = 1 then b2 else b1);
//eq_intro p2 (if v bit = 1 then b1 else b2);
()
let bn_get_top_index_t (len:size_nat) (i:nat{i <= len}) = x:nat{x < len}
val bn_get_top_index_f:
#t:limb_t
-> #len:size_nat
-> b:lbignum t len
-> i:nat{i < len}
-> priv:bn_get_top_index_t len i ->
bn_get_top_index_t len (i + 1)
let bn_get_top_index_f #t #len b i priv =
let mask = eq_mask b.[i] (zeros t SEC) in
if v mask = 0 then i else priv
val bn_get_top_index: #t:limb_t -> #len:size_pos -> b:lbignum t len -> res:size_nat{res < len}
let bn_get_top_index #t #len b =
Loops.repeat_gen len (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0
val bn_get_top_index_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (let ind = bn_get_top_index #t #len b in
ind < len /\ (ind > 0 ==> v b.[ind] <> 0) /\ (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0))
let bn_get_top_index_lemma #t #len b =
Loops.eq_repeat_gen0 len (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0;
let res =
Loops.repeati_inductive #size_nat len
(fun i priv ->
priv == Loops.repeat_gen i (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0 /\
priv < len /\ (priv > 0 ==> v b.[priv] <> 0) /\ (forall (k:nat{priv < k /\ k < i}). v b.[k] = 0))
(fun i priv ->
Loops.unfold_repeat_gen (i + 1) (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0 i;
let mask = eq_mask b.[i] (zeros t SEC) in
eq_mask_lemma b.[i] (zeros t SEC);
assert (if v mask = 0 then v b.[i] <> 0 else v b.[i] = 0);
let res = if v mask = 0 then i else priv in
res) 0 in
()
val bn_get_top_index_eval_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len -> ind:nat -> Lemma
(requires
ind < len /\ (ind > 0 ==> v b.[ind] <> 0) /\ (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0))
(ensures
bn_v b == bn_v (slice b 0 ind) + pow2 (bits t * ind) * v b.[ind])
let bn_get_top_index_eval_lemma #t #len b ind =
let pbits = bits t in
assert (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0);
bn_eval_split_i b (ind + 1);
assert (bn_v b == bn_v (slice b 0 (ind + 1)) + pow2 (pbits * (ind + 1)) * bn_v (slice b (ind + 1) len));
eq_intro (slice b (ind + 1) len) (create (len - ind - 1) (uint #t 0));
bn_eval_zeroes #t (len - ind - 1) (len - ind - 1);
assert (bn_v b == bn_v (slice b 0 (ind + 1)));
bn_eval_split_i (slice b 0 (ind + 1)) ind;
assert (bn_v b == bn_v (slice b 0 ind) + pow2 (pbits * ind) * bn_v (slice b ind (ind + 1)));
bn_eval1 (slice b ind (ind + 1));
assert (bn_v b == bn_v (slice b 0 ind) + pow2 (pbits * ind) * v b.[ind])
val bn_low_bound_bits:
#t:limb_t
-> #len:size_pos{bits t * len <= max_size_t}
-> b:lbignum t len ->
res:size_nat{res / bits t < len}
let bn_low_bound_bits #t #len b =
bits t * bn_get_top_index b
val bn_low_bound_bits_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len -> Lemma
(requires 1 < bn_v b /\ bits t * len <= max_size_t /\ bn_v b % 2 = 1)
(ensures pow2 (bn_low_bound_bits b) < bn_v b)
let bn_low_bound_bits_lemma #t #len b =
let ind = bn_get_top_index #t #len b in
bn_get_top_index_lemma #t #len b;
bn_get_top_index_eval_lemma #t #len b ind;
assert (pow2 (bn_low_bound_bits b) <= bn_v b);
if ind = 0 then
assert_norm (pow2 0 = 1)
else
Math.Lemmas.pow2_multiplication_modulo_lemma_1 1 1 (bn_low_bound_bits b)
val bn_get_bits_limb:
#t:limb_t
-> #nLen:size_nat
-> n:lbignum t nLen
-> ind:size_nat{ind / bits t < nLen} ->
limb t | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
n: Hacl.Spec.Bignum.Definitions.lbignum t nLen ->
ind: Lib.IntTypes.size_nat{ind / Lib.IntTypes.bits t < nLen}
-> Hacl.Spec.Bignum.Definitions.limb t | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Division",
"Lib.IntTypes.bits",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.op_AmpAmp",
"Prims.op_Addition",
"Lib.IntTypes.op_Bar_Dot",
"Lib.IntTypes.SEC",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.Sequence.op_String_Access",
"Lib.IntTypes.size",
"Prims.op_Subtraction",
"Prims.bool",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Greater_Greater_Dot",
"Prims.int",
"Prims.op_Modulus"
] | [] | false | false | false | false | false | let bn_get_bits_limb #t #nLen n ind =
| let i = ind / bits t in
let j = ind % bits t in
let p1 = n.[ i ] >>. size j in
let p2 = if i + 1 < nLen && 0 < j then p1 |. (n.[ i + 1 ] <<. (size (bits t - j))) else p1 in
p2 | false |
Hacl.Impl.K256.Qinv.fst | Hacl.Impl.K256.Qinv.qinv4 | val qinv4 (tmp x_101 x_111 x_1011: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h x_101 /\ live h x_111 /\ live h x_1011 /\
disjoint tmp x_101 /\ disjoint tmp x_111 /\ disjoint tmp x_1011 /\
qe_lt_q h tmp /\ qe_lt_q h x_101 /\ qe_lt_q h x_111 /\ qe_lt_q h x_1011)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r2_r8 (qas_nat h0 tmp)
(qas_nat h0 x_101) (qas_nat h0 x_111) (qas_nat h0 x_1011) /\
qe_lt_q h1 tmp) | val qinv4 (tmp x_101 x_111 x_1011: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h x_101 /\ live h x_111 /\ live h x_1011 /\
disjoint tmp x_101 /\ disjoint tmp x_111 /\ disjoint tmp x_1011 /\
qe_lt_q h tmp /\ qe_lt_q h x_101 /\ qe_lt_q h x_111 /\ qe_lt_q h x_1011)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r2_r8 (qas_nat h0 tmp)
(qas_nat h0 x_101) (qas_nat h0 x_111) (qas_nat h0 x_1011) /\
qe_lt_q h1 tmp) | let qinv4 tmp x_101 x_111 x_1011 =
let h0 = ST.get () in
qsquare_times_in_place tmp 3ul;
qmul tmp tmp x_101; //tmp = r2
let h1 = ST.get () in
assert (qas_nat h1 tmp == S.qmul (SI.qsquare_times (qas_nat h0 tmp) 3) (qas_nat h0 x_101));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_111; //tmp = r3
let h2 = ST.get () in
assert (qas_nat h2 tmp == S.qmul (SI.qsquare_times (qas_nat h1 tmp) 4) (qas_nat h0 x_111));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_101; //tmp = r4
let h3 = ST.get () in
assert (qas_nat h3 tmp == S.qmul (SI.qsquare_times (qas_nat h2 tmp) 4) (qas_nat h0 x_101));
qsquare_times_in_place tmp 5ul;
qmul tmp tmp x_1011; //tmp = r5
let h4 = ST.get () in
assert (qas_nat h4 tmp == S.qmul (SI.qsquare_times (qas_nat h3 tmp) 5) (qas_nat h0 x_1011));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_1011; //tmp = r6
let h5 = ST.get () in
assert (qas_nat h5 tmp == S.qmul (SI.qsquare_times (qas_nat h4 tmp) 4) (qas_nat h0 x_1011));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_111; //tmp = r7
let h6 = ST.get () in
assert (qas_nat h6 tmp == S.qmul (SI.qsquare_times (qas_nat h5 tmp) 4) (qas_nat h0 x_111));
qsquare_times_in_place tmp 5ul;
qmul tmp tmp x_111; //tmp = r8
let h7 = ST.get () in
assert (qas_nat h7 tmp == S.qmul (SI.qsquare_times (qas_nat h6 tmp) 5) (qas_nat h0 x_111)) | {
"file_name": "code/k256/Hacl.Impl.K256.Qinv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 92,
"end_line": 279,
"start_col": 0,
"start_line": 244
} | module Hacl.Impl.K256.Qinv
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.K256.Scalar
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Spec.K256
module SI = Hacl.Spec.K256.Qinv
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module SD = Hacl.Spec.Bignum.Definitions
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
unfold
let linv_ctx (a:LSeq.lseq uint64 0) : Type0 = True
unfold
let linv (a:LSeq.lseq uint64 4) : Type0 =
SD.bn_v #U64 #4 a < S.q
unfold
let refl (a:LSeq.lseq uint64 4{linv a}) : GTot S.qelem =
SD.bn_v #U64 #4 a
inline_for_extraction noextract
let mk_to_k256_scalar_comm_monoid : BE.to_comm_monoid U64 4ul 0ul = {
BE.a_spec = S.qelem;
BE.comm_monoid = SI.nat_mod_comm_monoid;
BE.linv_ctx = linv_ctx;
BE.linv = linv;
BE.refl = refl;
}
inline_for_extraction noextract
val one_mod : BE.lone_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let one_mod ctx one = make_u64_4 one (u64 1, u64 0, u64 0, u64 0)
inline_for_extraction noextract
val mul_mod : BE.lmul_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let mul_mod ctx x y xy = qmul xy x y
inline_for_extraction noextract
val sqr_mod : BE.lsqr_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let sqr_mod ctx x xx = qsqr xx x
inline_for_extraction noextract
let mk_k256_scalar_concrete_ops : BE.concrete_ops U64 4ul 0ul = {
BE.to = mk_to_k256_scalar_comm_monoid;
BE.lone = one_mod;
BE.lmul = mul_mod;
BE.lsqr = sqr_mod;
}
val qsquare_times_in_place (out:qelem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ qe_lt_q h out)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\ qe_lt_q h1 out /\
qas_nat h1 out == SI.qsquare_times (qas_nat h0 out) (v b))
[@CInline]
let qsquare_times_in_place out b =
let h0 = ST.get () in
SE.exp_pow2_lemma SI.mk_nat_mod_concrete_ops (qas_nat h0 out) (v b);
BE.lexp_pow2_in_place 4ul 0ul mk_k256_scalar_concrete_ops (null uint64) out b
val qsquare_times (out a:qelem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ live h a /\ disjoint out a /\
qe_lt_q h a)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\ qe_lt_q h1 a /\
qas_nat h1 out == SI.qsquare_times (qas_nat h0 a) (v b))
[@CInline]
let qsquare_times out a b =
let h0 = ST.get () in
SE.exp_pow2_lemma SI.mk_nat_mod_concrete_ops (qas_nat h0 a) (v b);
BE.lexp_pow2 4ul 0ul mk_k256_scalar_concrete_ops (null uint64) a b out
inline_for_extraction noextract
val qinv1 (f x_10 x_11 x_101 x_111 x_1001 x_1011 x_1101:qelem) : Stack unit
(requires fun h ->
live h f /\ live h x_10 /\ live h x_11 /\ live h x_101 /\
live h x_111 /\ live h x_1001 /\ live h x_1011 /\ live h x_1101 /\
disjoint f x_10 /\ disjoint f x_11 /\ disjoint f x_101 /\
disjoint f x_111 /\ disjoint f x_1001 /\ disjoint f x_1011 /\
disjoint f x_1101 /\ disjoint x_10 x_11 /\ disjoint x_10 x_101 /\
disjoint x_10 x_111 /\ disjoint x_10 x_1001 /\ disjoint x_10 x_1011 /\
disjoint x_10 x_1101 /\ disjoint x_11 x_101 /\ disjoint x_11 x_111 /\
disjoint x_11 x_1001 /\ disjoint x_11 x_1011 /\ disjoint x_11 x_1101 /\
disjoint x_101 x_111 /\ disjoint x_101 x_1001 /\ disjoint x_101 x_1011 /\
disjoint x_101 x_1101 /\ disjoint x_111 x_1001 /\ disjoint x_111 x_1011 /\
disjoint x_111 x_1101 /\ disjoint x_1001 x_1011 /\ disjoint x_1001 x_1101 /\
disjoint x_1011 x_1101 /\ qe_lt_q h f)
(ensures fun h0 _ h1 ->
modifies (loc x_10 |+| loc x_11 |+| loc x_101 |+|
loc x_111 |+| loc x_1001 |+| loc x_1011 |+| loc x_1101) h0 h1 /\
(let _x_10 = SI.qsquare_times (qas_nat h0 f) 1 in
let _x_11 = S.qmul _x_10 (qas_nat h0 f) in
let _x_101 = S.qmul _x_10 _x_11 in
let _x_111 = S.qmul _x_10 _x_101 in
let _x_1001 = S.qmul _x_10 _x_111 in
let _x_1011 = S.qmul _x_10 _x_1001 in
let _x_1101 = S.qmul _x_10 _x_1011 in
qas_nat h1 x_10 == _x_10 /\ qe_lt_q h1 x_10 /\
qas_nat h1 x_11 == _x_11 /\ qe_lt_q h1 x_11 /\
qas_nat h1 x_101 == _x_101 /\ qe_lt_q h1 x_101 /\
qas_nat h1 x_111 == _x_111 /\ qe_lt_q h1 x_111 /\
qas_nat h1 x_1001 == _x_1001 /\ qe_lt_q h1 x_1001 /\
qas_nat h1 x_1011 == _x_1011 /\ qe_lt_q h1 x_1011 /\
qas_nat h1 x_1101 == _x_1101 /\ qe_lt_q h1 x_1101))
let qinv1 f x_10 x_11 x_101 x_111 x_1001 x_1011 x_1101 =
let h0 = ST.get () in
qsquare_times x_10 f 1ul;
let h1 = ST.get () in
assert (qas_nat h1 x_10 == SI.qsquare_times (qas_nat h0 f) 1);
qmul x_11 x_10 f;
let h2 = ST.get () in
assert (qas_nat h2 x_11 == S.qmul (qas_nat h1 x_10) (qas_nat h0 f));
qmul x_101 x_10 x_11;
let h3 = ST.get () in
assert (qas_nat h3 x_101 == S.qmul (qas_nat h1 x_10) (qas_nat h2 x_11));
qmul x_111 x_10 x_101;
let h4 = ST.get () in
assert (qas_nat h4 x_111 == S.qmul (qas_nat h1 x_10) (qas_nat h3 x_101));
qmul x_1001 x_10 x_111;
let h5 = ST.get () in
assert (qas_nat h5 x_1001 == S.qmul (qas_nat h1 x_10) (qas_nat h4 x_111));
qmul x_1011 x_10 x_1001;
let h6 = ST.get () in
assert (qas_nat h6 x_1011 == S.qmul (qas_nat h1 x_10) (qas_nat h5 x_1001));
qmul x_1101 x_10 x_1011;
let h7 = ST.get () in
assert (qas_nat h7 x_1101 == S.qmul (qas_nat h1 x_10) (qas_nat h6 x_1011))
inline_for_extraction noextract
val qinv2 (x_11 x_1011 x_1101 x6 x8 x14: qelem) : Stack unit
(requires fun h ->
live h x_11 /\ live h x_1011 /\ live h x_1101 /\
live h x6 /\ live h x8 /\ live h x14 /\
disjoint x_11 x6 /\ disjoint x_11 x8 /\ disjoint x_11 x14 /\
disjoint x_1011 x6 /\ disjoint x_1011 x8 /\ disjoint x_1011 x14 /\
disjoint x_1101 x6 /\ disjoint x_1101 x8 /\ disjoint x_1101 x14 /\
disjoint x6 x8 /\ disjoint x6 x14 /\ disjoint x8 x14 /\
qe_lt_q h x_11 /\ qe_lt_q h x_1011 /\ qe_lt_q h x_1101)
(ensures fun h0 _ h1 -> modifies (loc x6 |+| loc x8 |+| loc x14) h0 h1 /\
(let _x6 = S.qmul (SI.qsquare_times (qas_nat h0 x_1101) 2) (qas_nat h0 x_1011) in
let _x8 = S.qmul (SI.qsquare_times _x6 2) (qas_nat h0 x_11) in
let _x14 = S.qmul (SI.qsquare_times _x8 6) _x6 in
qas_nat h1 x6 == _x6 /\ qe_lt_q h1 x6 /\
qas_nat h1 x8 == _x8 /\ qe_lt_q h1 x8 /\
qas_nat h1 x14 == _x14 /\ qe_lt_q h1 x14))
let qinv2 x_11 x_1011 x_1101 x6 x8 x14 =
let h0 = ST.get () in
qsquare_times x6 x_1101 2ul;
qmul x6 x6 x_1011;
let h1 = ST.get () in
assert (qas_nat h1 x6 == S.qmul (SI.qsquare_times (qas_nat h0 x_1101) 2) (qas_nat h0 x_1011));
qsquare_times x8 x6 2ul;
qmul x8 x8 x_11;
let h2 = ST.get () in
assert (qas_nat h2 x8 == S.qmul (SI.qsquare_times (qas_nat h1 x6) 2) (qas_nat h0 x_11));
qsquare_times x14 x8 6ul;
qmul x14 x14 x6;
let h3 = ST.get () in
assert (qas_nat h3 x14 == S.qmul (SI.qsquare_times (qas_nat h2 x8) 6) (qas_nat h1 x6))
inline_for_extraction noextract
val qinv3 (tmp x14: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h x14 /\ disjoint tmp x14 /\
qe_lt_q h x14)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r0_r1 (qas_nat h0 x14) /\
qe_lt_q h1 tmp)
let qinv3 tmp x14 =
push_frame ();
let x56 = create_qelem () in
let h0 = ST.get () in
qsquare_times tmp x14 14ul;
qmul tmp tmp x14; //tmp = x28
let h1 = ST.get () in
assert (qas_nat h1 tmp == S.qmul (SI.qsquare_times (qas_nat h0 x14) 14) (qas_nat h0 x14));
qsquare_times x56 tmp 28ul;
qmul x56 x56 tmp;
let h2 = ST.get () in
assert (qas_nat h2 x56 == S.qmul (SI.qsquare_times (qas_nat h1 tmp) 28) (qas_nat h1 tmp));
qsquare_times tmp x56 56ul; //tmp = r0
qmul tmp tmp x56;
let h3 = ST.get () in
assert (qas_nat h3 tmp == S.qmul (SI.qsquare_times (qas_nat h2 x56) 56) (qas_nat h2 x56));
qsquare_times_in_place tmp 14ul; //tmp = r1
qmul tmp tmp x14;
let h4 = ST.get () in
assert (qas_nat h4 tmp == S.qmul (SI.qsquare_times (qas_nat h3 tmp) 14) (qas_nat h0 x14));
pop_frame ()
//r2; .. ;r8
inline_for_extraction noextract
val qinv4 (tmp x_101 x_111 x_1011: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h x_101 /\ live h x_111 /\ live h x_1011 /\
disjoint tmp x_101 /\ disjoint tmp x_111 /\ disjoint tmp x_1011 /\
qe_lt_q h tmp /\ qe_lt_q h x_101 /\ qe_lt_q h x_111 /\ qe_lt_q h x_1011)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r2_r8 (qas_nat h0 tmp)
(qas_nat h0 x_101) (qas_nat h0 x_111) (qas_nat h0 x_1011) /\
qe_lt_q h1 tmp) | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.K256.Qinv.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.K256.Scalar.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.K256.Qinv.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "SD"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Qinv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.K256.Scalar",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
tmp: Hacl.K256.Scalar.qelem ->
x_101: Hacl.K256.Scalar.qelem ->
x_111: Hacl.K256.Scalar.qelem ->
x_1011: Hacl.K256.Scalar.qelem
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.K256.Scalar.qelem",
"Prims._assert",
"Prims.eq2",
"Prims.nat",
"Hacl.K256.Scalar.qas_nat",
"Spec.K256.PointOps.qmul",
"Hacl.Spec.K256.Qinv.qsquare_times",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Hacl.K256.Scalar.qmul",
"Hacl.Impl.K256.Qinv.qsquare_times_in_place",
"FStar.UInt32.__uint_to_t"
] | [] | false | true | false | false | false | let qinv4 tmp x_101 x_111 x_1011 =
| let h0 = ST.get () in
qsquare_times_in_place tmp 3ul;
qmul tmp tmp x_101;
let h1 = ST.get () in
assert (qas_nat h1 tmp == S.qmul (SI.qsquare_times (qas_nat h0 tmp) 3) (qas_nat h0 x_101));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_111;
let h2 = ST.get () in
assert (qas_nat h2 tmp == S.qmul (SI.qsquare_times (qas_nat h1 tmp) 4) (qas_nat h0 x_111));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_101;
let h3 = ST.get () in
assert (qas_nat h3 tmp == S.qmul (SI.qsquare_times (qas_nat h2 tmp) 4) (qas_nat h0 x_101));
qsquare_times_in_place tmp 5ul;
qmul tmp tmp x_1011;
let h4 = ST.get () in
assert (qas_nat h4 tmp == S.qmul (SI.qsquare_times (qas_nat h3 tmp) 5) (qas_nat h0 x_1011));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_1011;
let h5 = ST.get () in
assert (qas_nat h5 tmp == S.qmul (SI.qsquare_times (qas_nat h4 tmp) 4) (qas_nat h0 x_1011));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_111;
let h6 = ST.get () in
assert (qas_nat h6 tmp == S.qmul (SI.qsquare_times (qas_nat h5 tmp) 4) (qas_nat h0 x_111));
qsquare_times_in_place tmp 5ul;
qmul tmp tmp x_111;
let h7 = ST.get () in
assert (qas_nat h7 tmp == S.qmul (SI.qsquare_times (qas_nat h6 tmp) 5) (qas_nat h0 x_111)) | false |
Hacl.Impl.K256.Qinv.fst | Hacl.Impl.K256.Qinv.qinv5 | val qinv5 (tmp x_101 x_111 x_1001 x_1101: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h x_101 /\ live h x_111 /\
live h x_1001 /\ live h x_1101 /\ disjoint tmp x_101 /\
disjoint tmp x_111 /\ disjoint tmp x_1001 /\ disjoint tmp x_1101 /\
qe_lt_q h tmp /\ qe_lt_q h x_101 /\ qe_lt_q h x_111 /\
qe_lt_q h x_1001 /\ qe_lt_q h x_1101)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r9_r15 (qas_nat h0 tmp)
(qas_nat h0 x_101) (qas_nat h0 x_111) (qas_nat h0 x_1001) (qas_nat h0 x_1101) /\
qe_lt_q h1 tmp) | val qinv5 (tmp x_101 x_111 x_1001 x_1101: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h x_101 /\ live h x_111 /\
live h x_1001 /\ live h x_1101 /\ disjoint tmp x_101 /\
disjoint tmp x_111 /\ disjoint tmp x_1001 /\ disjoint tmp x_1101 /\
qe_lt_q h tmp /\ qe_lt_q h x_101 /\ qe_lt_q h x_111 /\
qe_lt_q h x_1001 /\ qe_lt_q h x_1101)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r9_r15 (qas_nat h0 tmp)
(qas_nat h0 x_101) (qas_nat h0 x_111) (qas_nat h0 x_1001) (qas_nat h0 x_1101) /\
qe_lt_q h1 tmp) | let qinv5 tmp x_101 x_111 x_1001 x_1101 =
let h0 = ST.get () in
qsquare_times_in_place tmp 6ul;
qmul tmp tmp x_1101; //tmp = r9
let h1 = ST.get () in
assert (qas_nat h1 tmp == S.qmul (SI.qsquare_times (qas_nat h0 tmp) 6) (qas_nat h0 x_1101));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_101; //tmp = r10
let h2 = ST.get () in
assert (qas_nat h2 tmp == S.qmul (SI.qsquare_times (qas_nat h1 tmp) 4) (qas_nat h0 x_101));
qsquare_times_in_place tmp 3ul;
qmul tmp tmp x_111; //tmp = r11
let h3 = ST.get () in
assert (qas_nat h3 tmp == S.qmul (SI.qsquare_times (qas_nat h2 tmp) 3) (qas_nat h0 x_111));
qsquare_times_in_place tmp 5ul;
qmul tmp tmp x_1001; //tmp = r12
let h4 = ST.get () in
assert (qas_nat h4 tmp == S.qmul (SI.qsquare_times (qas_nat h3 tmp) 5) (qas_nat h0 x_1001));
qsquare_times_in_place tmp 6ul;
qmul tmp tmp x_101; //tmp = r13
let h5 = ST.get () in
assert (qas_nat h5 tmp == S.qmul (SI.qsquare_times (qas_nat h4 tmp) 6) (qas_nat h0 x_101));
qsquare_times_in_place tmp 10ul;
qmul tmp tmp x_111; //tmp = r14
let h6 = ST.get () in
assert (qas_nat h6 tmp == S.qmul (SI.qsquare_times (qas_nat h5 tmp) 10) (qas_nat h0 x_111));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_111; //tmp = r15
let h7 = ST.get () in
assert (qas_nat h7 tmp == S.qmul (SI.qsquare_times (qas_nat h6 tmp) 4) (qas_nat h0 x_111)) | {
"file_name": "code/k256/Hacl.Impl.K256.Qinv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 92,
"end_line": 331,
"start_col": 0,
"start_line": 296
} | module Hacl.Impl.K256.Qinv
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.K256.Scalar
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Spec.K256
module SI = Hacl.Spec.K256.Qinv
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module SD = Hacl.Spec.Bignum.Definitions
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
unfold
let linv_ctx (a:LSeq.lseq uint64 0) : Type0 = True
unfold
let linv (a:LSeq.lseq uint64 4) : Type0 =
SD.bn_v #U64 #4 a < S.q
unfold
let refl (a:LSeq.lseq uint64 4{linv a}) : GTot S.qelem =
SD.bn_v #U64 #4 a
inline_for_extraction noextract
let mk_to_k256_scalar_comm_monoid : BE.to_comm_monoid U64 4ul 0ul = {
BE.a_spec = S.qelem;
BE.comm_monoid = SI.nat_mod_comm_monoid;
BE.linv_ctx = linv_ctx;
BE.linv = linv;
BE.refl = refl;
}
inline_for_extraction noextract
val one_mod : BE.lone_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let one_mod ctx one = make_u64_4 one (u64 1, u64 0, u64 0, u64 0)
inline_for_extraction noextract
val mul_mod : BE.lmul_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let mul_mod ctx x y xy = qmul xy x y
inline_for_extraction noextract
val sqr_mod : BE.lsqr_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let sqr_mod ctx x xx = qsqr xx x
inline_for_extraction noextract
let mk_k256_scalar_concrete_ops : BE.concrete_ops U64 4ul 0ul = {
BE.to = mk_to_k256_scalar_comm_monoid;
BE.lone = one_mod;
BE.lmul = mul_mod;
BE.lsqr = sqr_mod;
}
val qsquare_times_in_place (out:qelem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ qe_lt_q h out)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\ qe_lt_q h1 out /\
qas_nat h1 out == SI.qsquare_times (qas_nat h0 out) (v b))
[@CInline]
let qsquare_times_in_place out b =
let h0 = ST.get () in
SE.exp_pow2_lemma SI.mk_nat_mod_concrete_ops (qas_nat h0 out) (v b);
BE.lexp_pow2_in_place 4ul 0ul mk_k256_scalar_concrete_ops (null uint64) out b
val qsquare_times (out a:qelem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ live h a /\ disjoint out a /\
qe_lt_q h a)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\ qe_lt_q h1 a /\
qas_nat h1 out == SI.qsquare_times (qas_nat h0 a) (v b))
[@CInline]
let qsquare_times out a b =
let h0 = ST.get () in
SE.exp_pow2_lemma SI.mk_nat_mod_concrete_ops (qas_nat h0 a) (v b);
BE.lexp_pow2 4ul 0ul mk_k256_scalar_concrete_ops (null uint64) a b out
inline_for_extraction noextract
val qinv1 (f x_10 x_11 x_101 x_111 x_1001 x_1011 x_1101:qelem) : Stack unit
(requires fun h ->
live h f /\ live h x_10 /\ live h x_11 /\ live h x_101 /\
live h x_111 /\ live h x_1001 /\ live h x_1011 /\ live h x_1101 /\
disjoint f x_10 /\ disjoint f x_11 /\ disjoint f x_101 /\
disjoint f x_111 /\ disjoint f x_1001 /\ disjoint f x_1011 /\
disjoint f x_1101 /\ disjoint x_10 x_11 /\ disjoint x_10 x_101 /\
disjoint x_10 x_111 /\ disjoint x_10 x_1001 /\ disjoint x_10 x_1011 /\
disjoint x_10 x_1101 /\ disjoint x_11 x_101 /\ disjoint x_11 x_111 /\
disjoint x_11 x_1001 /\ disjoint x_11 x_1011 /\ disjoint x_11 x_1101 /\
disjoint x_101 x_111 /\ disjoint x_101 x_1001 /\ disjoint x_101 x_1011 /\
disjoint x_101 x_1101 /\ disjoint x_111 x_1001 /\ disjoint x_111 x_1011 /\
disjoint x_111 x_1101 /\ disjoint x_1001 x_1011 /\ disjoint x_1001 x_1101 /\
disjoint x_1011 x_1101 /\ qe_lt_q h f)
(ensures fun h0 _ h1 ->
modifies (loc x_10 |+| loc x_11 |+| loc x_101 |+|
loc x_111 |+| loc x_1001 |+| loc x_1011 |+| loc x_1101) h0 h1 /\
(let _x_10 = SI.qsquare_times (qas_nat h0 f) 1 in
let _x_11 = S.qmul _x_10 (qas_nat h0 f) in
let _x_101 = S.qmul _x_10 _x_11 in
let _x_111 = S.qmul _x_10 _x_101 in
let _x_1001 = S.qmul _x_10 _x_111 in
let _x_1011 = S.qmul _x_10 _x_1001 in
let _x_1101 = S.qmul _x_10 _x_1011 in
qas_nat h1 x_10 == _x_10 /\ qe_lt_q h1 x_10 /\
qas_nat h1 x_11 == _x_11 /\ qe_lt_q h1 x_11 /\
qas_nat h1 x_101 == _x_101 /\ qe_lt_q h1 x_101 /\
qas_nat h1 x_111 == _x_111 /\ qe_lt_q h1 x_111 /\
qas_nat h1 x_1001 == _x_1001 /\ qe_lt_q h1 x_1001 /\
qas_nat h1 x_1011 == _x_1011 /\ qe_lt_q h1 x_1011 /\
qas_nat h1 x_1101 == _x_1101 /\ qe_lt_q h1 x_1101))
let qinv1 f x_10 x_11 x_101 x_111 x_1001 x_1011 x_1101 =
let h0 = ST.get () in
qsquare_times x_10 f 1ul;
let h1 = ST.get () in
assert (qas_nat h1 x_10 == SI.qsquare_times (qas_nat h0 f) 1);
qmul x_11 x_10 f;
let h2 = ST.get () in
assert (qas_nat h2 x_11 == S.qmul (qas_nat h1 x_10) (qas_nat h0 f));
qmul x_101 x_10 x_11;
let h3 = ST.get () in
assert (qas_nat h3 x_101 == S.qmul (qas_nat h1 x_10) (qas_nat h2 x_11));
qmul x_111 x_10 x_101;
let h4 = ST.get () in
assert (qas_nat h4 x_111 == S.qmul (qas_nat h1 x_10) (qas_nat h3 x_101));
qmul x_1001 x_10 x_111;
let h5 = ST.get () in
assert (qas_nat h5 x_1001 == S.qmul (qas_nat h1 x_10) (qas_nat h4 x_111));
qmul x_1011 x_10 x_1001;
let h6 = ST.get () in
assert (qas_nat h6 x_1011 == S.qmul (qas_nat h1 x_10) (qas_nat h5 x_1001));
qmul x_1101 x_10 x_1011;
let h7 = ST.get () in
assert (qas_nat h7 x_1101 == S.qmul (qas_nat h1 x_10) (qas_nat h6 x_1011))
inline_for_extraction noextract
val qinv2 (x_11 x_1011 x_1101 x6 x8 x14: qelem) : Stack unit
(requires fun h ->
live h x_11 /\ live h x_1011 /\ live h x_1101 /\
live h x6 /\ live h x8 /\ live h x14 /\
disjoint x_11 x6 /\ disjoint x_11 x8 /\ disjoint x_11 x14 /\
disjoint x_1011 x6 /\ disjoint x_1011 x8 /\ disjoint x_1011 x14 /\
disjoint x_1101 x6 /\ disjoint x_1101 x8 /\ disjoint x_1101 x14 /\
disjoint x6 x8 /\ disjoint x6 x14 /\ disjoint x8 x14 /\
qe_lt_q h x_11 /\ qe_lt_q h x_1011 /\ qe_lt_q h x_1101)
(ensures fun h0 _ h1 -> modifies (loc x6 |+| loc x8 |+| loc x14) h0 h1 /\
(let _x6 = S.qmul (SI.qsquare_times (qas_nat h0 x_1101) 2) (qas_nat h0 x_1011) in
let _x8 = S.qmul (SI.qsquare_times _x6 2) (qas_nat h0 x_11) in
let _x14 = S.qmul (SI.qsquare_times _x8 6) _x6 in
qas_nat h1 x6 == _x6 /\ qe_lt_q h1 x6 /\
qas_nat h1 x8 == _x8 /\ qe_lt_q h1 x8 /\
qas_nat h1 x14 == _x14 /\ qe_lt_q h1 x14))
let qinv2 x_11 x_1011 x_1101 x6 x8 x14 =
let h0 = ST.get () in
qsquare_times x6 x_1101 2ul;
qmul x6 x6 x_1011;
let h1 = ST.get () in
assert (qas_nat h1 x6 == S.qmul (SI.qsquare_times (qas_nat h0 x_1101) 2) (qas_nat h0 x_1011));
qsquare_times x8 x6 2ul;
qmul x8 x8 x_11;
let h2 = ST.get () in
assert (qas_nat h2 x8 == S.qmul (SI.qsquare_times (qas_nat h1 x6) 2) (qas_nat h0 x_11));
qsquare_times x14 x8 6ul;
qmul x14 x14 x6;
let h3 = ST.get () in
assert (qas_nat h3 x14 == S.qmul (SI.qsquare_times (qas_nat h2 x8) 6) (qas_nat h1 x6))
inline_for_extraction noextract
val qinv3 (tmp x14: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h x14 /\ disjoint tmp x14 /\
qe_lt_q h x14)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r0_r1 (qas_nat h0 x14) /\
qe_lt_q h1 tmp)
let qinv3 tmp x14 =
push_frame ();
let x56 = create_qelem () in
let h0 = ST.get () in
qsquare_times tmp x14 14ul;
qmul tmp tmp x14; //tmp = x28
let h1 = ST.get () in
assert (qas_nat h1 tmp == S.qmul (SI.qsquare_times (qas_nat h0 x14) 14) (qas_nat h0 x14));
qsquare_times x56 tmp 28ul;
qmul x56 x56 tmp;
let h2 = ST.get () in
assert (qas_nat h2 x56 == S.qmul (SI.qsquare_times (qas_nat h1 tmp) 28) (qas_nat h1 tmp));
qsquare_times tmp x56 56ul; //tmp = r0
qmul tmp tmp x56;
let h3 = ST.get () in
assert (qas_nat h3 tmp == S.qmul (SI.qsquare_times (qas_nat h2 x56) 56) (qas_nat h2 x56));
qsquare_times_in_place tmp 14ul; //tmp = r1
qmul tmp tmp x14;
let h4 = ST.get () in
assert (qas_nat h4 tmp == S.qmul (SI.qsquare_times (qas_nat h3 tmp) 14) (qas_nat h0 x14));
pop_frame ()
//r2; .. ;r8
inline_for_extraction noextract
val qinv4 (tmp x_101 x_111 x_1011: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h x_101 /\ live h x_111 /\ live h x_1011 /\
disjoint tmp x_101 /\ disjoint tmp x_111 /\ disjoint tmp x_1011 /\
qe_lt_q h tmp /\ qe_lt_q h x_101 /\ qe_lt_q h x_111 /\ qe_lt_q h x_1011)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r2_r8 (qas_nat h0 tmp)
(qas_nat h0 x_101) (qas_nat h0 x_111) (qas_nat h0 x_1011) /\
qe_lt_q h1 tmp)
let qinv4 tmp x_101 x_111 x_1011 =
let h0 = ST.get () in
qsquare_times_in_place tmp 3ul;
qmul tmp tmp x_101; //tmp = r2
let h1 = ST.get () in
assert (qas_nat h1 tmp == S.qmul (SI.qsquare_times (qas_nat h0 tmp) 3) (qas_nat h0 x_101));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_111; //tmp = r3
let h2 = ST.get () in
assert (qas_nat h2 tmp == S.qmul (SI.qsquare_times (qas_nat h1 tmp) 4) (qas_nat h0 x_111));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_101; //tmp = r4
let h3 = ST.get () in
assert (qas_nat h3 tmp == S.qmul (SI.qsquare_times (qas_nat h2 tmp) 4) (qas_nat h0 x_101));
qsquare_times_in_place tmp 5ul;
qmul tmp tmp x_1011; //tmp = r5
let h4 = ST.get () in
assert (qas_nat h4 tmp == S.qmul (SI.qsquare_times (qas_nat h3 tmp) 5) (qas_nat h0 x_1011));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_1011; //tmp = r6
let h5 = ST.get () in
assert (qas_nat h5 tmp == S.qmul (SI.qsquare_times (qas_nat h4 tmp) 4) (qas_nat h0 x_1011));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_111; //tmp = r7
let h6 = ST.get () in
assert (qas_nat h6 tmp == S.qmul (SI.qsquare_times (qas_nat h5 tmp) 4) (qas_nat h0 x_111));
qsquare_times_in_place tmp 5ul;
qmul tmp tmp x_111; //tmp = r8
let h7 = ST.get () in
assert (qas_nat h7 tmp == S.qmul (SI.qsquare_times (qas_nat h6 tmp) 5) (qas_nat h0 x_111))
// r9; ..; r15
inline_for_extraction noextract
val qinv5 (tmp x_101 x_111 x_1001 x_1101: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h x_101 /\ live h x_111 /\
live h x_1001 /\ live h x_1101 /\ disjoint tmp x_101 /\
disjoint tmp x_111 /\ disjoint tmp x_1001 /\ disjoint tmp x_1101 /\
qe_lt_q h tmp /\ qe_lt_q h x_101 /\ qe_lt_q h x_111 /\
qe_lt_q h x_1001 /\ qe_lt_q h x_1101)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r9_r15 (qas_nat h0 tmp)
(qas_nat h0 x_101) (qas_nat h0 x_111) (qas_nat h0 x_1001) (qas_nat h0 x_1101) /\
qe_lt_q h1 tmp) | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.K256.Qinv.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.K256.Scalar.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.K256.Qinv.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "SD"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Qinv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.K256.Scalar",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
tmp: Hacl.K256.Scalar.qelem ->
x_101: Hacl.K256.Scalar.qelem ->
x_111: Hacl.K256.Scalar.qelem ->
x_1001: Hacl.K256.Scalar.qelem ->
x_1101: Hacl.K256.Scalar.qelem
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.K256.Scalar.qelem",
"Prims._assert",
"Prims.eq2",
"Prims.nat",
"Hacl.K256.Scalar.qas_nat",
"Spec.K256.PointOps.qmul",
"Hacl.Spec.K256.Qinv.qsquare_times",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Hacl.K256.Scalar.qmul",
"Hacl.Impl.K256.Qinv.qsquare_times_in_place",
"FStar.UInt32.__uint_to_t"
] | [] | false | true | false | false | false | let qinv5 tmp x_101 x_111 x_1001 x_1101 =
| let h0 = ST.get () in
qsquare_times_in_place tmp 6ul;
qmul tmp tmp x_1101;
let h1 = ST.get () in
assert (qas_nat h1 tmp == S.qmul (SI.qsquare_times (qas_nat h0 tmp) 6) (qas_nat h0 x_1101));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_101;
let h2 = ST.get () in
assert (qas_nat h2 tmp == S.qmul (SI.qsquare_times (qas_nat h1 tmp) 4) (qas_nat h0 x_101));
qsquare_times_in_place tmp 3ul;
qmul tmp tmp x_111;
let h3 = ST.get () in
assert (qas_nat h3 tmp == S.qmul (SI.qsquare_times (qas_nat h2 tmp) 3) (qas_nat h0 x_111));
qsquare_times_in_place tmp 5ul;
qmul tmp tmp x_1001;
let h4 = ST.get () in
assert (qas_nat h4 tmp == S.qmul (SI.qsquare_times (qas_nat h3 tmp) 5) (qas_nat h0 x_1001));
qsquare_times_in_place tmp 6ul;
qmul tmp tmp x_101;
let h5 = ST.get () in
assert (qas_nat h5 tmp == S.qmul (SI.qsquare_times (qas_nat h4 tmp) 6) (qas_nat h0 x_101));
qsquare_times_in_place tmp 10ul;
qmul tmp tmp x_111;
let h6 = ST.get () in
assert (qas_nat h6 tmp == S.qmul (SI.qsquare_times (qas_nat h5 tmp) 10) (qas_nat h0 x_111));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_111;
let h7 = ST.get () in
assert (qas_nat h7 tmp == S.qmul (SI.qsquare_times (qas_nat h6 tmp) 4) (qas_nat h0 x_111)) | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.bn_div_pow2_lemma | val bn_div_pow2_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i < len} ->
Lemma (bn_v (bn_div_pow2 b i) == bn_v b / pow2 (bits t * i)) | val bn_div_pow2_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i < len} ->
Lemma (bn_v (bn_div_pow2 b i) == bn_v b / pow2 (bits t * i)) | let bn_div_pow2_lemma #t #len c i =
let pbits = bits t in
calc (==) {
bn_v c / pow2 (pbits * i);
(==) { bn_eval_split_i c i }
(bn_v (slice c 0 i) + pow2 (pbits * i) * bn_v (slice c i len)) / pow2 (pbits * i);
(==) { Math.Lemmas.division_addition_lemma (bn_v (slice c 0 i)) (pow2 (pbits * i)) (bn_v (slice c i len)) }
bn_v (slice c 0 i) / pow2 (pbits * i) + bn_v (slice c i len);
(==) { bn_eval_bound (slice c 0 i) i; Math.Lemmas.small_division_lemma_1 (bn_v (slice c 0 i)) (pow2 (pbits * i)) }
bn_v (slice c i len);
};
assert (bn_v (slice c i len) == bn_v c / pow2 (pbits * i)) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 60,
"end_line": 201,
"start_col": 0,
"start_line": 190
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2)
let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2)
val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t
let bn_get_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[i] j
val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j))
let bn_get_ith_bit_aux_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = b.[i] >>. size j in
calc (==) {
v b.[i] / pow2 j;
(==) { bn_eval_index b i }
(bn_v b / pow2 (pbits * i) % pow2 pbits) / pow2 j;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b / pow2 (pbits * i)) j pbits }
(bn_v b / pow2 (pbits * i) / pow2 j) % pow2 (pbits - j);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b) (pow2 (pbits * i)) (pow2 j) }
(bn_v b / (pow2 (pbits * i) * pow2 j)) % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_plus (pbits * i) j }
(bn_v b / pow2 (pbits * i + j)) % pow2 (pbits - j);
(==) { Math.Lemmas.euclidean_div_axiom ind pbits }
(bn_v b / pow2 ind) % pow2 (pbits - j);
};
assert (v res == (bn_v b / pow2 ind) % pow2 (pbits - j))
val bn_get_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} ->
Lemma (v (bn_get_ith_bit b i) == (bn_v b / pow2 i % 2))
let bn_get_ith_bit_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = limb_get_ith_bit b.[i] j in
limb_get_ith_bit_lemma b.[i] j;
calc (==) {
v b.[i] / pow2 j % 2;
(==) { bn_get_ith_bit_aux_lemma b ind }
(bn_v b / pow2 ind) % pow2 (pbits - j) % 2;
(==) { assert_norm (pow2 1 = 2);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 ind) 1 (pbits - j) }
(bn_v b / pow2 ind) % 2;
};
assert (v res == bn_v b / pow2 ind % 2)
val bn_set_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> lbignum t len
let bn_set_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
let inp = input.[i] <- input.[i] |. (uint #t 1 <<. size j) in
inp
val bn_set_ith_bit_lemma_aux: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a + b * pow2 c < pow2 (c + d) /\ a < pow2 c)
(ensures b < pow2 d)
let bn_set_ith_bit_lemma_aux a b c d =
Math.Lemmas.lemma_div_lt_nat (a + b * pow2 c) (c + d) c;
assert ((a + b * pow2 c) / pow2 c < pow2 d);
Math.Lemmas.lemma_div_plus a b (pow2 c);
assert (a / pow2 c + b < pow2 d);
Math.Lemmas.small_division_lemma_1 a (pow2 c)
val bn_lt_pow2_index_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} -> Lemma
(requires bn_v b < pow2 ind)
(ensures (let i = ind / bits t in v b.[i] < pow2 (ind % bits t) /\
bn_v b == bn_v (slice b 0 i) + pow2 (i * bits t) * v b.[i] /\
bn_v (slice b (i + 1) len) = 0))
let bn_lt_pow2_index_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
Math.Lemmas.euclidean_division_definition ind (pbits);
assert (bn_v b < pow2 (i * pbits + j));
Math.Lemmas.pow2_lt_compat (i * pbits + pbits) (i * pbits + j);
assert (bn_v b < pow2 (i * pbits + pbits));
bn_eval_split_i #t #len b (i + 1);
bn_eval_bound (slice b 0 (i + 1)) (i + 1);
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 (i + 1))) (bn_v (slice b (i + 1) len)) (pbits * (i + 1)) 0;
assert (bn_v b == bn_v (slice b 0 (i + 1)));
bn_eval_split_i #t #(i + 1) (slice b 0 (i + 1)) i;
bn_eval1 (slice b i (i + 1));
assert (bn_v b == bn_v (slice b 0 i) + pow2 (i * pbits) * v b.[i]);
bn_eval_bound #t #i (slice b 0 i) i;
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 i)) (v b.[i]) (i * pbits) j;
assert (v b.[i] < pow2 j)
val bn_set_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> Lemma
(requires bn_v b < pow2 i)
(ensures bn_v (bn_set_ith_bit b i) == bn_v b + pow2 i)
let bn_set_ith_bit_lemma #t #len input ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
bn_lt_pow2_index_lemma #t #len input ind;
assert (v input.[i] < pow2 j);
let b = uint #t 1 <<. size j in
let inp = input.[i] <- input.[i] |. b in
FStar.Math.Lemmas.pow2_lt_compat pbits j;
FStar.Math.Lemmas.modulo_lemma (pow2 j) (pow2 pbits);
assert (v b == pow2 j);
logor_disjoint (input.[i]) b j;
assert (v inp.[i] == v input.[i] + v b);
calc (==) {
bn_v inp;
(==) { bn_eval_split_i #t #len inp (i + 1);
bn_eval_extensionality_j (slice inp (i + 1) len) (slice input (i + 1) len) (len - i - 1) }
bn_v (slice inp 0 (i + 1));
(==) { bn_eval_split_i #t #(i + 1) (slice inp 0 (i + 1)) i }
bn_v (slice inp 0 i) + pow2 (i * pbits) * bn_v (slice inp i (i + 1));
(==) { bn_eval1 (slice inp i (i + 1)) }
bn_v (slice inp 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { bn_eval_extensionality_j input inp i }
bn_v (slice input 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { }
bn_v (slice input 0 i) + pow2 (i * pbits) * (v input.[i] + v b);
(==) { Math.Lemmas.distributivity_add_right (pow2 (i * pbits)) (v input.[i]) (v b) }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 (i * pbits) * v b;
(==) { Math.Lemmas.pow2_plus (i * pbits) j; Math.Lemmas.euclidean_division_definition ind pbits }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 ind;
(==) { }
bn_v input + pow2 ind;
}
///
/// % pow2 and / pow2
///
val bn_div_pow2: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i <= len} -> lbignum t (len - i)
let bn_div_pow2 #t #len b i =
slice b i len
val bn_div_pow2_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i < len} -> | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b: Hacl.Spec.Bignum.Definitions.lbignum t len -> i: Lib.IntTypes.size_nat{i < len}
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Definitions.bn_v (Hacl.Spec.Bignum.Lib.bn_div_pow2 b i) ==
Hacl.Spec.Bignum.Definitions.bn_v b / Prims.pow2 (Lib.IntTypes.bits t * i)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.b2t",
"Prims.op_LessThan",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.op_Subtraction",
"Lib.Sequence.slice",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.op_Division",
"Prims.pow2",
"FStar.Mul.op_Star",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"Prims.op_Addition",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Hacl.Spec.Bignum.Definitions.bn_eval_split_i",
"Prims.squash",
"FStar.Math.Lemmas.division_addition_lemma",
"FStar.Math.Lemmas.small_division_lemma_1",
"Hacl.Spec.Bignum.Definitions.bn_eval_bound",
"Lib.IntTypes.bits"
] | [] | false | false | true | false | false | let bn_div_pow2_lemma #t #len c i =
| let pbits = bits t in
calc ( == ) {
bn_v c / pow2 (pbits * i);
( == ) { bn_eval_split_i c i }
(bn_v (slice c 0 i) + pow2 (pbits * i) * bn_v (slice c i len)) / pow2 (pbits * i);
( == ) { Math.Lemmas.division_addition_lemma (bn_v (slice c 0 i))
(pow2 (pbits * i))
(bn_v (slice c i len)) }
bn_v (slice c 0 i) / pow2 (pbits * i) + bn_v (slice c i len);
( == ) { (bn_eval_bound (slice c 0 i) i;
Math.Lemmas.small_division_lemma_1 (bn_v (slice c 0 i)) (pow2 (pbits * i))) }
bn_v (slice c i len);
};
assert (bn_v (slice c i len) == bn_v c / pow2 (pbits * i)) | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.bn_get_ith_bit_aux_lemma | val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j)) | val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j)) | let bn_get_ith_bit_aux_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = b.[i] >>. size j in
calc (==) {
v b.[i] / pow2 j;
(==) { bn_eval_index b i }
(bn_v b / pow2 (pbits * i) % pow2 pbits) / pow2 j;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b / pow2 (pbits * i)) j pbits }
(bn_v b / pow2 (pbits * i) / pow2 j) % pow2 (pbits - j);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b) (pow2 (pbits * i)) (pow2 j) }
(bn_v b / (pow2 (pbits * i) * pow2 j)) % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_plus (pbits * i) j }
(bn_v b / pow2 (pbits * i + j)) % pow2 (pbits - j);
(==) { Math.Lemmas.euclidean_div_axiom ind pbits }
(bn_v b / pow2 ind) % pow2 (pbits - j);
};
assert (v res == (bn_v b / pow2 ind) % pow2 (pbits - j)) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 58,
"end_line": 65,
"start_col": 0,
"start_line": 45
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2)
let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2)
val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t
let bn_get_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[i] j
val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
b: Hacl.Spec.Bignum.Definitions.lbignum t len ->
ind: Lib.IntTypes.size_nat{ind / Lib.IntTypes.bits t < len}
-> FStar.Pervasives.Lemma
(ensures
(let i = ind / Lib.IntTypes.bits t in
let j = ind % Lib.IntTypes.bits t in
Lib.IntTypes.v (b.[ i ] >>. Lib.IntTypes.size j) ==
Hacl.Spec.Bignum.Definitions.bn_v b / Prims.pow2 ind % Prims.pow2 (Lib.IntTypes.bits t - j))
) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Division",
"Lib.IntTypes.bits",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims.op_Modulus",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.pow2",
"Prims.op_Subtraction",
"Prims.unit",
"FStar.Calc.calc_finish",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Hacl.Spec.Bignum.Definitions.bn_eval_index",
"Prims.squash",
"FStar.Math.Lemmas.pow2_modulo_division_lemma_1",
"FStar.Math.Lemmas.division_multiplication_lemma",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.euclidean_div_axiom",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Greater_Greater_Dot",
"Lib.IntTypes.size"
] | [] | false | false | true | false | false | let bn_get_ith_bit_aux_lemma #t #len b ind =
| let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = b.[ i ] >>. size j in
calc ( == ) {
v b.[ i ] / pow2 j;
( == ) { bn_eval_index b i }
(bn_v b / pow2 (pbits * i) % pow2 pbits) / pow2 j;
( == ) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b / pow2 (pbits * i)) j pbits }
(bn_v b / pow2 (pbits * i) / pow2 j) % pow2 (pbits - j);
( == ) { Math.Lemmas.division_multiplication_lemma (bn_v b) (pow2 (pbits * i)) (pow2 j) }
(bn_v b / (pow2 (pbits * i) * pow2 j)) % pow2 (pbits - j);
( == ) { Math.Lemmas.pow2_plus (pbits * i) j }
(bn_v b / pow2 (pbits * i + j)) % pow2 (pbits - j);
( == ) { Math.Lemmas.euclidean_div_axiom ind pbits }
(bn_v b / pow2 ind) % pow2 (pbits - j);
};
assert (v res == (bn_v b / pow2 ind) % pow2 (pbits - j)) | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.bn_mod_pow2_lemma | val bn_mod_pow2_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} ->
Lemma (bn_v (bn_mod_pow2 a i) == bn_v a % pow2 (bits t * i)) | val bn_mod_pow2_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} ->
Lemma (bn_v (bn_mod_pow2 a i) == bn_v a % pow2 (bits t * i)) | let bn_mod_pow2_lemma #t #aLen a i =
let pbits = bits t in
calc (==) {
bn_v a % pow2 (pbits * i);
(==) { bn_eval_split_i a i }
(bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v (slice a i aLen)) % pow2 (pbits * i);
(==) { Math.Lemmas.modulo_addition_lemma (bn_v (slice a 0 i)) (pow2 (pbits * i)) (bn_v (slice a i aLen)) }
(bn_v (slice a 0 i)) % pow2 (pbits * i);
(==) { bn_eval_bound (slice a 0 i) i; Math.Lemmas.small_mod (bn_v (slice a 0 i)) (pow2 (pbits * i)) }
bn_v (slice a 0 i);
} | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 219,
"start_col": 0,
"start_line": 209
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2)
let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2)
val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t
let bn_get_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[i] j
val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j))
let bn_get_ith_bit_aux_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = b.[i] >>. size j in
calc (==) {
v b.[i] / pow2 j;
(==) { bn_eval_index b i }
(bn_v b / pow2 (pbits * i) % pow2 pbits) / pow2 j;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b / pow2 (pbits * i)) j pbits }
(bn_v b / pow2 (pbits * i) / pow2 j) % pow2 (pbits - j);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b) (pow2 (pbits * i)) (pow2 j) }
(bn_v b / (pow2 (pbits * i) * pow2 j)) % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_plus (pbits * i) j }
(bn_v b / pow2 (pbits * i + j)) % pow2 (pbits - j);
(==) { Math.Lemmas.euclidean_div_axiom ind pbits }
(bn_v b / pow2 ind) % pow2 (pbits - j);
};
assert (v res == (bn_v b / pow2 ind) % pow2 (pbits - j))
val bn_get_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} ->
Lemma (v (bn_get_ith_bit b i) == (bn_v b / pow2 i % 2))
let bn_get_ith_bit_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = limb_get_ith_bit b.[i] j in
limb_get_ith_bit_lemma b.[i] j;
calc (==) {
v b.[i] / pow2 j % 2;
(==) { bn_get_ith_bit_aux_lemma b ind }
(bn_v b / pow2 ind) % pow2 (pbits - j) % 2;
(==) { assert_norm (pow2 1 = 2);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 ind) 1 (pbits - j) }
(bn_v b / pow2 ind) % 2;
};
assert (v res == bn_v b / pow2 ind % 2)
val bn_set_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> lbignum t len
let bn_set_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
let inp = input.[i] <- input.[i] |. (uint #t 1 <<. size j) in
inp
val bn_set_ith_bit_lemma_aux: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a + b * pow2 c < pow2 (c + d) /\ a < pow2 c)
(ensures b < pow2 d)
let bn_set_ith_bit_lemma_aux a b c d =
Math.Lemmas.lemma_div_lt_nat (a + b * pow2 c) (c + d) c;
assert ((a + b * pow2 c) / pow2 c < pow2 d);
Math.Lemmas.lemma_div_plus a b (pow2 c);
assert (a / pow2 c + b < pow2 d);
Math.Lemmas.small_division_lemma_1 a (pow2 c)
val bn_lt_pow2_index_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} -> Lemma
(requires bn_v b < pow2 ind)
(ensures (let i = ind / bits t in v b.[i] < pow2 (ind % bits t) /\
bn_v b == bn_v (slice b 0 i) + pow2 (i * bits t) * v b.[i] /\
bn_v (slice b (i + 1) len) = 0))
let bn_lt_pow2_index_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
Math.Lemmas.euclidean_division_definition ind (pbits);
assert (bn_v b < pow2 (i * pbits + j));
Math.Lemmas.pow2_lt_compat (i * pbits + pbits) (i * pbits + j);
assert (bn_v b < pow2 (i * pbits + pbits));
bn_eval_split_i #t #len b (i + 1);
bn_eval_bound (slice b 0 (i + 1)) (i + 1);
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 (i + 1))) (bn_v (slice b (i + 1) len)) (pbits * (i + 1)) 0;
assert (bn_v b == bn_v (slice b 0 (i + 1)));
bn_eval_split_i #t #(i + 1) (slice b 0 (i + 1)) i;
bn_eval1 (slice b i (i + 1));
assert (bn_v b == bn_v (slice b 0 i) + pow2 (i * pbits) * v b.[i]);
bn_eval_bound #t #i (slice b 0 i) i;
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 i)) (v b.[i]) (i * pbits) j;
assert (v b.[i] < pow2 j)
val bn_set_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> Lemma
(requires bn_v b < pow2 i)
(ensures bn_v (bn_set_ith_bit b i) == bn_v b + pow2 i)
let bn_set_ith_bit_lemma #t #len input ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
bn_lt_pow2_index_lemma #t #len input ind;
assert (v input.[i] < pow2 j);
let b = uint #t 1 <<. size j in
let inp = input.[i] <- input.[i] |. b in
FStar.Math.Lemmas.pow2_lt_compat pbits j;
FStar.Math.Lemmas.modulo_lemma (pow2 j) (pow2 pbits);
assert (v b == pow2 j);
logor_disjoint (input.[i]) b j;
assert (v inp.[i] == v input.[i] + v b);
calc (==) {
bn_v inp;
(==) { bn_eval_split_i #t #len inp (i + 1);
bn_eval_extensionality_j (slice inp (i + 1) len) (slice input (i + 1) len) (len - i - 1) }
bn_v (slice inp 0 (i + 1));
(==) { bn_eval_split_i #t #(i + 1) (slice inp 0 (i + 1)) i }
bn_v (slice inp 0 i) + pow2 (i * pbits) * bn_v (slice inp i (i + 1));
(==) { bn_eval1 (slice inp i (i + 1)) }
bn_v (slice inp 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { bn_eval_extensionality_j input inp i }
bn_v (slice input 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { }
bn_v (slice input 0 i) + pow2 (i * pbits) * (v input.[i] + v b);
(==) { Math.Lemmas.distributivity_add_right (pow2 (i * pbits)) (v input.[i]) (v b) }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 (i * pbits) * v b;
(==) { Math.Lemmas.pow2_plus (i * pbits) j; Math.Lemmas.euclidean_division_definition ind pbits }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 ind;
(==) { }
bn_v input + pow2 ind;
}
///
/// % pow2 and / pow2
///
val bn_div_pow2: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i <= len} -> lbignum t (len - i)
let bn_div_pow2 #t #len b i =
slice b i len
val bn_div_pow2_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i < len} ->
Lemma (bn_v (bn_div_pow2 b i) == bn_v b / pow2 (bits t * i))
let bn_div_pow2_lemma #t #len c i =
let pbits = bits t in
calc (==) {
bn_v c / pow2 (pbits * i);
(==) { bn_eval_split_i c i }
(bn_v (slice c 0 i) + pow2 (pbits * i) * bn_v (slice c i len)) / pow2 (pbits * i);
(==) { Math.Lemmas.division_addition_lemma (bn_v (slice c 0 i)) (pow2 (pbits * i)) (bn_v (slice c i len)) }
bn_v (slice c 0 i) / pow2 (pbits * i) + bn_v (slice c i len);
(==) { bn_eval_bound (slice c 0 i) i; Math.Lemmas.small_division_lemma_1 (bn_v (slice c 0 i)) (pow2 (pbits * i)) }
bn_v (slice c i len);
};
assert (bn_v (slice c i len) == bn_v c / pow2 (pbits * i))
val bn_mod_pow2: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} -> lbignum t i
let bn_mod_pow2 #t #aLen a i = sub a 0 i
val bn_mod_pow2_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} -> | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> i: Prims.nat{i <= aLen}
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Definitions.bn_v (Hacl.Spec.Bignum.Lib.bn_mod_pow2 a i) ==
Hacl.Spec.Bignum.Definitions.bn_v a % Prims.pow2 (Lib.IntTypes.bits t * i)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Modulus",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.pow2",
"FStar.Mul.op_Star",
"Prims.op_Subtraction",
"Lib.Sequence.slice",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"Prims.op_Addition",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Hacl.Spec.Bignum.Definitions.bn_eval_split_i",
"Prims.squash",
"FStar.Math.Lemmas.modulo_addition_lemma",
"FStar.Math.Lemmas.small_mod",
"Hacl.Spec.Bignum.Definitions.bn_eval_bound",
"Lib.IntTypes.bits"
] | [] | false | false | true | false | false | let bn_mod_pow2_lemma #t #aLen a i =
| let pbits = bits t in
calc ( == ) {
bn_v a % pow2 (pbits * i);
( == ) { bn_eval_split_i a i }
(bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v (slice a i aLen)) % pow2 (pbits * i);
( == ) { Math.Lemmas.modulo_addition_lemma (bn_v (slice a 0 i))
(pow2 (pbits * i))
(bn_v (slice a i aLen)) }
(bn_v (slice a 0 i)) % pow2 (pbits * i);
( == ) { (bn_eval_bound (slice a 0 i) i;
Math.Lemmas.small_mod (bn_v (slice a 0 i)) (pow2 (pbits * i))) }
bn_v (slice a 0 i);
} | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.bn_get_top_index_lemma | val bn_get_top_index_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (let ind = bn_get_top_index #t #len b in
ind < len /\ (ind > 0 ==> v b.[ind] <> 0) /\ (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0)) | val bn_get_top_index_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (let ind = bn_get_top_index #t #len b in
ind < len /\ (ind > 0 ==> v b.[ind] <> 0) /\ (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0)) | let bn_get_top_index_lemma #t #len b =
Loops.eq_repeat_gen0 len (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0;
let res =
Loops.repeati_inductive #size_nat len
(fun i priv ->
priv == Loops.repeat_gen i (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0 /\
priv < len /\ (priv > 0 ==> v b.[priv] <> 0) /\ (forall (k:nat{priv < k /\ k < i}). v b.[k] = 0))
(fun i priv ->
Loops.unfold_repeat_gen (i + 1) (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0 i;
let mask = eq_mask b.[i] (zeros t SEC) in
eq_mask_lemma b.[i] (zeros t SEC);
assert (if v mask = 0 then v b.[i] <> 0 else v b.[i] = 0);
let res = if v mask = 0 then i else priv in
res) 0 in
() | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 349,
"start_col": 0,
"start_line": 335
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2)
let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2)
val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t
let bn_get_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[i] j
val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j))
let bn_get_ith_bit_aux_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = b.[i] >>. size j in
calc (==) {
v b.[i] / pow2 j;
(==) { bn_eval_index b i }
(bn_v b / pow2 (pbits * i) % pow2 pbits) / pow2 j;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b / pow2 (pbits * i)) j pbits }
(bn_v b / pow2 (pbits * i) / pow2 j) % pow2 (pbits - j);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b) (pow2 (pbits * i)) (pow2 j) }
(bn_v b / (pow2 (pbits * i) * pow2 j)) % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_plus (pbits * i) j }
(bn_v b / pow2 (pbits * i + j)) % pow2 (pbits - j);
(==) { Math.Lemmas.euclidean_div_axiom ind pbits }
(bn_v b / pow2 ind) % pow2 (pbits - j);
};
assert (v res == (bn_v b / pow2 ind) % pow2 (pbits - j))
val bn_get_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} ->
Lemma (v (bn_get_ith_bit b i) == (bn_v b / pow2 i % 2))
let bn_get_ith_bit_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = limb_get_ith_bit b.[i] j in
limb_get_ith_bit_lemma b.[i] j;
calc (==) {
v b.[i] / pow2 j % 2;
(==) { bn_get_ith_bit_aux_lemma b ind }
(bn_v b / pow2 ind) % pow2 (pbits - j) % 2;
(==) { assert_norm (pow2 1 = 2);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 ind) 1 (pbits - j) }
(bn_v b / pow2 ind) % 2;
};
assert (v res == bn_v b / pow2 ind % 2)
val bn_set_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> lbignum t len
let bn_set_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
let inp = input.[i] <- input.[i] |. (uint #t 1 <<. size j) in
inp
val bn_set_ith_bit_lemma_aux: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a + b * pow2 c < pow2 (c + d) /\ a < pow2 c)
(ensures b < pow2 d)
let bn_set_ith_bit_lemma_aux a b c d =
Math.Lemmas.lemma_div_lt_nat (a + b * pow2 c) (c + d) c;
assert ((a + b * pow2 c) / pow2 c < pow2 d);
Math.Lemmas.lemma_div_plus a b (pow2 c);
assert (a / pow2 c + b < pow2 d);
Math.Lemmas.small_division_lemma_1 a (pow2 c)
val bn_lt_pow2_index_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} -> Lemma
(requires bn_v b < pow2 ind)
(ensures (let i = ind / bits t in v b.[i] < pow2 (ind % bits t) /\
bn_v b == bn_v (slice b 0 i) + pow2 (i * bits t) * v b.[i] /\
bn_v (slice b (i + 1) len) = 0))
let bn_lt_pow2_index_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
Math.Lemmas.euclidean_division_definition ind (pbits);
assert (bn_v b < pow2 (i * pbits + j));
Math.Lemmas.pow2_lt_compat (i * pbits + pbits) (i * pbits + j);
assert (bn_v b < pow2 (i * pbits + pbits));
bn_eval_split_i #t #len b (i + 1);
bn_eval_bound (slice b 0 (i + 1)) (i + 1);
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 (i + 1))) (bn_v (slice b (i + 1) len)) (pbits * (i + 1)) 0;
assert (bn_v b == bn_v (slice b 0 (i + 1)));
bn_eval_split_i #t #(i + 1) (slice b 0 (i + 1)) i;
bn_eval1 (slice b i (i + 1));
assert (bn_v b == bn_v (slice b 0 i) + pow2 (i * pbits) * v b.[i]);
bn_eval_bound #t #i (slice b 0 i) i;
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 i)) (v b.[i]) (i * pbits) j;
assert (v b.[i] < pow2 j)
val bn_set_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> Lemma
(requires bn_v b < pow2 i)
(ensures bn_v (bn_set_ith_bit b i) == bn_v b + pow2 i)
let bn_set_ith_bit_lemma #t #len input ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
bn_lt_pow2_index_lemma #t #len input ind;
assert (v input.[i] < pow2 j);
let b = uint #t 1 <<. size j in
let inp = input.[i] <- input.[i] |. b in
FStar.Math.Lemmas.pow2_lt_compat pbits j;
FStar.Math.Lemmas.modulo_lemma (pow2 j) (pow2 pbits);
assert (v b == pow2 j);
logor_disjoint (input.[i]) b j;
assert (v inp.[i] == v input.[i] + v b);
calc (==) {
bn_v inp;
(==) { bn_eval_split_i #t #len inp (i + 1);
bn_eval_extensionality_j (slice inp (i + 1) len) (slice input (i + 1) len) (len - i - 1) }
bn_v (slice inp 0 (i + 1));
(==) { bn_eval_split_i #t #(i + 1) (slice inp 0 (i + 1)) i }
bn_v (slice inp 0 i) + pow2 (i * pbits) * bn_v (slice inp i (i + 1));
(==) { bn_eval1 (slice inp i (i + 1)) }
bn_v (slice inp 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { bn_eval_extensionality_j input inp i }
bn_v (slice input 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { }
bn_v (slice input 0 i) + pow2 (i * pbits) * (v input.[i] + v b);
(==) { Math.Lemmas.distributivity_add_right (pow2 (i * pbits)) (v input.[i]) (v b) }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 (i * pbits) * v b;
(==) { Math.Lemmas.pow2_plus (i * pbits) j; Math.Lemmas.euclidean_division_definition ind pbits }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 ind;
(==) { }
bn_v input + pow2 ind;
}
///
/// % pow2 and / pow2
///
val bn_div_pow2: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i <= len} -> lbignum t (len - i)
let bn_div_pow2 #t #len b i =
slice b i len
val bn_div_pow2_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i < len} ->
Lemma (bn_v (bn_div_pow2 b i) == bn_v b / pow2 (bits t * i))
let bn_div_pow2_lemma #t #len c i =
let pbits = bits t in
calc (==) {
bn_v c / pow2 (pbits * i);
(==) { bn_eval_split_i c i }
(bn_v (slice c 0 i) + pow2 (pbits * i) * bn_v (slice c i len)) / pow2 (pbits * i);
(==) { Math.Lemmas.division_addition_lemma (bn_v (slice c 0 i)) (pow2 (pbits * i)) (bn_v (slice c i len)) }
bn_v (slice c 0 i) / pow2 (pbits * i) + bn_v (slice c i len);
(==) { bn_eval_bound (slice c 0 i) i; Math.Lemmas.small_division_lemma_1 (bn_v (slice c 0 i)) (pow2 (pbits * i)) }
bn_v (slice c i len);
};
assert (bn_v (slice c i len) == bn_v c / pow2 (pbits * i))
val bn_mod_pow2: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} -> lbignum t i
let bn_mod_pow2 #t #aLen a i = sub a 0 i
val bn_mod_pow2_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} ->
Lemma (bn_v (bn_mod_pow2 a i) == bn_v a % pow2 (bits t * i))
let bn_mod_pow2_lemma #t #aLen a i =
let pbits = bits t in
calc (==) {
bn_v a % pow2 (pbits * i);
(==) { bn_eval_split_i a i }
(bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v (slice a i aLen)) % pow2 (pbits * i);
(==) { Math.Lemmas.modulo_addition_lemma (bn_v (slice a 0 i)) (pow2 (pbits * i)) (bn_v (slice a i aLen)) }
(bn_v (slice a 0 i)) % pow2 (pbits * i);
(==) { bn_eval_bound (slice a 0 i) i; Math.Lemmas.small_mod (bn_v (slice a 0 i)) (pow2 (pbits * i)) }
bn_v (slice a 0 i);
}
///
/// Conditional swap
///
//the same as in curve25519
val lemma_cswap2_step:
#t:limb_t
-> bit:limb t{v bit <= 1}
-> p1:limb t
-> p2:limb t ->
Lemma
(let mask = uint #t 0 -. bit in
let dummy = mask &. (p1 ^. p2) in
let p1' = p1 ^. dummy in
let p2' = p2 ^. dummy in
if v bit = 1 then p1' == p2 /\ p2' == p1 else p1' == p1 /\ p2' == p2)
let lemma_cswap2_step #t bit p1 p2 =
let mask = uint #t 0 -. bit in
assert (v bit == 0 ==> v mask == 0);
assert (v bit == 1 ==> v mask == pow2 (bits t) - 1);
let dummy = mask &. (p1 ^. p2) in
logand_lemma mask (p1 ^. p2);
assert (v bit == 1 ==> v dummy == v (p1 ^. p2));
assert (v bit == 0 ==> v dummy == 0);
let p1' = p1 ^. dummy in
assert (v dummy == v (if v bit = 1 then (p1 ^. p2) else uint #t 0));
logxor_lemma p1 p2;
let p2' = p2 ^. dummy in
logxor_lemma p2 p1
val cswap2_f:
#t:limb_t
-> #len:size_nat
-> mask:limb t
-> i:nat{i < len}
-> tuple2 (lbignum t len) (lbignum t len) ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2_f #t #len mask i (p1, p2) =
let dummy = mask &. (p1.[i] ^. p2.[i]) in
let p1 = p1.[i] <- p1.[i] ^. dummy in
let p2 = p2.[i] <- p2.[i] ^. dummy in
(p1, p2)
val cswap2:
#t:limb_t
-> #len:size_nat
-> bit:limb t
-> b1:lbignum t len
-> b2:lbignum t len ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2 #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.repeati len (cswap2_f #t #len mask) (b1, b2)
val cswap2_lemma:
#t:limb_t
-> #len:size_nat
-> bit:limb t{v bit <= 1}
-> b1:lbignum t len
-> b2:lbignum t len ->
Lemma (let (p1, p2) = cswap2 bit b1 b2 in
(if v bit = 1 then p1 == b2 /\ p2 == b1 else p1 == b1 /\ p2 == b2))
let cswap2_lemma #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.eq_repeati0 len (cswap2_f #t #len mask) (b1, b2);
let (p1, p2) =
Loops.repeati_inductive #(tuple2 (lbignum t len) (lbignum t len)) len
(fun i (p1, p2) ->
(p1, p2) == Loops.repeati i (cswap2_f #t #len mask) (b1, b2) /\
(forall (k:nat{k < i}).
(if v bit = 1 then p1.[k] == b2.[k] /\ p2.[k] == b1.[k] else p1.[k] == b1.[k] /\ p2.[k] == b2.[k])) /\
(forall (k:nat{i <= k /\ k < len}). p1.[k] == b1.[k] /\ p2.[k] == b2.[k]))
(fun i (p1, p2) ->
Loops.unfold_repeati (i + 1) (cswap2_f #t #len mask) (b1, b2) i;
lemma_cswap2_step bit p1.[i] p2.[i];
cswap2_f #t #len mask i (p1, p2)) (b1, b2) in
assert (if v bit = 1 then (eq_intro p1 b2; p1 == b2) else (eq_intro p1 b1; p1 == b1));
assert (if v bit = 1 then (eq_intro p2 b1; p2 == b1) else (eq_intro p2 b2; p2 == b2));
//eq_intro p1 (if v bit = 1 then b2 else b1);
//eq_intro p2 (if v bit = 1 then b1 else b2);
()
let bn_get_top_index_t (len:size_nat) (i:nat{i <= len}) = x:nat{x < len}
val bn_get_top_index_f:
#t:limb_t
-> #len:size_nat
-> b:lbignum t len
-> i:nat{i < len}
-> priv:bn_get_top_index_t len i ->
bn_get_top_index_t len (i + 1)
let bn_get_top_index_f #t #len b i priv =
let mask = eq_mask b.[i] (zeros t SEC) in
if v mask = 0 then i else priv
val bn_get_top_index: #t:limb_t -> #len:size_pos -> b:lbignum t len -> res:size_nat{res < len}
let bn_get_top_index #t #len b =
Loops.repeat_gen len (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0
val bn_get_top_index_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (let ind = bn_get_top_index #t #len b in
ind < len /\ (ind > 0 ==> v b.[ind] <> 0) /\ (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b: Hacl.Spec.Bignum.Definitions.lbignum t len
-> FStar.Pervasives.Lemma
(ensures
(let ind = Hacl.Spec.Bignum.Lib.bn_get_top_index b in
ind < len /\ (ind > 0 ==> Lib.IntTypes.v b.[ ind ] <> 0) /\
(forall (k: Prims.nat{ind < k /\ k < len}). Lib.IntTypes.v b.[ k ] = 0))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.l_and",
"Prims.eq2",
"Prims.l_or",
"Prims.op_LessThan",
"Lib.LoopCombinators.repeat_gen",
"Hacl.Spec.Bignum.Lib.bn_get_top_index_t",
"Hacl.Spec.Bignum.Lib.bn_get_top_index_f",
"Prims.l_imp",
"Prims.op_GreaterThan",
"Prims.op_disEquality",
"Prims.int",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Lib.Sequence.index",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.l_Forall",
"Prims.op_Equality",
"Lib.LoopCombinators.repeati_inductive",
"Lib.IntTypes.size_nat",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.op_String_Access",
"Prims.op_Addition",
"Prims.bool",
"Prims.unit",
"Prims._assert",
"Lib.IntTypes.eq_mask_lemma",
"Lib.IntTypes.zeros",
"Lib.IntTypes.int_t",
"Lib.IntTypes.eq_mask",
"Lib.LoopCombinators.unfold_repeat_gen",
"Lib.LoopCombinators.eq_repeat_gen0"
] | [] | false | false | true | false | false | let bn_get_top_index_lemma #t #len b =
| Loops.eq_repeat_gen0 len (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0;
let res =
Loops.repeati_inductive #size_nat
len
(fun i priv ->
priv == Loops.repeat_gen i (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0 /\
priv < len /\ (priv > 0 ==> v b.[ priv ] <> 0) /\
(forall (k: nat{priv < k /\ k < i}). v b.[ k ] = 0))
(fun i priv ->
Loops.unfold_repeat_gen (i + 1) (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0 i;
let mask = eq_mask b.[ i ] (zeros t SEC) in
eq_mask_lemma b.[ i ] (zeros t SEC);
assert (if v mask = 0 then v b.[ i ] <> 0 else v b.[ i ] = 0);
let res = if v mask = 0 then i else priv in
res)
0
in
() | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.bn_get_bits_lemma | val bn_get_bits_lemma:
#t:limb_t
-> #nLen:size_nat
-> n:lbignum t nLen
-> i:size_nat
-> l:size_nat{l < bits t /\ i / bits t < nLen} ->
Lemma (v (bn_get_bits n i l) == bn_v n / pow2 i % pow2 l) | val bn_get_bits_lemma:
#t:limb_t
-> #nLen:size_nat
-> n:lbignum t nLen
-> i:size_nat
-> l:size_nat{l < bits t /\ i / bits t < nLen} ->
Lemma (v (bn_get_bits n i l) == bn_v n / pow2 i % pow2 l) | let bn_get_bits_lemma #t #nLen n ind l =
let tmp = bn_get_bits_limb n ind in
let mask_l = (uint #t #SEC 1 <<. size l) -. uint #t 1 in
let tmp1 = tmp &. mask_l in
Math.Lemmas.pow2_lt_compat (bits t) l;
mod_mask_lemma tmp (size l);
assert (v (mod_mask #t #SEC (size l)) == v mask_l);
assert (v tmp1 == v tmp % pow2 l);
bn_get_bits_limb_lemma #t #nLen n ind;
assert (v tmp1 == bn_v n / pow2 ind % pow2 (bits t) % pow2 l);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v n / pow2 ind) l (bits t);
assert (v tmp1 == bn_v n / pow2 ind % pow2 l) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 47,
"end_line": 538,
"start_col": 0,
"start_line": 527
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2)
let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2)
val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t
let bn_get_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[i] j
val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j))
let bn_get_ith_bit_aux_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = b.[i] >>. size j in
calc (==) {
v b.[i] / pow2 j;
(==) { bn_eval_index b i }
(bn_v b / pow2 (pbits * i) % pow2 pbits) / pow2 j;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b / pow2 (pbits * i)) j pbits }
(bn_v b / pow2 (pbits * i) / pow2 j) % pow2 (pbits - j);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b) (pow2 (pbits * i)) (pow2 j) }
(bn_v b / (pow2 (pbits * i) * pow2 j)) % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_plus (pbits * i) j }
(bn_v b / pow2 (pbits * i + j)) % pow2 (pbits - j);
(==) { Math.Lemmas.euclidean_div_axiom ind pbits }
(bn_v b / pow2 ind) % pow2 (pbits - j);
};
assert (v res == (bn_v b / pow2 ind) % pow2 (pbits - j))
val bn_get_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} ->
Lemma (v (bn_get_ith_bit b i) == (bn_v b / pow2 i % 2))
let bn_get_ith_bit_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = limb_get_ith_bit b.[i] j in
limb_get_ith_bit_lemma b.[i] j;
calc (==) {
v b.[i] / pow2 j % 2;
(==) { bn_get_ith_bit_aux_lemma b ind }
(bn_v b / pow2 ind) % pow2 (pbits - j) % 2;
(==) { assert_norm (pow2 1 = 2);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 ind) 1 (pbits - j) }
(bn_v b / pow2 ind) % 2;
};
assert (v res == bn_v b / pow2 ind % 2)
val bn_set_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> lbignum t len
let bn_set_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
let inp = input.[i] <- input.[i] |. (uint #t 1 <<. size j) in
inp
val bn_set_ith_bit_lemma_aux: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a + b * pow2 c < pow2 (c + d) /\ a < pow2 c)
(ensures b < pow2 d)
let bn_set_ith_bit_lemma_aux a b c d =
Math.Lemmas.lemma_div_lt_nat (a + b * pow2 c) (c + d) c;
assert ((a + b * pow2 c) / pow2 c < pow2 d);
Math.Lemmas.lemma_div_plus a b (pow2 c);
assert (a / pow2 c + b < pow2 d);
Math.Lemmas.small_division_lemma_1 a (pow2 c)
val bn_lt_pow2_index_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} -> Lemma
(requires bn_v b < pow2 ind)
(ensures (let i = ind / bits t in v b.[i] < pow2 (ind % bits t) /\
bn_v b == bn_v (slice b 0 i) + pow2 (i * bits t) * v b.[i] /\
bn_v (slice b (i + 1) len) = 0))
let bn_lt_pow2_index_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
Math.Lemmas.euclidean_division_definition ind (pbits);
assert (bn_v b < pow2 (i * pbits + j));
Math.Lemmas.pow2_lt_compat (i * pbits + pbits) (i * pbits + j);
assert (bn_v b < pow2 (i * pbits + pbits));
bn_eval_split_i #t #len b (i + 1);
bn_eval_bound (slice b 0 (i + 1)) (i + 1);
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 (i + 1))) (bn_v (slice b (i + 1) len)) (pbits * (i + 1)) 0;
assert (bn_v b == bn_v (slice b 0 (i + 1)));
bn_eval_split_i #t #(i + 1) (slice b 0 (i + 1)) i;
bn_eval1 (slice b i (i + 1));
assert (bn_v b == bn_v (slice b 0 i) + pow2 (i * pbits) * v b.[i]);
bn_eval_bound #t #i (slice b 0 i) i;
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 i)) (v b.[i]) (i * pbits) j;
assert (v b.[i] < pow2 j)
val bn_set_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> Lemma
(requires bn_v b < pow2 i)
(ensures bn_v (bn_set_ith_bit b i) == bn_v b + pow2 i)
let bn_set_ith_bit_lemma #t #len input ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
bn_lt_pow2_index_lemma #t #len input ind;
assert (v input.[i] < pow2 j);
let b = uint #t 1 <<. size j in
let inp = input.[i] <- input.[i] |. b in
FStar.Math.Lemmas.pow2_lt_compat pbits j;
FStar.Math.Lemmas.modulo_lemma (pow2 j) (pow2 pbits);
assert (v b == pow2 j);
logor_disjoint (input.[i]) b j;
assert (v inp.[i] == v input.[i] + v b);
calc (==) {
bn_v inp;
(==) { bn_eval_split_i #t #len inp (i + 1);
bn_eval_extensionality_j (slice inp (i + 1) len) (slice input (i + 1) len) (len - i - 1) }
bn_v (slice inp 0 (i + 1));
(==) { bn_eval_split_i #t #(i + 1) (slice inp 0 (i + 1)) i }
bn_v (slice inp 0 i) + pow2 (i * pbits) * bn_v (slice inp i (i + 1));
(==) { bn_eval1 (slice inp i (i + 1)) }
bn_v (slice inp 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { bn_eval_extensionality_j input inp i }
bn_v (slice input 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { }
bn_v (slice input 0 i) + pow2 (i * pbits) * (v input.[i] + v b);
(==) { Math.Lemmas.distributivity_add_right (pow2 (i * pbits)) (v input.[i]) (v b) }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 (i * pbits) * v b;
(==) { Math.Lemmas.pow2_plus (i * pbits) j; Math.Lemmas.euclidean_division_definition ind pbits }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 ind;
(==) { }
bn_v input + pow2 ind;
}
///
/// % pow2 and / pow2
///
val bn_div_pow2: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i <= len} -> lbignum t (len - i)
let bn_div_pow2 #t #len b i =
slice b i len
val bn_div_pow2_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i < len} ->
Lemma (bn_v (bn_div_pow2 b i) == bn_v b / pow2 (bits t * i))
let bn_div_pow2_lemma #t #len c i =
let pbits = bits t in
calc (==) {
bn_v c / pow2 (pbits * i);
(==) { bn_eval_split_i c i }
(bn_v (slice c 0 i) + pow2 (pbits * i) * bn_v (slice c i len)) / pow2 (pbits * i);
(==) { Math.Lemmas.division_addition_lemma (bn_v (slice c 0 i)) (pow2 (pbits * i)) (bn_v (slice c i len)) }
bn_v (slice c 0 i) / pow2 (pbits * i) + bn_v (slice c i len);
(==) { bn_eval_bound (slice c 0 i) i; Math.Lemmas.small_division_lemma_1 (bn_v (slice c 0 i)) (pow2 (pbits * i)) }
bn_v (slice c i len);
};
assert (bn_v (slice c i len) == bn_v c / pow2 (pbits * i))
val bn_mod_pow2: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} -> lbignum t i
let bn_mod_pow2 #t #aLen a i = sub a 0 i
val bn_mod_pow2_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} ->
Lemma (bn_v (bn_mod_pow2 a i) == bn_v a % pow2 (bits t * i))
let bn_mod_pow2_lemma #t #aLen a i =
let pbits = bits t in
calc (==) {
bn_v a % pow2 (pbits * i);
(==) { bn_eval_split_i a i }
(bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v (slice a i aLen)) % pow2 (pbits * i);
(==) { Math.Lemmas.modulo_addition_lemma (bn_v (slice a 0 i)) (pow2 (pbits * i)) (bn_v (slice a i aLen)) }
(bn_v (slice a 0 i)) % pow2 (pbits * i);
(==) { bn_eval_bound (slice a 0 i) i; Math.Lemmas.small_mod (bn_v (slice a 0 i)) (pow2 (pbits * i)) }
bn_v (slice a 0 i);
}
///
/// Conditional swap
///
//the same as in curve25519
val lemma_cswap2_step:
#t:limb_t
-> bit:limb t{v bit <= 1}
-> p1:limb t
-> p2:limb t ->
Lemma
(let mask = uint #t 0 -. bit in
let dummy = mask &. (p1 ^. p2) in
let p1' = p1 ^. dummy in
let p2' = p2 ^. dummy in
if v bit = 1 then p1' == p2 /\ p2' == p1 else p1' == p1 /\ p2' == p2)
let lemma_cswap2_step #t bit p1 p2 =
let mask = uint #t 0 -. bit in
assert (v bit == 0 ==> v mask == 0);
assert (v bit == 1 ==> v mask == pow2 (bits t) - 1);
let dummy = mask &. (p1 ^. p2) in
logand_lemma mask (p1 ^. p2);
assert (v bit == 1 ==> v dummy == v (p1 ^. p2));
assert (v bit == 0 ==> v dummy == 0);
let p1' = p1 ^. dummy in
assert (v dummy == v (if v bit = 1 then (p1 ^. p2) else uint #t 0));
logxor_lemma p1 p2;
let p2' = p2 ^. dummy in
logxor_lemma p2 p1
val cswap2_f:
#t:limb_t
-> #len:size_nat
-> mask:limb t
-> i:nat{i < len}
-> tuple2 (lbignum t len) (lbignum t len) ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2_f #t #len mask i (p1, p2) =
let dummy = mask &. (p1.[i] ^. p2.[i]) in
let p1 = p1.[i] <- p1.[i] ^. dummy in
let p2 = p2.[i] <- p2.[i] ^. dummy in
(p1, p2)
val cswap2:
#t:limb_t
-> #len:size_nat
-> bit:limb t
-> b1:lbignum t len
-> b2:lbignum t len ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2 #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.repeati len (cswap2_f #t #len mask) (b1, b2)
val cswap2_lemma:
#t:limb_t
-> #len:size_nat
-> bit:limb t{v bit <= 1}
-> b1:lbignum t len
-> b2:lbignum t len ->
Lemma (let (p1, p2) = cswap2 bit b1 b2 in
(if v bit = 1 then p1 == b2 /\ p2 == b1 else p1 == b1 /\ p2 == b2))
let cswap2_lemma #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.eq_repeati0 len (cswap2_f #t #len mask) (b1, b2);
let (p1, p2) =
Loops.repeati_inductive #(tuple2 (lbignum t len) (lbignum t len)) len
(fun i (p1, p2) ->
(p1, p2) == Loops.repeati i (cswap2_f #t #len mask) (b1, b2) /\
(forall (k:nat{k < i}).
(if v bit = 1 then p1.[k] == b2.[k] /\ p2.[k] == b1.[k] else p1.[k] == b1.[k] /\ p2.[k] == b2.[k])) /\
(forall (k:nat{i <= k /\ k < len}). p1.[k] == b1.[k] /\ p2.[k] == b2.[k]))
(fun i (p1, p2) ->
Loops.unfold_repeati (i + 1) (cswap2_f #t #len mask) (b1, b2) i;
lemma_cswap2_step bit p1.[i] p2.[i];
cswap2_f #t #len mask i (p1, p2)) (b1, b2) in
assert (if v bit = 1 then (eq_intro p1 b2; p1 == b2) else (eq_intro p1 b1; p1 == b1));
assert (if v bit = 1 then (eq_intro p2 b1; p2 == b1) else (eq_intro p2 b2; p2 == b2));
//eq_intro p1 (if v bit = 1 then b2 else b1);
//eq_intro p2 (if v bit = 1 then b1 else b2);
()
let bn_get_top_index_t (len:size_nat) (i:nat{i <= len}) = x:nat{x < len}
val bn_get_top_index_f:
#t:limb_t
-> #len:size_nat
-> b:lbignum t len
-> i:nat{i < len}
-> priv:bn_get_top_index_t len i ->
bn_get_top_index_t len (i + 1)
let bn_get_top_index_f #t #len b i priv =
let mask = eq_mask b.[i] (zeros t SEC) in
if v mask = 0 then i else priv
val bn_get_top_index: #t:limb_t -> #len:size_pos -> b:lbignum t len -> res:size_nat{res < len}
let bn_get_top_index #t #len b =
Loops.repeat_gen len (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0
val bn_get_top_index_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (let ind = bn_get_top_index #t #len b in
ind < len /\ (ind > 0 ==> v b.[ind] <> 0) /\ (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0))
let bn_get_top_index_lemma #t #len b =
Loops.eq_repeat_gen0 len (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0;
let res =
Loops.repeati_inductive #size_nat len
(fun i priv ->
priv == Loops.repeat_gen i (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0 /\
priv < len /\ (priv > 0 ==> v b.[priv] <> 0) /\ (forall (k:nat{priv < k /\ k < i}). v b.[k] = 0))
(fun i priv ->
Loops.unfold_repeat_gen (i + 1) (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0 i;
let mask = eq_mask b.[i] (zeros t SEC) in
eq_mask_lemma b.[i] (zeros t SEC);
assert (if v mask = 0 then v b.[i] <> 0 else v b.[i] = 0);
let res = if v mask = 0 then i else priv in
res) 0 in
()
val bn_get_top_index_eval_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len -> ind:nat -> Lemma
(requires
ind < len /\ (ind > 0 ==> v b.[ind] <> 0) /\ (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0))
(ensures
bn_v b == bn_v (slice b 0 ind) + pow2 (bits t * ind) * v b.[ind])
let bn_get_top_index_eval_lemma #t #len b ind =
let pbits = bits t in
assert (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0);
bn_eval_split_i b (ind + 1);
assert (bn_v b == bn_v (slice b 0 (ind + 1)) + pow2 (pbits * (ind + 1)) * bn_v (slice b (ind + 1) len));
eq_intro (slice b (ind + 1) len) (create (len - ind - 1) (uint #t 0));
bn_eval_zeroes #t (len - ind - 1) (len - ind - 1);
assert (bn_v b == bn_v (slice b 0 (ind + 1)));
bn_eval_split_i (slice b 0 (ind + 1)) ind;
assert (bn_v b == bn_v (slice b 0 ind) + pow2 (pbits * ind) * bn_v (slice b ind (ind + 1)));
bn_eval1 (slice b ind (ind + 1));
assert (bn_v b == bn_v (slice b 0 ind) + pow2 (pbits * ind) * v b.[ind])
val bn_low_bound_bits:
#t:limb_t
-> #len:size_pos{bits t * len <= max_size_t}
-> b:lbignum t len ->
res:size_nat{res / bits t < len}
let bn_low_bound_bits #t #len b =
bits t * bn_get_top_index b
val bn_low_bound_bits_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len -> Lemma
(requires 1 < bn_v b /\ bits t * len <= max_size_t /\ bn_v b % 2 = 1)
(ensures pow2 (bn_low_bound_bits b) < bn_v b)
let bn_low_bound_bits_lemma #t #len b =
let ind = bn_get_top_index #t #len b in
bn_get_top_index_lemma #t #len b;
bn_get_top_index_eval_lemma #t #len b ind;
assert (pow2 (bn_low_bound_bits b) <= bn_v b);
if ind = 0 then
assert_norm (pow2 0 = 1)
else
Math.Lemmas.pow2_multiplication_modulo_lemma_1 1 1 (bn_low_bound_bits b)
val bn_get_bits_limb:
#t:limb_t
-> #nLen:size_nat
-> n:lbignum t nLen
-> ind:size_nat{ind / bits t < nLen} ->
limb t
let bn_get_bits_limb #t #nLen n ind =
let i = ind / bits t in
let j = ind % bits t in
let p1 = n.[i] >>. size j in
let p2 = if i + 1 < nLen && 0 < j then p1 |. (n.[i + 1] <<. (size (bits t - j))) else p1 in
p2
val bn_get_bits_limb_aux_lemma:
#t:limb_t
-> #nLen:size_nat
-> n:lbignum t nLen
-> ind:size_nat{ind / bits t < nLen} ->
Lemma (
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let p1 = n.[i] >>. size j in
bn_v n / pow2 ind % pow2 pbits == bn_v n / pow2 ((i + 1) * pbits) % pow2 pbits * pow2 (pbits - j) % pow2 pbits + v p1)
let bn_get_bits_limb_aux_lemma #t #nLen n ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let p1 = n.[i] >>. size j in
let res = bn_v n / pow2 ind % pow2 pbits in
calc (==) {
bn_v n / pow2 ind % pow2 pbits;
(==) { Math.Lemmas.euclidean_division_definition res (pow2 (pbits - j)) }
res / pow2 (pbits - j) * pow2 (pbits - j) + res % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v n / pow2 ind) (pbits - j) pbits }
res / pow2 (pbits - j) * pow2 (pbits - j) + bn_v n / pow2 ind % pow2 (pbits - j);
(==) { bn_get_ith_bit_aux_lemma n ind }
res / pow2 (pbits - j) * pow2 (pbits - j) + v p1;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v n / pow2 ind) (pbits - j) pbits }
bn_v n / pow2 ind / pow2 (pbits - j) % pow2 j * pow2 (pbits - j) + v p1;
(==) { Math.Lemmas.division_multiplication_lemma (bn_v n) (pow2 ind) (pow2 (pbits - j)) }
bn_v n / (pow2 ind * pow2 (pbits - j)) % pow2 j * pow2 (pbits - j) + v p1;
(==) { Math.Lemmas.pow2_plus ind (pbits - j) }
bn_v n / pow2 (ind + pbits - j) % pow2 j * pow2 (pbits - j) + v p1;
(==) { Math.Lemmas.euclidean_division_definition ind pbits }
bn_v n / pow2 (i * pbits + pbits) % pow2 j * pow2 (pbits - j) + v p1;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (bn_v n / pow2 (i * pbits + pbits)) pbits (pbits - j) }
bn_v n / pow2 (i * pbits + pbits) * pow2 (pbits - j) % pow2 pbits + v p1;
(==) { Math.Lemmas.distributivity_add_left i 1 pbits }
bn_v n / pow2 ((i + 1) * pbits) * pow2 (pbits - j) % pow2 pbits + v p1;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (bn_v n / pow2 ((i + 1) * pbits)) (pow2 (pbits - j)) (pow2 pbits) }
bn_v n / pow2 ((i + 1) * pbits) % pow2 pbits * pow2 (pbits - j) % pow2 pbits + v p1;
}
val bn_get_bits_limb_lemma:
#t:limb_t
-> #nLen:size_nat
-> n:lbignum t nLen
-> ind:size_nat{ind / bits t < nLen} ->
Lemma (v (bn_get_bits_limb n ind) == bn_v n / pow2 ind % pow2 (bits t))
#push-options "--z3rlimit 100"
let bn_get_bits_limb_lemma #t #nLen n ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
assert (i == ind / bits t);
assert (i < nLen);
let p1 = n.[i] >>. size j in
let res = bn_v n / pow2 ind % pow2 pbits in
bn_get_ith_bit_aux_lemma n ind;
assert (v p1 == bn_v n / pow2 ind % pow2 (pbits - j));
if j = 0 then () else begin
bn_get_bits_limb_aux_lemma n ind;
if i + 1 < nLen then begin
let p2 = n.[i + 1] <<. (size (pbits - j)) in
calc (==) {
v p2 % pow2 (pbits - j);
(==) { }
v n.[i + 1] * pow2 (pbits - j) % pow2 pbits % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (v n.[i + 1] * pow2 (pbits - j)) (pbits - j) pbits }
v n.[i + 1] * pow2 (pbits - j) % pow2 (pbits - j);
(==) { Math.Lemmas.multiple_modulo_lemma (v n.[i + 1]) (pow2 (pbits - j)) }
0;
};
let p3 = p1 |. p2 in
logor_disjoint p1 p2 (pbits - j);
assert (v p3 == v p1 + v p2);
bn_eval_index n (i + 1);
assert (res == v p1 + v p2);
assert (ind / bits t + 1 < nLen && 0 < ind % bits t) end
else begin
bn_eval_bound n nLen;
assert (bn_v n < pow2 (nLen * pbits));
Math.Lemmas.lemma_div_lt_nat (bn_v n) (nLen * pbits) ((i + 1) * pbits);
Math.Lemmas.pow2_minus (nLen * pbits) ((i + 1) * pbits);
assert (bn_v n / pow2 ((i + 1) * pbits) < pow2 0);
assert_norm (pow2 0 = 1);
assert (res == v p1)
end
end
#pop-options
val bn_get_bits:
#t:limb_t
-> #nLen:size_nat
-> n:lbignum t nLen
-> i:size_nat
-> l:size_nat{l < bits t /\ i / bits t < nLen} ->
limb t
let bn_get_bits #t #nLen n ind l =
let mask_l = (uint #t #SEC 1 <<. size l) -. uint #t 1 in
bn_get_bits_limb n ind &. mask_l
val bn_get_bits_lemma:
#t:limb_t
-> #nLen:size_nat
-> n:lbignum t nLen
-> i:size_nat
-> l:size_nat{l < bits t /\ i / bits t < nLen} ->
Lemma (v (bn_get_bits n i l) == bn_v n / pow2 i % pow2 l) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
n: Hacl.Spec.Bignum.Definitions.lbignum t nLen ->
i: Lib.IntTypes.size_nat ->
l: Lib.IntTypes.size_nat{l < Lib.IntTypes.bits t /\ i / Lib.IntTypes.bits t < nLen}
-> FStar.Pervasives.Lemma
(ensures
Lib.IntTypes.v (Hacl.Spec.Bignum.Lib.bn_get_bits n i l) ==
Hacl.Spec.Bignum.Definitions.bn_v n / Prims.pow2 i % Prims.pow2 l) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.bits",
"Prims.op_Division",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims.op_Modulus",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.pow2",
"Prims.unit",
"FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1",
"Hacl.Spec.Bignum.Lib.bn_get_bits_limb_lemma",
"Lib.IntTypes.range_t",
"Lib.IntTypes.mod_mask",
"Lib.IntTypes.size",
"Lib.IntTypes.mod_mask_lemma",
"FStar.Math.Lemmas.pow2_lt_compat",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.op_Subtraction_Dot",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.IntTypes.uint",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Lib.bn_get_bits_limb"
] | [] | true | false | true | false | false | let bn_get_bits_lemma #t #nLen n ind l =
| let tmp = bn_get_bits_limb n ind in
let mask_l = (uint #t #SEC 1 <<. size l) -. uint #t 1 in
let tmp1 = tmp &. mask_l in
Math.Lemmas.pow2_lt_compat (bits t) l;
mod_mask_lemma tmp (size l);
assert (v (mod_mask #t #SEC (size l)) == v mask_l);
assert (v tmp1 == v tmp % pow2 l);
bn_get_bits_limb_lemma #t #nLen n ind;
assert (v tmp1 == bn_v n / pow2 ind % pow2 (bits t) % pow2 l);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v n / pow2 ind) l (bits t);
assert (v tmp1 == bn_v n / pow2 ind % pow2 l) | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.bn_get_top_index_eval_lemma | val bn_get_top_index_eval_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len -> ind:nat -> Lemma
(requires
ind < len /\ (ind > 0 ==> v b.[ind] <> 0) /\ (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0))
(ensures
bn_v b == bn_v (slice b 0 ind) + pow2 (bits t * ind) * v b.[ind]) | val bn_get_top_index_eval_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len -> ind:nat -> Lemma
(requires
ind < len /\ (ind > 0 ==> v b.[ind] <> 0) /\ (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0))
(ensures
bn_v b == bn_v (slice b 0 ind) + pow2 (bits t * ind) * v b.[ind]) | let bn_get_top_index_eval_lemma #t #len b ind =
let pbits = bits t in
assert (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0);
bn_eval_split_i b (ind + 1);
assert (bn_v b == bn_v (slice b 0 (ind + 1)) + pow2 (pbits * (ind + 1)) * bn_v (slice b (ind + 1) len));
eq_intro (slice b (ind + 1) len) (create (len - ind - 1) (uint #t 0));
bn_eval_zeroes #t (len - ind - 1) (len - ind - 1);
assert (bn_v b == bn_v (slice b 0 (ind + 1)));
bn_eval_split_i (slice b 0 (ind + 1)) ind;
assert (bn_v b == bn_v (slice b 0 ind) + pow2 (pbits * ind) * bn_v (slice b ind (ind + 1)));
bn_eval1 (slice b ind (ind + 1));
assert (bn_v b == bn_v (slice b 0 ind) + pow2 (pbits * ind) * v b.[ind]) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 74,
"end_line": 369,
"start_col": 0,
"start_line": 358
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2)
let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2)
val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t
let bn_get_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[i] j
val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j))
let bn_get_ith_bit_aux_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = b.[i] >>. size j in
calc (==) {
v b.[i] / pow2 j;
(==) { bn_eval_index b i }
(bn_v b / pow2 (pbits * i) % pow2 pbits) / pow2 j;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b / pow2 (pbits * i)) j pbits }
(bn_v b / pow2 (pbits * i) / pow2 j) % pow2 (pbits - j);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b) (pow2 (pbits * i)) (pow2 j) }
(bn_v b / (pow2 (pbits * i) * pow2 j)) % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_plus (pbits * i) j }
(bn_v b / pow2 (pbits * i + j)) % pow2 (pbits - j);
(==) { Math.Lemmas.euclidean_div_axiom ind pbits }
(bn_v b / pow2 ind) % pow2 (pbits - j);
};
assert (v res == (bn_v b / pow2 ind) % pow2 (pbits - j))
val bn_get_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} ->
Lemma (v (bn_get_ith_bit b i) == (bn_v b / pow2 i % 2))
let bn_get_ith_bit_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = limb_get_ith_bit b.[i] j in
limb_get_ith_bit_lemma b.[i] j;
calc (==) {
v b.[i] / pow2 j % 2;
(==) { bn_get_ith_bit_aux_lemma b ind }
(bn_v b / pow2 ind) % pow2 (pbits - j) % 2;
(==) { assert_norm (pow2 1 = 2);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 ind) 1 (pbits - j) }
(bn_v b / pow2 ind) % 2;
};
assert (v res == bn_v b / pow2 ind % 2)
val bn_set_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> lbignum t len
let bn_set_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
let inp = input.[i] <- input.[i] |. (uint #t 1 <<. size j) in
inp
val bn_set_ith_bit_lemma_aux: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a + b * pow2 c < pow2 (c + d) /\ a < pow2 c)
(ensures b < pow2 d)
let bn_set_ith_bit_lemma_aux a b c d =
Math.Lemmas.lemma_div_lt_nat (a + b * pow2 c) (c + d) c;
assert ((a + b * pow2 c) / pow2 c < pow2 d);
Math.Lemmas.lemma_div_plus a b (pow2 c);
assert (a / pow2 c + b < pow2 d);
Math.Lemmas.small_division_lemma_1 a (pow2 c)
val bn_lt_pow2_index_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} -> Lemma
(requires bn_v b < pow2 ind)
(ensures (let i = ind / bits t in v b.[i] < pow2 (ind % bits t) /\
bn_v b == bn_v (slice b 0 i) + pow2 (i * bits t) * v b.[i] /\
bn_v (slice b (i + 1) len) = 0))
let bn_lt_pow2_index_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
Math.Lemmas.euclidean_division_definition ind (pbits);
assert (bn_v b < pow2 (i * pbits + j));
Math.Lemmas.pow2_lt_compat (i * pbits + pbits) (i * pbits + j);
assert (bn_v b < pow2 (i * pbits + pbits));
bn_eval_split_i #t #len b (i + 1);
bn_eval_bound (slice b 0 (i + 1)) (i + 1);
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 (i + 1))) (bn_v (slice b (i + 1) len)) (pbits * (i + 1)) 0;
assert (bn_v b == bn_v (slice b 0 (i + 1)));
bn_eval_split_i #t #(i + 1) (slice b 0 (i + 1)) i;
bn_eval1 (slice b i (i + 1));
assert (bn_v b == bn_v (slice b 0 i) + pow2 (i * pbits) * v b.[i]);
bn_eval_bound #t #i (slice b 0 i) i;
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 i)) (v b.[i]) (i * pbits) j;
assert (v b.[i] < pow2 j)
val bn_set_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> Lemma
(requires bn_v b < pow2 i)
(ensures bn_v (bn_set_ith_bit b i) == bn_v b + pow2 i)
let bn_set_ith_bit_lemma #t #len input ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
bn_lt_pow2_index_lemma #t #len input ind;
assert (v input.[i] < pow2 j);
let b = uint #t 1 <<. size j in
let inp = input.[i] <- input.[i] |. b in
FStar.Math.Lemmas.pow2_lt_compat pbits j;
FStar.Math.Lemmas.modulo_lemma (pow2 j) (pow2 pbits);
assert (v b == pow2 j);
logor_disjoint (input.[i]) b j;
assert (v inp.[i] == v input.[i] + v b);
calc (==) {
bn_v inp;
(==) { bn_eval_split_i #t #len inp (i + 1);
bn_eval_extensionality_j (slice inp (i + 1) len) (slice input (i + 1) len) (len - i - 1) }
bn_v (slice inp 0 (i + 1));
(==) { bn_eval_split_i #t #(i + 1) (slice inp 0 (i + 1)) i }
bn_v (slice inp 0 i) + pow2 (i * pbits) * bn_v (slice inp i (i + 1));
(==) { bn_eval1 (slice inp i (i + 1)) }
bn_v (slice inp 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { bn_eval_extensionality_j input inp i }
bn_v (slice input 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { }
bn_v (slice input 0 i) + pow2 (i * pbits) * (v input.[i] + v b);
(==) { Math.Lemmas.distributivity_add_right (pow2 (i * pbits)) (v input.[i]) (v b) }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 (i * pbits) * v b;
(==) { Math.Lemmas.pow2_plus (i * pbits) j; Math.Lemmas.euclidean_division_definition ind pbits }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 ind;
(==) { }
bn_v input + pow2 ind;
}
///
/// % pow2 and / pow2
///
val bn_div_pow2: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i <= len} -> lbignum t (len - i)
let bn_div_pow2 #t #len b i =
slice b i len
val bn_div_pow2_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i < len} ->
Lemma (bn_v (bn_div_pow2 b i) == bn_v b / pow2 (bits t * i))
let bn_div_pow2_lemma #t #len c i =
let pbits = bits t in
calc (==) {
bn_v c / pow2 (pbits * i);
(==) { bn_eval_split_i c i }
(bn_v (slice c 0 i) + pow2 (pbits * i) * bn_v (slice c i len)) / pow2 (pbits * i);
(==) { Math.Lemmas.division_addition_lemma (bn_v (slice c 0 i)) (pow2 (pbits * i)) (bn_v (slice c i len)) }
bn_v (slice c 0 i) / pow2 (pbits * i) + bn_v (slice c i len);
(==) { bn_eval_bound (slice c 0 i) i; Math.Lemmas.small_division_lemma_1 (bn_v (slice c 0 i)) (pow2 (pbits * i)) }
bn_v (slice c i len);
};
assert (bn_v (slice c i len) == bn_v c / pow2 (pbits * i))
val bn_mod_pow2: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} -> lbignum t i
let bn_mod_pow2 #t #aLen a i = sub a 0 i
val bn_mod_pow2_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} ->
Lemma (bn_v (bn_mod_pow2 a i) == bn_v a % pow2 (bits t * i))
let bn_mod_pow2_lemma #t #aLen a i =
let pbits = bits t in
calc (==) {
bn_v a % pow2 (pbits * i);
(==) { bn_eval_split_i a i }
(bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v (slice a i aLen)) % pow2 (pbits * i);
(==) { Math.Lemmas.modulo_addition_lemma (bn_v (slice a 0 i)) (pow2 (pbits * i)) (bn_v (slice a i aLen)) }
(bn_v (slice a 0 i)) % pow2 (pbits * i);
(==) { bn_eval_bound (slice a 0 i) i; Math.Lemmas.small_mod (bn_v (slice a 0 i)) (pow2 (pbits * i)) }
bn_v (slice a 0 i);
}
///
/// Conditional swap
///
//the same as in curve25519
val lemma_cswap2_step:
#t:limb_t
-> bit:limb t{v bit <= 1}
-> p1:limb t
-> p2:limb t ->
Lemma
(let mask = uint #t 0 -. bit in
let dummy = mask &. (p1 ^. p2) in
let p1' = p1 ^. dummy in
let p2' = p2 ^. dummy in
if v bit = 1 then p1' == p2 /\ p2' == p1 else p1' == p1 /\ p2' == p2)
let lemma_cswap2_step #t bit p1 p2 =
let mask = uint #t 0 -. bit in
assert (v bit == 0 ==> v mask == 0);
assert (v bit == 1 ==> v mask == pow2 (bits t) - 1);
let dummy = mask &. (p1 ^. p2) in
logand_lemma mask (p1 ^. p2);
assert (v bit == 1 ==> v dummy == v (p1 ^. p2));
assert (v bit == 0 ==> v dummy == 0);
let p1' = p1 ^. dummy in
assert (v dummy == v (if v bit = 1 then (p1 ^. p2) else uint #t 0));
logxor_lemma p1 p2;
let p2' = p2 ^. dummy in
logxor_lemma p2 p1
val cswap2_f:
#t:limb_t
-> #len:size_nat
-> mask:limb t
-> i:nat{i < len}
-> tuple2 (lbignum t len) (lbignum t len) ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2_f #t #len mask i (p1, p2) =
let dummy = mask &. (p1.[i] ^. p2.[i]) in
let p1 = p1.[i] <- p1.[i] ^. dummy in
let p2 = p2.[i] <- p2.[i] ^. dummy in
(p1, p2)
val cswap2:
#t:limb_t
-> #len:size_nat
-> bit:limb t
-> b1:lbignum t len
-> b2:lbignum t len ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2 #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.repeati len (cswap2_f #t #len mask) (b1, b2)
val cswap2_lemma:
#t:limb_t
-> #len:size_nat
-> bit:limb t{v bit <= 1}
-> b1:lbignum t len
-> b2:lbignum t len ->
Lemma (let (p1, p2) = cswap2 bit b1 b2 in
(if v bit = 1 then p1 == b2 /\ p2 == b1 else p1 == b1 /\ p2 == b2))
let cswap2_lemma #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.eq_repeati0 len (cswap2_f #t #len mask) (b1, b2);
let (p1, p2) =
Loops.repeati_inductive #(tuple2 (lbignum t len) (lbignum t len)) len
(fun i (p1, p2) ->
(p1, p2) == Loops.repeati i (cswap2_f #t #len mask) (b1, b2) /\
(forall (k:nat{k < i}).
(if v bit = 1 then p1.[k] == b2.[k] /\ p2.[k] == b1.[k] else p1.[k] == b1.[k] /\ p2.[k] == b2.[k])) /\
(forall (k:nat{i <= k /\ k < len}). p1.[k] == b1.[k] /\ p2.[k] == b2.[k]))
(fun i (p1, p2) ->
Loops.unfold_repeati (i + 1) (cswap2_f #t #len mask) (b1, b2) i;
lemma_cswap2_step bit p1.[i] p2.[i];
cswap2_f #t #len mask i (p1, p2)) (b1, b2) in
assert (if v bit = 1 then (eq_intro p1 b2; p1 == b2) else (eq_intro p1 b1; p1 == b1));
assert (if v bit = 1 then (eq_intro p2 b1; p2 == b1) else (eq_intro p2 b2; p2 == b2));
//eq_intro p1 (if v bit = 1 then b2 else b1);
//eq_intro p2 (if v bit = 1 then b1 else b2);
()
let bn_get_top_index_t (len:size_nat) (i:nat{i <= len}) = x:nat{x < len}
val bn_get_top_index_f:
#t:limb_t
-> #len:size_nat
-> b:lbignum t len
-> i:nat{i < len}
-> priv:bn_get_top_index_t len i ->
bn_get_top_index_t len (i + 1)
let bn_get_top_index_f #t #len b i priv =
let mask = eq_mask b.[i] (zeros t SEC) in
if v mask = 0 then i else priv
val bn_get_top_index: #t:limb_t -> #len:size_pos -> b:lbignum t len -> res:size_nat{res < len}
let bn_get_top_index #t #len b =
Loops.repeat_gen len (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0
val bn_get_top_index_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (let ind = bn_get_top_index #t #len b in
ind < len /\ (ind > 0 ==> v b.[ind] <> 0) /\ (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0))
let bn_get_top_index_lemma #t #len b =
Loops.eq_repeat_gen0 len (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0;
let res =
Loops.repeati_inductive #size_nat len
(fun i priv ->
priv == Loops.repeat_gen i (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0 /\
priv < len /\ (priv > 0 ==> v b.[priv] <> 0) /\ (forall (k:nat{priv < k /\ k < i}). v b.[k] = 0))
(fun i priv ->
Loops.unfold_repeat_gen (i + 1) (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0 i;
let mask = eq_mask b.[i] (zeros t SEC) in
eq_mask_lemma b.[i] (zeros t SEC);
assert (if v mask = 0 then v b.[i] <> 0 else v b.[i] = 0);
let res = if v mask = 0 then i else priv in
res) 0 in
()
val bn_get_top_index_eval_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len -> ind:nat -> Lemma
(requires
ind < len /\ (ind > 0 ==> v b.[ind] <> 0) /\ (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0))
(ensures
bn_v b == bn_v (slice b 0 ind) + pow2 (bits t * ind) * v b.[ind]) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b: Hacl.Spec.Bignum.Definitions.lbignum t len -> ind: Prims.nat
-> FStar.Pervasives.Lemma
(requires
ind < len /\ (ind > 0 ==> Lib.IntTypes.v b.[ ind ] <> 0) /\
(forall (k: Prims.nat{ind < k /\ k < len}). Lib.IntTypes.v b.[ k ] = 0))
(ensures
Hacl.Spec.Bignum.Definitions.bn_v b ==
Hacl.Spec.Bignum.Definitions.bn_v (Lib.Sequence.slice b 0 ind) +
Prims.pow2 (Lib.IntTypes.bits t * ind) * Lib.IntTypes.v b.[ ind ]) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.nat",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.op_Addition",
"Prims.op_Subtraction",
"Lib.Sequence.slice",
"Hacl.Spec.Bignum.Definitions.limb",
"FStar.Mul.op_Star",
"Prims.pow2",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Lib.Sequence.op_String_Access",
"Prims.unit",
"Hacl.Spec.Bignum.Definitions.bn_eval1",
"Hacl.Spec.Bignum.Definitions.bn_eval_split_i",
"Hacl.Spec.Bignum.Definitions.bn_eval_zeroes",
"Lib.Sequence.eq_intro",
"Lib.Sequence.create",
"Lib.IntTypes.uint",
"Prims.l_Forall",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Equality",
"Lib.IntTypes.bits"
] | [] | false | false | true | false | false | let bn_get_top_index_eval_lemma #t #len b ind =
| let pbits = bits t in
assert (forall (k: nat{ind < k /\ k < len}). v b.[ k ] = 0);
bn_eval_split_i b (ind + 1);
assert (bn_v b ==
bn_v (slice b 0 (ind + 1)) + pow2 (pbits * (ind + 1)) * bn_v (slice b (ind + 1) len));
eq_intro (slice b (ind + 1) len) (create (len - ind - 1) (uint #t 0));
bn_eval_zeroes #t (len - ind - 1) (len - ind - 1);
assert (bn_v b == bn_v (slice b 0 (ind + 1)));
bn_eval_split_i (slice b 0 (ind + 1)) ind;
assert (bn_v b == bn_v (slice b 0 ind) + pow2 (pbits * ind) * bn_v (slice b ind (ind + 1)));
bn_eval1 (slice b ind (ind + 1));
assert (bn_v b == bn_v (slice b 0 ind) + pow2 (pbits * ind) * v b.[ ind ]) | false |
Hacl.Impl.K256.Qinv.fst | Hacl.Impl.K256.Qinv.qinv6 | val qinv6 (tmp x8 x_11 x_1001 x_1011 x_1101: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h x8 /\ live h x_11 /\
live h x_1001 /\ live h x_1011 /\ live h x_1101 /\
disjoint tmp x8 /\ disjoint tmp x_11 /\ disjoint tmp x_1001 /\
disjoint tmp x_1011 /\ disjoint tmp x_1101 /\
qe_lt_q h tmp /\ qe_lt_q h x8 /\ qe_lt_q h x_11 /\
qe_lt_q h x_1001 /\ qe_lt_q h x_1011 /\ qe_lt_q h x_1101)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r16_r23 (qas_nat h0 tmp)
(qas_nat h0 x8) (qas_nat h0 x_11) (qas_nat h0 x_1001) (qas_nat h0 x_1011) (qas_nat h0 x_1101) /\
qe_lt_q h1 tmp) | val qinv6 (tmp x8 x_11 x_1001 x_1011 x_1101: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h x8 /\ live h x_11 /\
live h x_1001 /\ live h x_1011 /\ live h x_1101 /\
disjoint tmp x8 /\ disjoint tmp x_11 /\ disjoint tmp x_1001 /\
disjoint tmp x_1011 /\ disjoint tmp x_1101 /\
qe_lt_q h tmp /\ qe_lt_q h x8 /\ qe_lt_q h x_11 /\
qe_lt_q h x_1001 /\ qe_lt_q h x_1011 /\ qe_lt_q h x_1101)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r16_r23 (qas_nat h0 tmp)
(qas_nat h0 x8) (qas_nat h0 x_11) (qas_nat h0 x_1001) (qas_nat h0 x_1011) (qas_nat h0 x_1101) /\
qe_lt_q h1 tmp) | let qinv6 tmp x8 x_11 x_1001 x_1011 x_1101 =
let h0 = ST.get () in
qsquare_times_in_place tmp 9ul;
qmul tmp tmp x8; //tmp = r16
let h1 = ST.get () in
assert (qas_nat h1 tmp == S.qmul (SI.qsquare_times (qas_nat h0 tmp) 9) (qas_nat h0 x8));
qsquare_times_in_place tmp 5ul;
qmul tmp tmp x_1001; //tmp = r17
let h2 = ST.get () in
assert (qas_nat h2 tmp == S.qmul (SI.qsquare_times (qas_nat h1 tmp) 5) (qas_nat h0 x_1001));
qsquare_times_in_place tmp 6ul;
qmul tmp tmp x_1011; //tmp = r18
let h3 = ST.get () in
assert (qas_nat h3 tmp == S.qmul (SI.qsquare_times (qas_nat h2 tmp) 6) (qas_nat h0 x_1011));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_1101; //tmp = r19
let h4 = ST.get () in
assert (qas_nat h4 tmp == S.qmul (SI.qsquare_times (qas_nat h3 tmp) 4) (qas_nat h0 x_1101));
qsquare_times_in_place tmp 5ul;
qmul tmp tmp x_11; //tmp = r20
let h5 = ST.get () in
assert (qas_nat h5 tmp == S.qmul (SI.qsquare_times (qas_nat h4 tmp) 5) (qas_nat h0 x_11));
qsquare_times_in_place tmp 6ul;
qmul tmp tmp x_1101; //tmp = r21
let h6 = ST.get () in
assert (qas_nat h6 tmp == S.qmul (SI.qsquare_times (qas_nat h5 tmp) 6) (qas_nat h0 x_1101));
qsquare_times_in_place tmp 10ul;
qmul tmp tmp x_1101; //tmp = r22
let h7 = ST.get () in
assert (qas_nat h7 tmp == S.qmul (SI.qsquare_times (qas_nat h6 tmp) 10) (qas_nat h0 x_1101));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_1001; //tmp = r23
let h8 = ST.get () in
assert (qas_nat h8 tmp == S.qmul (SI.qsquare_times (qas_nat h7 tmp) 4) (qas_nat h0 x_1001)) | {
"file_name": "code/k256/Hacl.Impl.K256.Qinv.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 93,
"end_line": 389,
"start_col": 0,
"start_line": 349
} | module Hacl.Impl.K256.Qinv
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.K256.Scalar
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Spec.K256
module SI = Hacl.Spec.K256.Qinv
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module SD = Hacl.Spec.Bignum.Definitions
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
unfold
let linv_ctx (a:LSeq.lseq uint64 0) : Type0 = True
unfold
let linv (a:LSeq.lseq uint64 4) : Type0 =
SD.bn_v #U64 #4 a < S.q
unfold
let refl (a:LSeq.lseq uint64 4{linv a}) : GTot S.qelem =
SD.bn_v #U64 #4 a
inline_for_extraction noextract
let mk_to_k256_scalar_comm_monoid : BE.to_comm_monoid U64 4ul 0ul = {
BE.a_spec = S.qelem;
BE.comm_monoid = SI.nat_mod_comm_monoid;
BE.linv_ctx = linv_ctx;
BE.linv = linv;
BE.refl = refl;
}
inline_for_extraction noextract
val one_mod : BE.lone_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let one_mod ctx one = make_u64_4 one (u64 1, u64 0, u64 0, u64 0)
inline_for_extraction noextract
val mul_mod : BE.lmul_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let mul_mod ctx x y xy = qmul xy x y
inline_for_extraction noextract
val sqr_mod : BE.lsqr_st U64 4ul 0ul mk_to_k256_scalar_comm_monoid
let sqr_mod ctx x xx = qsqr xx x
inline_for_extraction noextract
let mk_k256_scalar_concrete_ops : BE.concrete_ops U64 4ul 0ul = {
BE.to = mk_to_k256_scalar_comm_monoid;
BE.lone = one_mod;
BE.lmul = mul_mod;
BE.lsqr = sqr_mod;
}
val qsquare_times_in_place (out:qelem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ qe_lt_q h out)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\ qe_lt_q h1 out /\
qas_nat h1 out == SI.qsquare_times (qas_nat h0 out) (v b))
[@CInline]
let qsquare_times_in_place out b =
let h0 = ST.get () in
SE.exp_pow2_lemma SI.mk_nat_mod_concrete_ops (qas_nat h0 out) (v b);
BE.lexp_pow2_in_place 4ul 0ul mk_k256_scalar_concrete_ops (null uint64) out b
val qsquare_times (out a:qelem) (b:size_t) : Stack unit
(requires fun h ->
live h out /\ live h a /\ disjoint out a /\
qe_lt_q h a)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\ qe_lt_q h1 a /\
qas_nat h1 out == SI.qsquare_times (qas_nat h0 a) (v b))
[@CInline]
let qsquare_times out a b =
let h0 = ST.get () in
SE.exp_pow2_lemma SI.mk_nat_mod_concrete_ops (qas_nat h0 a) (v b);
BE.lexp_pow2 4ul 0ul mk_k256_scalar_concrete_ops (null uint64) a b out
inline_for_extraction noextract
val qinv1 (f x_10 x_11 x_101 x_111 x_1001 x_1011 x_1101:qelem) : Stack unit
(requires fun h ->
live h f /\ live h x_10 /\ live h x_11 /\ live h x_101 /\
live h x_111 /\ live h x_1001 /\ live h x_1011 /\ live h x_1101 /\
disjoint f x_10 /\ disjoint f x_11 /\ disjoint f x_101 /\
disjoint f x_111 /\ disjoint f x_1001 /\ disjoint f x_1011 /\
disjoint f x_1101 /\ disjoint x_10 x_11 /\ disjoint x_10 x_101 /\
disjoint x_10 x_111 /\ disjoint x_10 x_1001 /\ disjoint x_10 x_1011 /\
disjoint x_10 x_1101 /\ disjoint x_11 x_101 /\ disjoint x_11 x_111 /\
disjoint x_11 x_1001 /\ disjoint x_11 x_1011 /\ disjoint x_11 x_1101 /\
disjoint x_101 x_111 /\ disjoint x_101 x_1001 /\ disjoint x_101 x_1011 /\
disjoint x_101 x_1101 /\ disjoint x_111 x_1001 /\ disjoint x_111 x_1011 /\
disjoint x_111 x_1101 /\ disjoint x_1001 x_1011 /\ disjoint x_1001 x_1101 /\
disjoint x_1011 x_1101 /\ qe_lt_q h f)
(ensures fun h0 _ h1 ->
modifies (loc x_10 |+| loc x_11 |+| loc x_101 |+|
loc x_111 |+| loc x_1001 |+| loc x_1011 |+| loc x_1101) h0 h1 /\
(let _x_10 = SI.qsquare_times (qas_nat h0 f) 1 in
let _x_11 = S.qmul _x_10 (qas_nat h0 f) in
let _x_101 = S.qmul _x_10 _x_11 in
let _x_111 = S.qmul _x_10 _x_101 in
let _x_1001 = S.qmul _x_10 _x_111 in
let _x_1011 = S.qmul _x_10 _x_1001 in
let _x_1101 = S.qmul _x_10 _x_1011 in
qas_nat h1 x_10 == _x_10 /\ qe_lt_q h1 x_10 /\
qas_nat h1 x_11 == _x_11 /\ qe_lt_q h1 x_11 /\
qas_nat h1 x_101 == _x_101 /\ qe_lt_q h1 x_101 /\
qas_nat h1 x_111 == _x_111 /\ qe_lt_q h1 x_111 /\
qas_nat h1 x_1001 == _x_1001 /\ qe_lt_q h1 x_1001 /\
qas_nat h1 x_1011 == _x_1011 /\ qe_lt_q h1 x_1011 /\
qas_nat h1 x_1101 == _x_1101 /\ qe_lt_q h1 x_1101))
let qinv1 f x_10 x_11 x_101 x_111 x_1001 x_1011 x_1101 =
let h0 = ST.get () in
qsquare_times x_10 f 1ul;
let h1 = ST.get () in
assert (qas_nat h1 x_10 == SI.qsquare_times (qas_nat h0 f) 1);
qmul x_11 x_10 f;
let h2 = ST.get () in
assert (qas_nat h2 x_11 == S.qmul (qas_nat h1 x_10) (qas_nat h0 f));
qmul x_101 x_10 x_11;
let h3 = ST.get () in
assert (qas_nat h3 x_101 == S.qmul (qas_nat h1 x_10) (qas_nat h2 x_11));
qmul x_111 x_10 x_101;
let h4 = ST.get () in
assert (qas_nat h4 x_111 == S.qmul (qas_nat h1 x_10) (qas_nat h3 x_101));
qmul x_1001 x_10 x_111;
let h5 = ST.get () in
assert (qas_nat h5 x_1001 == S.qmul (qas_nat h1 x_10) (qas_nat h4 x_111));
qmul x_1011 x_10 x_1001;
let h6 = ST.get () in
assert (qas_nat h6 x_1011 == S.qmul (qas_nat h1 x_10) (qas_nat h5 x_1001));
qmul x_1101 x_10 x_1011;
let h7 = ST.get () in
assert (qas_nat h7 x_1101 == S.qmul (qas_nat h1 x_10) (qas_nat h6 x_1011))
inline_for_extraction noextract
val qinv2 (x_11 x_1011 x_1101 x6 x8 x14: qelem) : Stack unit
(requires fun h ->
live h x_11 /\ live h x_1011 /\ live h x_1101 /\
live h x6 /\ live h x8 /\ live h x14 /\
disjoint x_11 x6 /\ disjoint x_11 x8 /\ disjoint x_11 x14 /\
disjoint x_1011 x6 /\ disjoint x_1011 x8 /\ disjoint x_1011 x14 /\
disjoint x_1101 x6 /\ disjoint x_1101 x8 /\ disjoint x_1101 x14 /\
disjoint x6 x8 /\ disjoint x6 x14 /\ disjoint x8 x14 /\
qe_lt_q h x_11 /\ qe_lt_q h x_1011 /\ qe_lt_q h x_1101)
(ensures fun h0 _ h1 -> modifies (loc x6 |+| loc x8 |+| loc x14) h0 h1 /\
(let _x6 = S.qmul (SI.qsquare_times (qas_nat h0 x_1101) 2) (qas_nat h0 x_1011) in
let _x8 = S.qmul (SI.qsquare_times _x6 2) (qas_nat h0 x_11) in
let _x14 = S.qmul (SI.qsquare_times _x8 6) _x6 in
qas_nat h1 x6 == _x6 /\ qe_lt_q h1 x6 /\
qas_nat h1 x8 == _x8 /\ qe_lt_q h1 x8 /\
qas_nat h1 x14 == _x14 /\ qe_lt_q h1 x14))
let qinv2 x_11 x_1011 x_1101 x6 x8 x14 =
let h0 = ST.get () in
qsquare_times x6 x_1101 2ul;
qmul x6 x6 x_1011;
let h1 = ST.get () in
assert (qas_nat h1 x6 == S.qmul (SI.qsquare_times (qas_nat h0 x_1101) 2) (qas_nat h0 x_1011));
qsquare_times x8 x6 2ul;
qmul x8 x8 x_11;
let h2 = ST.get () in
assert (qas_nat h2 x8 == S.qmul (SI.qsquare_times (qas_nat h1 x6) 2) (qas_nat h0 x_11));
qsquare_times x14 x8 6ul;
qmul x14 x14 x6;
let h3 = ST.get () in
assert (qas_nat h3 x14 == S.qmul (SI.qsquare_times (qas_nat h2 x8) 6) (qas_nat h1 x6))
inline_for_extraction noextract
val qinv3 (tmp x14: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h x14 /\ disjoint tmp x14 /\
qe_lt_q h x14)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r0_r1 (qas_nat h0 x14) /\
qe_lt_q h1 tmp)
let qinv3 tmp x14 =
push_frame ();
let x56 = create_qelem () in
let h0 = ST.get () in
qsquare_times tmp x14 14ul;
qmul tmp tmp x14; //tmp = x28
let h1 = ST.get () in
assert (qas_nat h1 tmp == S.qmul (SI.qsquare_times (qas_nat h0 x14) 14) (qas_nat h0 x14));
qsquare_times x56 tmp 28ul;
qmul x56 x56 tmp;
let h2 = ST.get () in
assert (qas_nat h2 x56 == S.qmul (SI.qsquare_times (qas_nat h1 tmp) 28) (qas_nat h1 tmp));
qsquare_times tmp x56 56ul; //tmp = r0
qmul tmp tmp x56;
let h3 = ST.get () in
assert (qas_nat h3 tmp == S.qmul (SI.qsquare_times (qas_nat h2 x56) 56) (qas_nat h2 x56));
qsquare_times_in_place tmp 14ul; //tmp = r1
qmul tmp tmp x14;
let h4 = ST.get () in
assert (qas_nat h4 tmp == S.qmul (SI.qsquare_times (qas_nat h3 tmp) 14) (qas_nat h0 x14));
pop_frame ()
//r2; .. ;r8
inline_for_extraction noextract
val qinv4 (tmp x_101 x_111 x_1011: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h x_101 /\ live h x_111 /\ live h x_1011 /\
disjoint tmp x_101 /\ disjoint tmp x_111 /\ disjoint tmp x_1011 /\
qe_lt_q h tmp /\ qe_lt_q h x_101 /\ qe_lt_q h x_111 /\ qe_lt_q h x_1011)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r2_r8 (qas_nat h0 tmp)
(qas_nat h0 x_101) (qas_nat h0 x_111) (qas_nat h0 x_1011) /\
qe_lt_q h1 tmp)
let qinv4 tmp x_101 x_111 x_1011 =
let h0 = ST.get () in
qsquare_times_in_place tmp 3ul;
qmul tmp tmp x_101; //tmp = r2
let h1 = ST.get () in
assert (qas_nat h1 tmp == S.qmul (SI.qsquare_times (qas_nat h0 tmp) 3) (qas_nat h0 x_101));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_111; //tmp = r3
let h2 = ST.get () in
assert (qas_nat h2 tmp == S.qmul (SI.qsquare_times (qas_nat h1 tmp) 4) (qas_nat h0 x_111));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_101; //tmp = r4
let h3 = ST.get () in
assert (qas_nat h3 tmp == S.qmul (SI.qsquare_times (qas_nat h2 tmp) 4) (qas_nat h0 x_101));
qsquare_times_in_place tmp 5ul;
qmul tmp tmp x_1011; //tmp = r5
let h4 = ST.get () in
assert (qas_nat h4 tmp == S.qmul (SI.qsquare_times (qas_nat h3 tmp) 5) (qas_nat h0 x_1011));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_1011; //tmp = r6
let h5 = ST.get () in
assert (qas_nat h5 tmp == S.qmul (SI.qsquare_times (qas_nat h4 tmp) 4) (qas_nat h0 x_1011));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_111; //tmp = r7
let h6 = ST.get () in
assert (qas_nat h6 tmp == S.qmul (SI.qsquare_times (qas_nat h5 tmp) 4) (qas_nat h0 x_111));
qsquare_times_in_place tmp 5ul;
qmul tmp tmp x_111; //tmp = r8
let h7 = ST.get () in
assert (qas_nat h7 tmp == S.qmul (SI.qsquare_times (qas_nat h6 tmp) 5) (qas_nat h0 x_111))
// r9; ..; r15
inline_for_extraction noextract
val qinv5 (tmp x_101 x_111 x_1001 x_1101: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h x_101 /\ live h x_111 /\
live h x_1001 /\ live h x_1101 /\ disjoint tmp x_101 /\
disjoint tmp x_111 /\ disjoint tmp x_1001 /\ disjoint tmp x_1101 /\
qe_lt_q h tmp /\ qe_lt_q h x_101 /\ qe_lt_q h x_111 /\
qe_lt_q h x_1001 /\ qe_lt_q h x_1101)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r9_r15 (qas_nat h0 tmp)
(qas_nat h0 x_101) (qas_nat h0 x_111) (qas_nat h0 x_1001) (qas_nat h0 x_1101) /\
qe_lt_q h1 tmp)
let qinv5 tmp x_101 x_111 x_1001 x_1101 =
let h0 = ST.get () in
qsquare_times_in_place tmp 6ul;
qmul tmp tmp x_1101; //tmp = r9
let h1 = ST.get () in
assert (qas_nat h1 tmp == S.qmul (SI.qsquare_times (qas_nat h0 tmp) 6) (qas_nat h0 x_1101));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_101; //tmp = r10
let h2 = ST.get () in
assert (qas_nat h2 tmp == S.qmul (SI.qsquare_times (qas_nat h1 tmp) 4) (qas_nat h0 x_101));
qsquare_times_in_place tmp 3ul;
qmul tmp tmp x_111; //tmp = r11
let h3 = ST.get () in
assert (qas_nat h3 tmp == S.qmul (SI.qsquare_times (qas_nat h2 tmp) 3) (qas_nat h0 x_111));
qsquare_times_in_place tmp 5ul;
qmul tmp tmp x_1001; //tmp = r12
let h4 = ST.get () in
assert (qas_nat h4 tmp == S.qmul (SI.qsquare_times (qas_nat h3 tmp) 5) (qas_nat h0 x_1001));
qsquare_times_in_place tmp 6ul;
qmul tmp tmp x_101; //tmp = r13
let h5 = ST.get () in
assert (qas_nat h5 tmp == S.qmul (SI.qsquare_times (qas_nat h4 tmp) 6) (qas_nat h0 x_101));
qsquare_times_in_place tmp 10ul;
qmul tmp tmp x_111; //tmp = r14
let h6 = ST.get () in
assert (qas_nat h6 tmp == S.qmul (SI.qsquare_times (qas_nat h5 tmp) 10) (qas_nat h0 x_111));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_111; //tmp = r15
let h7 = ST.get () in
assert (qas_nat h7 tmp == S.qmul (SI.qsquare_times (qas_nat h6 tmp) 4) (qas_nat h0 x_111))
// r16; ..;r23
inline_for_extraction noextract
val qinv6 (tmp x8 x_11 x_1001 x_1011 x_1101: qelem) : Stack unit
(requires fun h ->
live h tmp /\ live h x8 /\ live h x_11 /\
live h x_1001 /\ live h x_1011 /\ live h x_1101 /\
disjoint tmp x8 /\ disjoint tmp x_11 /\ disjoint tmp x_1001 /\
disjoint tmp x_1011 /\ disjoint tmp x_1101 /\
qe_lt_q h tmp /\ qe_lt_q h x8 /\ qe_lt_q h x_11 /\
qe_lt_q h x_1001 /\ qe_lt_q h x_1011 /\ qe_lt_q h x_1101)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
qas_nat h1 tmp == SI.qinv_r16_r23 (qas_nat h0 tmp)
(qas_nat h0 x8) (qas_nat h0 x_11) (qas_nat h0 x_1001) (qas_nat h0 x_1011) (qas_nat h0 x_1101) /\
qe_lt_q h1 tmp) | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.K256.Qinv.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.K256.Scalar.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.K256.Qinv.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "SD"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Qinv",
"short_module": "SI"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.K256.Scalar",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
tmp: Hacl.K256.Scalar.qelem ->
x8: Hacl.K256.Scalar.qelem ->
x_11: Hacl.K256.Scalar.qelem ->
x_1001: Hacl.K256.Scalar.qelem ->
x_1011: Hacl.K256.Scalar.qelem ->
x_1101: Hacl.K256.Scalar.qelem
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.K256.Scalar.qelem",
"Prims._assert",
"Prims.eq2",
"Prims.nat",
"Hacl.K256.Scalar.qas_nat",
"Spec.K256.PointOps.qmul",
"Hacl.Spec.K256.Qinv.qsquare_times",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Hacl.K256.Scalar.qmul",
"Hacl.Impl.K256.Qinv.qsquare_times_in_place",
"FStar.UInt32.__uint_to_t"
] | [] | false | true | false | false | false | let qinv6 tmp x8 x_11 x_1001 x_1011 x_1101 =
| let h0 = ST.get () in
qsquare_times_in_place tmp 9ul;
qmul tmp tmp x8;
let h1 = ST.get () in
assert (qas_nat h1 tmp == S.qmul (SI.qsquare_times (qas_nat h0 tmp) 9) (qas_nat h0 x8));
qsquare_times_in_place tmp 5ul;
qmul tmp tmp x_1001;
let h2 = ST.get () in
assert (qas_nat h2 tmp == S.qmul (SI.qsquare_times (qas_nat h1 tmp) 5) (qas_nat h0 x_1001));
qsquare_times_in_place tmp 6ul;
qmul tmp tmp x_1011;
let h3 = ST.get () in
assert (qas_nat h3 tmp == S.qmul (SI.qsquare_times (qas_nat h2 tmp) 6) (qas_nat h0 x_1011));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_1101;
let h4 = ST.get () in
assert (qas_nat h4 tmp == S.qmul (SI.qsquare_times (qas_nat h3 tmp) 4) (qas_nat h0 x_1101));
qsquare_times_in_place tmp 5ul;
qmul tmp tmp x_11;
let h5 = ST.get () in
assert (qas_nat h5 tmp == S.qmul (SI.qsquare_times (qas_nat h4 tmp) 5) (qas_nat h0 x_11));
qsquare_times_in_place tmp 6ul;
qmul tmp tmp x_1101;
let h6 = ST.get () in
assert (qas_nat h6 tmp == S.qmul (SI.qsquare_times (qas_nat h5 tmp) 6) (qas_nat h0 x_1101));
qsquare_times_in_place tmp 10ul;
qmul tmp tmp x_1101;
let h7 = ST.get () in
assert (qas_nat h7 tmp == S.qmul (SI.qsquare_times (qas_nat h6 tmp) 10) (qas_nat h0 x_1101));
qsquare_times_in_place tmp 4ul;
qmul tmp tmp x_1001;
let h8 = ST.get () in
assert (qas_nat h8 tmp == S.qmul (SI.qsquare_times (qas_nat h7 tmp) 4) (qas_nat h0 x_1001)) | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.bn_get_bits_limb_lemma | val bn_get_bits_limb_lemma:
#t:limb_t
-> #nLen:size_nat
-> n:lbignum t nLen
-> ind:size_nat{ind / bits t < nLen} ->
Lemma (v (bn_get_bits_limb n ind) == bn_v n / pow2 ind % pow2 (bits t)) | val bn_get_bits_limb_lemma:
#t:limb_t
-> #nLen:size_nat
-> n:lbignum t nLen
-> ind:size_nat{ind / bits t < nLen} ->
Lemma (v (bn_get_bits_limb n ind) == bn_v n / pow2 ind % pow2 (bits t)) | let bn_get_bits_limb_lemma #t #nLen n ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
assert (i == ind / bits t);
assert (i < nLen);
let p1 = n.[i] >>. size j in
let res = bn_v n / pow2 ind % pow2 pbits in
bn_get_ith_bit_aux_lemma n ind;
assert (v p1 == bn_v n / pow2 ind % pow2 (pbits - j));
if j = 0 then () else begin
bn_get_bits_limb_aux_lemma n ind;
if i + 1 < nLen then begin
let p2 = n.[i + 1] <<. (size (pbits - j)) in
calc (==) {
v p2 % pow2 (pbits - j);
(==) { }
v n.[i + 1] * pow2 (pbits - j) % pow2 pbits % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (v n.[i + 1] * pow2 (pbits - j)) (pbits - j) pbits }
v n.[i + 1] * pow2 (pbits - j) % pow2 (pbits - j);
(==) { Math.Lemmas.multiple_modulo_lemma (v n.[i + 1]) (pow2 (pbits - j)) }
0;
};
let p3 = p1 |. p2 in
logor_disjoint p1 p2 (pbits - j);
assert (v p3 == v p1 + v p2);
bn_eval_index n (i + 1);
assert (res == v p1 + v p2);
assert (ind / bits t + 1 < nLen && 0 < ind % bits t) end
else begin
bn_eval_bound n nLen;
assert (bn_v n < pow2 (nLen * pbits));
Math.Lemmas.lemma_div_lt_nat (bn_v n) (nLen * pbits) ((i + 1) * pbits);
Math.Lemmas.pow2_minus (nLen * pbits) ((i + 1) * pbits);
assert (bn_v n / pow2 ((i + 1) * pbits) < pow2 0);
assert_norm (pow2 0 = 1);
assert (res == v p1)
end
end | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 503,
"start_col": 0,
"start_line": 464
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2)
let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2)
val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t
let bn_get_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[i] j
val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j))
let bn_get_ith_bit_aux_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = b.[i] >>. size j in
calc (==) {
v b.[i] / pow2 j;
(==) { bn_eval_index b i }
(bn_v b / pow2 (pbits * i) % pow2 pbits) / pow2 j;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b / pow2 (pbits * i)) j pbits }
(bn_v b / pow2 (pbits * i) / pow2 j) % pow2 (pbits - j);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b) (pow2 (pbits * i)) (pow2 j) }
(bn_v b / (pow2 (pbits * i) * pow2 j)) % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_plus (pbits * i) j }
(bn_v b / pow2 (pbits * i + j)) % pow2 (pbits - j);
(==) { Math.Lemmas.euclidean_div_axiom ind pbits }
(bn_v b / pow2 ind) % pow2 (pbits - j);
};
assert (v res == (bn_v b / pow2 ind) % pow2 (pbits - j))
val bn_get_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} ->
Lemma (v (bn_get_ith_bit b i) == (bn_v b / pow2 i % 2))
let bn_get_ith_bit_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = limb_get_ith_bit b.[i] j in
limb_get_ith_bit_lemma b.[i] j;
calc (==) {
v b.[i] / pow2 j % 2;
(==) { bn_get_ith_bit_aux_lemma b ind }
(bn_v b / pow2 ind) % pow2 (pbits - j) % 2;
(==) { assert_norm (pow2 1 = 2);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 ind) 1 (pbits - j) }
(bn_v b / pow2 ind) % 2;
};
assert (v res == bn_v b / pow2 ind % 2)
val bn_set_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> lbignum t len
let bn_set_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
let inp = input.[i] <- input.[i] |. (uint #t 1 <<. size j) in
inp
val bn_set_ith_bit_lemma_aux: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a + b * pow2 c < pow2 (c + d) /\ a < pow2 c)
(ensures b < pow2 d)
let bn_set_ith_bit_lemma_aux a b c d =
Math.Lemmas.lemma_div_lt_nat (a + b * pow2 c) (c + d) c;
assert ((a + b * pow2 c) / pow2 c < pow2 d);
Math.Lemmas.lemma_div_plus a b (pow2 c);
assert (a / pow2 c + b < pow2 d);
Math.Lemmas.small_division_lemma_1 a (pow2 c)
val bn_lt_pow2_index_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} -> Lemma
(requires bn_v b < pow2 ind)
(ensures (let i = ind / bits t in v b.[i] < pow2 (ind % bits t) /\
bn_v b == bn_v (slice b 0 i) + pow2 (i * bits t) * v b.[i] /\
bn_v (slice b (i + 1) len) = 0))
let bn_lt_pow2_index_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
Math.Lemmas.euclidean_division_definition ind (pbits);
assert (bn_v b < pow2 (i * pbits + j));
Math.Lemmas.pow2_lt_compat (i * pbits + pbits) (i * pbits + j);
assert (bn_v b < pow2 (i * pbits + pbits));
bn_eval_split_i #t #len b (i + 1);
bn_eval_bound (slice b 0 (i + 1)) (i + 1);
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 (i + 1))) (bn_v (slice b (i + 1) len)) (pbits * (i + 1)) 0;
assert (bn_v b == bn_v (slice b 0 (i + 1)));
bn_eval_split_i #t #(i + 1) (slice b 0 (i + 1)) i;
bn_eval1 (slice b i (i + 1));
assert (bn_v b == bn_v (slice b 0 i) + pow2 (i * pbits) * v b.[i]);
bn_eval_bound #t #i (slice b 0 i) i;
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 i)) (v b.[i]) (i * pbits) j;
assert (v b.[i] < pow2 j)
val bn_set_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> Lemma
(requires bn_v b < pow2 i)
(ensures bn_v (bn_set_ith_bit b i) == bn_v b + pow2 i)
let bn_set_ith_bit_lemma #t #len input ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
bn_lt_pow2_index_lemma #t #len input ind;
assert (v input.[i] < pow2 j);
let b = uint #t 1 <<. size j in
let inp = input.[i] <- input.[i] |. b in
FStar.Math.Lemmas.pow2_lt_compat pbits j;
FStar.Math.Lemmas.modulo_lemma (pow2 j) (pow2 pbits);
assert (v b == pow2 j);
logor_disjoint (input.[i]) b j;
assert (v inp.[i] == v input.[i] + v b);
calc (==) {
bn_v inp;
(==) { bn_eval_split_i #t #len inp (i + 1);
bn_eval_extensionality_j (slice inp (i + 1) len) (slice input (i + 1) len) (len - i - 1) }
bn_v (slice inp 0 (i + 1));
(==) { bn_eval_split_i #t #(i + 1) (slice inp 0 (i + 1)) i }
bn_v (slice inp 0 i) + pow2 (i * pbits) * bn_v (slice inp i (i + 1));
(==) { bn_eval1 (slice inp i (i + 1)) }
bn_v (slice inp 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { bn_eval_extensionality_j input inp i }
bn_v (slice input 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { }
bn_v (slice input 0 i) + pow2 (i * pbits) * (v input.[i] + v b);
(==) { Math.Lemmas.distributivity_add_right (pow2 (i * pbits)) (v input.[i]) (v b) }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 (i * pbits) * v b;
(==) { Math.Lemmas.pow2_plus (i * pbits) j; Math.Lemmas.euclidean_division_definition ind pbits }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 ind;
(==) { }
bn_v input + pow2 ind;
}
///
/// % pow2 and / pow2
///
val bn_div_pow2: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i <= len} -> lbignum t (len - i)
let bn_div_pow2 #t #len b i =
slice b i len
val bn_div_pow2_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i < len} ->
Lemma (bn_v (bn_div_pow2 b i) == bn_v b / pow2 (bits t * i))
let bn_div_pow2_lemma #t #len c i =
let pbits = bits t in
calc (==) {
bn_v c / pow2 (pbits * i);
(==) { bn_eval_split_i c i }
(bn_v (slice c 0 i) + pow2 (pbits * i) * bn_v (slice c i len)) / pow2 (pbits * i);
(==) { Math.Lemmas.division_addition_lemma (bn_v (slice c 0 i)) (pow2 (pbits * i)) (bn_v (slice c i len)) }
bn_v (slice c 0 i) / pow2 (pbits * i) + bn_v (slice c i len);
(==) { bn_eval_bound (slice c 0 i) i; Math.Lemmas.small_division_lemma_1 (bn_v (slice c 0 i)) (pow2 (pbits * i)) }
bn_v (slice c i len);
};
assert (bn_v (slice c i len) == bn_v c / pow2 (pbits * i))
val bn_mod_pow2: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} -> lbignum t i
let bn_mod_pow2 #t #aLen a i = sub a 0 i
val bn_mod_pow2_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} ->
Lemma (bn_v (bn_mod_pow2 a i) == bn_v a % pow2 (bits t * i))
let bn_mod_pow2_lemma #t #aLen a i =
let pbits = bits t in
calc (==) {
bn_v a % pow2 (pbits * i);
(==) { bn_eval_split_i a i }
(bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v (slice a i aLen)) % pow2 (pbits * i);
(==) { Math.Lemmas.modulo_addition_lemma (bn_v (slice a 0 i)) (pow2 (pbits * i)) (bn_v (slice a i aLen)) }
(bn_v (slice a 0 i)) % pow2 (pbits * i);
(==) { bn_eval_bound (slice a 0 i) i; Math.Lemmas.small_mod (bn_v (slice a 0 i)) (pow2 (pbits * i)) }
bn_v (slice a 0 i);
}
///
/// Conditional swap
///
//the same as in curve25519
val lemma_cswap2_step:
#t:limb_t
-> bit:limb t{v bit <= 1}
-> p1:limb t
-> p2:limb t ->
Lemma
(let mask = uint #t 0 -. bit in
let dummy = mask &. (p1 ^. p2) in
let p1' = p1 ^. dummy in
let p2' = p2 ^. dummy in
if v bit = 1 then p1' == p2 /\ p2' == p1 else p1' == p1 /\ p2' == p2)
let lemma_cswap2_step #t bit p1 p2 =
let mask = uint #t 0 -. bit in
assert (v bit == 0 ==> v mask == 0);
assert (v bit == 1 ==> v mask == pow2 (bits t) - 1);
let dummy = mask &. (p1 ^. p2) in
logand_lemma mask (p1 ^. p2);
assert (v bit == 1 ==> v dummy == v (p1 ^. p2));
assert (v bit == 0 ==> v dummy == 0);
let p1' = p1 ^. dummy in
assert (v dummy == v (if v bit = 1 then (p1 ^. p2) else uint #t 0));
logxor_lemma p1 p2;
let p2' = p2 ^. dummy in
logxor_lemma p2 p1
val cswap2_f:
#t:limb_t
-> #len:size_nat
-> mask:limb t
-> i:nat{i < len}
-> tuple2 (lbignum t len) (lbignum t len) ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2_f #t #len mask i (p1, p2) =
let dummy = mask &. (p1.[i] ^. p2.[i]) in
let p1 = p1.[i] <- p1.[i] ^. dummy in
let p2 = p2.[i] <- p2.[i] ^. dummy in
(p1, p2)
val cswap2:
#t:limb_t
-> #len:size_nat
-> bit:limb t
-> b1:lbignum t len
-> b2:lbignum t len ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2 #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.repeati len (cswap2_f #t #len mask) (b1, b2)
val cswap2_lemma:
#t:limb_t
-> #len:size_nat
-> bit:limb t{v bit <= 1}
-> b1:lbignum t len
-> b2:lbignum t len ->
Lemma (let (p1, p2) = cswap2 bit b1 b2 in
(if v bit = 1 then p1 == b2 /\ p2 == b1 else p1 == b1 /\ p2 == b2))
let cswap2_lemma #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.eq_repeati0 len (cswap2_f #t #len mask) (b1, b2);
let (p1, p2) =
Loops.repeati_inductive #(tuple2 (lbignum t len) (lbignum t len)) len
(fun i (p1, p2) ->
(p1, p2) == Loops.repeati i (cswap2_f #t #len mask) (b1, b2) /\
(forall (k:nat{k < i}).
(if v bit = 1 then p1.[k] == b2.[k] /\ p2.[k] == b1.[k] else p1.[k] == b1.[k] /\ p2.[k] == b2.[k])) /\
(forall (k:nat{i <= k /\ k < len}). p1.[k] == b1.[k] /\ p2.[k] == b2.[k]))
(fun i (p1, p2) ->
Loops.unfold_repeati (i + 1) (cswap2_f #t #len mask) (b1, b2) i;
lemma_cswap2_step bit p1.[i] p2.[i];
cswap2_f #t #len mask i (p1, p2)) (b1, b2) in
assert (if v bit = 1 then (eq_intro p1 b2; p1 == b2) else (eq_intro p1 b1; p1 == b1));
assert (if v bit = 1 then (eq_intro p2 b1; p2 == b1) else (eq_intro p2 b2; p2 == b2));
//eq_intro p1 (if v bit = 1 then b2 else b1);
//eq_intro p2 (if v bit = 1 then b1 else b2);
()
let bn_get_top_index_t (len:size_nat) (i:nat{i <= len}) = x:nat{x < len}
val bn_get_top_index_f:
#t:limb_t
-> #len:size_nat
-> b:lbignum t len
-> i:nat{i < len}
-> priv:bn_get_top_index_t len i ->
bn_get_top_index_t len (i + 1)
let bn_get_top_index_f #t #len b i priv =
let mask = eq_mask b.[i] (zeros t SEC) in
if v mask = 0 then i else priv
val bn_get_top_index: #t:limb_t -> #len:size_pos -> b:lbignum t len -> res:size_nat{res < len}
let bn_get_top_index #t #len b =
Loops.repeat_gen len (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0
val bn_get_top_index_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (let ind = bn_get_top_index #t #len b in
ind < len /\ (ind > 0 ==> v b.[ind] <> 0) /\ (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0))
let bn_get_top_index_lemma #t #len b =
Loops.eq_repeat_gen0 len (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0;
let res =
Loops.repeati_inductive #size_nat len
(fun i priv ->
priv == Loops.repeat_gen i (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0 /\
priv < len /\ (priv > 0 ==> v b.[priv] <> 0) /\ (forall (k:nat{priv < k /\ k < i}). v b.[k] = 0))
(fun i priv ->
Loops.unfold_repeat_gen (i + 1) (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0 i;
let mask = eq_mask b.[i] (zeros t SEC) in
eq_mask_lemma b.[i] (zeros t SEC);
assert (if v mask = 0 then v b.[i] <> 0 else v b.[i] = 0);
let res = if v mask = 0 then i else priv in
res) 0 in
()
val bn_get_top_index_eval_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len -> ind:nat -> Lemma
(requires
ind < len /\ (ind > 0 ==> v b.[ind] <> 0) /\ (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0))
(ensures
bn_v b == bn_v (slice b 0 ind) + pow2 (bits t * ind) * v b.[ind])
let bn_get_top_index_eval_lemma #t #len b ind =
let pbits = bits t in
assert (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0);
bn_eval_split_i b (ind + 1);
assert (bn_v b == bn_v (slice b 0 (ind + 1)) + pow2 (pbits * (ind + 1)) * bn_v (slice b (ind + 1) len));
eq_intro (slice b (ind + 1) len) (create (len - ind - 1) (uint #t 0));
bn_eval_zeroes #t (len - ind - 1) (len - ind - 1);
assert (bn_v b == bn_v (slice b 0 (ind + 1)));
bn_eval_split_i (slice b 0 (ind + 1)) ind;
assert (bn_v b == bn_v (slice b 0 ind) + pow2 (pbits * ind) * bn_v (slice b ind (ind + 1)));
bn_eval1 (slice b ind (ind + 1));
assert (bn_v b == bn_v (slice b 0 ind) + pow2 (pbits * ind) * v b.[ind])
val bn_low_bound_bits:
#t:limb_t
-> #len:size_pos{bits t * len <= max_size_t}
-> b:lbignum t len ->
res:size_nat{res / bits t < len}
let bn_low_bound_bits #t #len b =
bits t * bn_get_top_index b
val bn_low_bound_bits_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len -> Lemma
(requires 1 < bn_v b /\ bits t * len <= max_size_t /\ bn_v b % 2 = 1)
(ensures pow2 (bn_low_bound_bits b) < bn_v b)
let bn_low_bound_bits_lemma #t #len b =
let ind = bn_get_top_index #t #len b in
bn_get_top_index_lemma #t #len b;
bn_get_top_index_eval_lemma #t #len b ind;
assert (pow2 (bn_low_bound_bits b) <= bn_v b);
if ind = 0 then
assert_norm (pow2 0 = 1)
else
Math.Lemmas.pow2_multiplication_modulo_lemma_1 1 1 (bn_low_bound_bits b)
val bn_get_bits_limb:
#t:limb_t
-> #nLen:size_nat
-> n:lbignum t nLen
-> ind:size_nat{ind / bits t < nLen} ->
limb t
let bn_get_bits_limb #t #nLen n ind =
let i = ind / bits t in
let j = ind % bits t in
let p1 = n.[i] >>. size j in
let p2 = if i + 1 < nLen && 0 < j then p1 |. (n.[i + 1] <<. (size (bits t - j))) else p1 in
p2
val bn_get_bits_limb_aux_lemma:
#t:limb_t
-> #nLen:size_nat
-> n:lbignum t nLen
-> ind:size_nat{ind / bits t < nLen} ->
Lemma (
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let p1 = n.[i] >>. size j in
bn_v n / pow2 ind % pow2 pbits == bn_v n / pow2 ((i + 1) * pbits) % pow2 pbits * pow2 (pbits - j) % pow2 pbits + v p1)
let bn_get_bits_limb_aux_lemma #t #nLen n ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let p1 = n.[i] >>. size j in
let res = bn_v n / pow2 ind % pow2 pbits in
calc (==) {
bn_v n / pow2 ind % pow2 pbits;
(==) { Math.Lemmas.euclidean_division_definition res (pow2 (pbits - j)) }
res / pow2 (pbits - j) * pow2 (pbits - j) + res % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v n / pow2 ind) (pbits - j) pbits }
res / pow2 (pbits - j) * pow2 (pbits - j) + bn_v n / pow2 ind % pow2 (pbits - j);
(==) { bn_get_ith_bit_aux_lemma n ind }
res / pow2 (pbits - j) * pow2 (pbits - j) + v p1;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v n / pow2 ind) (pbits - j) pbits }
bn_v n / pow2 ind / pow2 (pbits - j) % pow2 j * pow2 (pbits - j) + v p1;
(==) { Math.Lemmas.division_multiplication_lemma (bn_v n) (pow2 ind) (pow2 (pbits - j)) }
bn_v n / (pow2 ind * pow2 (pbits - j)) % pow2 j * pow2 (pbits - j) + v p1;
(==) { Math.Lemmas.pow2_plus ind (pbits - j) }
bn_v n / pow2 (ind + pbits - j) % pow2 j * pow2 (pbits - j) + v p1;
(==) { Math.Lemmas.euclidean_division_definition ind pbits }
bn_v n / pow2 (i * pbits + pbits) % pow2 j * pow2 (pbits - j) + v p1;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (bn_v n / pow2 (i * pbits + pbits)) pbits (pbits - j) }
bn_v n / pow2 (i * pbits + pbits) * pow2 (pbits - j) % pow2 pbits + v p1;
(==) { Math.Lemmas.distributivity_add_left i 1 pbits }
bn_v n / pow2 ((i + 1) * pbits) * pow2 (pbits - j) % pow2 pbits + v p1;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (bn_v n / pow2 ((i + 1) * pbits)) (pow2 (pbits - j)) (pow2 pbits) }
bn_v n / pow2 ((i + 1) * pbits) % pow2 pbits * pow2 (pbits - j) % pow2 pbits + v p1;
}
val bn_get_bits_limb_lemma:
#t:limb_t
-> #nLen:size_nat
-> n:lbignum t nLen
-> ind:size_nat{ind / bits t < nLen} ->
Lemma (v (bn_get_bits_limb n ind) == bn_v n / pow2 ind % pow2 (bits t)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
n: Hacl.Spec.Bignum.Definitions.lbignum t nLen ->
ind: Lib.IntTypes.size_nat{ind / Lib.IntTypes.bits t < nLen}
-> FStar.Pervasives.Lemma
(ensures
Lib.IntTypes.v (Hacl.Spec.Bignum.Lib.bn_get_bits_limb n ind) ==
Hacl.Spec.Bignum.Definitions.bn_v n / Prims.pow2 ind % Prims.pow2 (Lib.IntTypes.bits t)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Division",
"Lib.IntTypes.bits",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"Prims.op_Addition",
"Prims._assert",
"Prims.op_AmpAmp",
"Prims.op_Modulus",
"Prims.unit",
"Prims.eq2",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Hacl.Spec.Bignum.Definitions.bn_eval_index",
"Lib.IntTypes.logor_disjoint",
"Prims.op_Subtraction",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Bar_Dot",
"FStar.Calc.calc_finish",
"Prims.pow2",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"FStar.Mul.op_Star",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Bignum.Definitions.limb",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1",
"FStar.Math.Lemmas.multiple_modulo_lemma",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.IntTypes.size",
"FStar.Pervasives.assert_norm",
"Hacl.Spec.Bignum.Definitions.bn_v",
"FStar.Math.Lemmas.pow2_minus",
"FStar.Math.Lemmas.lemma_div_lt_nat",
"Hacl.Spec.Bignum.Definitions.bn_eval_bound",
"Hacl.Spec.Bignum.Lib.bn_get_bits_limb_aux_lemma",
"Hacl.Spec.Bignum.Lib.bn_get_ith_bit_aux_lemma",
"Lib.IntTypes.op_Greater_Greater_Dot"
] | [] | false | false | true | false | false | let bn_get_bits_limb_lemma #t #nLen n ind =
| let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
assert (i == ind / bits t);
assert (i < nLen);
let p1 = n.[ i ] >>. size j in
let res = bn_v n / pow2 ind % pow2 pbits in
bn_get_ith_bit_aux_lemma n ind;
assert (v p1 == bn_v n / pow2 ind % pow2 (pbits - j));
if j = 0
then ()
else
(bn_get_bits_limb_aux_lemma n ind;
if i + 1 < nLen
then
let p2 = n.[ i + 1 ] <<. (size (pbits - j)) in
calc ( == ) {
v p2 % pow2 (pbits - j);
( == ) { () }
v n.[ i + 1 ] * pow2 (pbits - j) % pow2 pbits % pow2 (pbits - j);
( == ) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (v n.[ i + 1 ] * pow2 (pbits - j))
(pbits - j)
pbits }
v n.[ i + 1 ] * pow2 (pbits - j) % pow2 (pbits - j);
( == ) { Math.Lemmas.multiple_modulo_lemma (v n.[ i + 1 ]) (pow2 (pbits - j)) }
0;
};
let p3 = p1 |. p2 in
logor_disjoint p1 p2 (pbits - j);
assert (v p3 == v p1 + v p2);
bn_eval_index n (i + 1);
assert (res == v p1 + v p2);
assert (ind / bits t + 1 < nLen && 0 < ind % bits t)
else
(bn_eval_bound n nLen;
assert (bn_v n < pow2 (nLen * pbits));
Math.Lemmas.lemma_div_lt_nat (bn_v n) (nLen * pbits) ((i + 1) * pbits);
Math.Lemmas.pow2_minus (nLen * pbits) ((i + 1) * pbits);
assert (bn_v n / pow2 ((i + 1) * pbits) < pow2 0);
assert_norm (pow2 0 = 1);
assert (res == v p1))) | false |
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.cswap2_lemma | val cswap2_lemma:
#t:limb_t
-> #len:size_nat
-> bit:limb t{v bit <= 1}
-> b1:lbignum t len
-> b2:lbignum t len ->
Lemma (let (p1, p2) = cswap2 bit b1 b2 in
(if v bit = 1 then p1 == b2 /\ p2 == b1 else p1 == b1 /\ p2 == b2)) | val cswap2_lemma:
#t:limb_t
-> #len:size_nat
-> bit:limb t{v bit <= 1}
-> b1:lbignum t len
-> b2:lbignum t len ->
Lemma (let (p1, p2) = cswap2 bit b1 b2 in
(if v bit = 1 then p1 == b2 /\ p2 == b1 else p1 == b1 /\ p2 == b2)) | let cswap2_lemma #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.eq_repeati0 len (cswap2_f #t #len mask) (b1, b2);
let (p1, p2) =
Loops.repeati_inductive #(tuple2 (lbignum t len) (lbignum t len)) len
(fun i (p1, p2) ->
(p1, p2) == Loops.repeati i (cswap2_f #t #len mask) (b1, b2) /\
(forall (k:nat{k < i}).
(if v bit = 1 then p1.[k] == b2.[k] /\ p2.[k] == b1.[k] else p1.[k] == b1.[k] /\ p2.[k] == b2.[k])) /\
(forall (k:nat{i <= k /\ k < len}). p1.[k] == b1.[k] /\ p2.[k] == b2.[k]))
(fun i (p1, p2) ->
Loops.unfold_repeati (i + 1) (cswap2_f #t #len mask) (b1, b2) i;
lemma_cswap2_step bit p1.[i] p2.[i];
cswap2_f #t #len mask i (p1, p2)) (b1, b2) in
assert (if v bit = 1 then (eq_intro p1 b2; p1 == b2) else (eq_intro p1 b1; p1 == b1));
assert (if v bit = 1 then (eq_intro p2 b1; p2 == b1) else (eq_intro p2 b2; p2 == b2));
//eq_intro p1 (if v bit = 1 then b2 else b1);
//eq_intro p2 (if v bit = 1 then b1 else b2);
() | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 309,
"start_col": 0,
"start_line": 290
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2)
let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2)
val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t
let bn_get_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[i] j
val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j))
let bn_get_ith_bit_aux_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = b.[i] >>. size j in
calc (==) {
v b.[i] / pow2 j;
(==) { bn_eval_index b i }
(bn_v b / pow2 (pbits * i) % pow2 pbits) / pow2 j;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b / pow2 (pbits * i)) j pbits }
(bn_v b / pow2 (pbits * i) / pow2 j) % pow2 (pbits - j);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b) (pow2 (pbits * i)) (pow2 j) }
(bn_v b / (pow2 (pbits * i) * pow2 j)) % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_plus (pbits * i) j }
(bn_v b / pow2 (pbits * i + j)) % pow2 (pbits - j);
(==) { Math.Lemmas.euclidean_div_axiom ind pbits }
(bn_v b / pow2 ind) % pow2 (pbits - j);
};
assert (v res == (bn_v b / pow2 ind) % pow2 (pbits - j))
val bn_get_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} ->
Lemma (v (bn_get_ith_bit b i) == (bn_v b / pow2 i % 2))
let bn_get_ith_bit_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = limb_get_ith_bit b.[i] j in
limb_get_ith_bit_lemma b.[i] j;
calc (==) {
v b.[i] / pow2 j % 2;
(==) { bn_get_ith_bit_aux_lemma b ind }
(bn_v b / pow2 ind) % pow2 (pbits - j) % 2;
(==) { assert_norm (pow2 1 = 2);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 ind) 1 (pbits - j) }
(bn_v b / pow2 ind) % 2;
};
assert (v res == bn_v b / pow2 ind % 2)
val bn_set_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> lbignum t len
let bn_set_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
let inp = input.[i] <- input.[i] |. (uint #t 1 <<. size j) in
inp
val bn_set_ith_bit_lemma_aux: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a + b * pow2 c < pow2 (c + d) /\ a < pow2 c)
(ensures b < pow2 d)
let bn_set_ith_bit_lemma_aux a b c d =
Math.Lemmas.lemma_div_lt_nat (a + b * pow2 c) (c + d) c;
assert ((a + b * pow2 c) / pow2 c < pow2 d);
Math.Lemmas.lemma_div_plus a b (pow2 c);
assert (a / pow2 c + b < pow2 d);
Math.Lemmas.small_division_lemma_1 a (pow2 c)
val bn_lt_pow2_index_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} -> Lemma
(requires bn_v b < pow2 ind)
(ensures (let i = ind / bits t in v b.[i] < pow2 (ind % bits t) /\
bn_v b == bn_v (slice b 0 i) + pow2 (i * bits t) * v b.[i] /\
bn_v (slice b (i + 1) len) = 0))
let bn_lt_pow2_index_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
Math.Lemmas.euclidean_division_definition ind (pbits);
assert (bn_v b < pow2 (i * pbits + j));
Math.Lemmas.pow2_lt_compat (i * pbits + pbits) (i * pbits + j);
assert (bn_v b < pow2 (i * pbits + pbits));
bn_eval_split_i #t #len b (i + 1);
bn_eval_bound (slice b 0 (i + 1)) (i + 1);
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 (i + 1))) (bn_v (slice b (i + 1) len)) (pbits * (i + 1)) 0;
assert (bn_v b == bn_v (slice b 0 (i + 1)));
bn_eval_split_i #t #(i + 1) (slice b 0 (i + 1)) i;
bn_eval1 (slice b i (i + 1));
assert (bn_v b == bn_v (slice b 0 i) + pow2 (i * pbits) * v b.[i]);
bn_eval_bound #t #i (slice b 0 i) i;
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 i)) (v b.[i]) (i * pbits) j;
assert (v b.[i] < pow2 j)
val bn_set_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> Lemma
(requires bn_v b < pow2 i)
(ensures bn_v (bn_set_ith_bit b i) == bn_v b + pow2 i)
let bn_set_ith_bit_lemma #t #len input ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
bn_lt_pow2_index_lemma #t #len input ind;
assert (v input.[i] < pow2 j);
let b = uint #t 1 <<. size j in
let inp = input.[i] <- input.[i] |. b in
FStar.Math.Lemmas.pow2_lt_compat pbits j;
FStar.Math.Lemmas.modulo_lemma (pow2 j) (pow2 pbits);
assert (v b == pow2 j);
logor_disjoint (input.[i]) b j;
assert (v inp.[i] == v input.[i] + v b);
calc (==) {
bn_v inp;
(==) { bn_eval_split_i #t #len inp (i + 1);
bn_eval_extensionality_j (slice inp (i + 1) len) (slice input (i + 1) len) (len - i - 1) }
bn_v (slice inp 0 (i + 1));
(==) { bn_eval_split_i #t #(i + 1) (slice inp 0 (i + 1)) i }
bn_v (slice inp 0 i) + pow2 (i * pbits) * bn_v (slice inp i (i + 1));
(==) { bn_eval1 (slice inp i (i + 1)) }
bn_v (slice inp 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { bn_eval_extensionality_j input inp i }
bn_v (slice input 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { }
bn_v (slice input 0 i) + pow2 (i * pbits) * (v input.[i] + v b);
(==) { Math.Lemmas.distributivity_add_right (pow2 (i * pbits)) (v input.[i]) (v b) }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 (i * pbits) * v b;
(==) { Math.Lemmas.pow2_plus (i * pbits) j; Math.Lemmas.euclidean_division_definition ind pbits }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 ind;
(==) { }
bn_v input + pow2 ind;
}
///
/// % pow2 and / pow2
///
val bn_div_pow2: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i <= len} -> lbignum t (len - i)
let bn_div_pow2 #t #len b i =
slice b i len
val bn_div_pow2_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i < len} ->
Lemma (bn_v (bn_div_pow2 b i) == bn_v b / pow2 (bits t * i))
let bn_div_pow2_lemma #t #len c i =
let pbits = bits t in
calc (==) {
bn_v c / pow2 (pbits * i);
(==) { bn_eval_split_i c i }
(bn_v (slice c 0 i) + pow2 (pbits * i) * bn_v (slice c i len)) / pow2 (pbits * i);
(==) { Math.Lemmas.division_addition_lemma (bn_v (slice c 0 i)) (pow2 (pbits * i)) (bn_v (slice c i len)) }
bn_v (slice c 0 i) / pow2 (pbits * i) + bn_v (slice c i len);
(==) { bn_eval_bound (slice c 0 i) i; Math.Lemmas.small_division_lemma_1 (bn_v (slice c 0 i)) (pow2 (pbits * i)) }
bn_v (slice c i len);
};
assert (bn_v (slice c i len) == bn_v c / pow2 (pbits * i))
val bn_mod_pow2: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} -> lbignum t i
let bn_mod_pow2 #t #aLen a i = sub a 0 i
val bn_mod_pow2_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} ->
Lemma (bn_v (bn_mod_pow2 a i) == bn_v a % pow2 (bits t * i))
let bn_mod_pow2_lemma #t #aLen a i =
let pbits = bits t in
calc (==) {
bn_v a % pow2 (pbits * i);
(==) { bn_eval_split_i a i }
(bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v (slice a i aLen)) % pow2 (pbits * i);
(==) { Math.Lemmas.modulo_addition_lemma (bn_v (slice a 0 i)) (pow2 (pbits * i)) (bn_v (slice a i aLen)) }
(bn_v (slice a 0 i)) % pow2 (pbits * i);
(==) { bn_eval_bound (slice a 0 i) i; Math.Lemmas.small_mod (bn_v (slice a 0 i)) (pow2 (pbits * i)) }
bn_v (slice a 0 i);
}
///
/// Conditional swap
///
//the same as in curve25519
val lemma_cswap2_step:
#t:limb_t
-> bit:limb t{v bit <= 1}
-> p1:limb t
-> p2:limb t ->
Lemma
(let mask = uint #t 0 -. bit in
let dummy = mask &. (p1 ^. p2) in
let p1' = p1 ^. dummy in
let p2' = p2 ^. dummy in
if v bit = 1 then p1' == p2 /\ p2' == p1 else p1' == p1 /\ p2' == p2)
let lemma_cswap2_step #t bit p1 p2 =
let mask = uint #t 0 -. bit in
assert (v bit == 0 ==> v mask == 0);
assert (v bit == 1 ==> v mask == pow2 (bits t) - 1);
let dummy = mask &. (p1 ^. p2) in
logand_lemma mask (p1 ^. p2);
assert (v bit == 1 ==> v dummy == v (p1 ^. p2));
assert (v bit == 0 ==> v dummy == 0);
let p1' = p1 ^. dummy in
assert (v dummy == v (if v bit = 1 then (p1 ^. p2) else uint #t 0));
logxor_lemma p1 p2;
let p2' = p2 ^. dummy in
logxor_lemma p2 p1
val cswap2_f:
#t:limb_t
-> #len:size_nat
-> mask:limb t
-> i:nat{i < len}
-> tuple2 (lbignum t len) (lbignum t len) ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2_f #t #len mask i (p1, p2) =
let dummy = mask &. (p1.[i] ^. p2.[i]) in
let p1 = p1.[i] <- p1.[i] ^. dummy in
let p2 = p2.[i] <- p2.[i] ^. dummy in
(p1, p2)
val cswap2:
#t:limb_t
-> #len:size_nat
-> bit:limb t
-> b1:lbignum t len
-> b2:lbignum t len ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2 #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.repeati len (cswap2_f #t #len mask) (b1, b2)
val cswap2_lemma:
#t:limb_t
-> #len:size_nat
-> bit:limb t{v bit <= 1}
-> b1:lbignum t len
-> b2:lbignum t len ->
Lemma (let (p1, p2) = cswap2 bit b1 b2 in
(if v bit = 1 then p1 == b2 /\ p2 == b1 else p1 == b1 /\ p2 == b2)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
bit: Hacl.Spec.Bignum.Definitions.limb t {Lib.IntTypes.v bit <= 1} ->
b1: Hacl.Spec.Bignum.Definitions.lbignum t len ->
b2: Hacl.Spec.Bignum.Definitions.lbignum t len
-> FStar.Pervasives.Lemma
(ensures
(let _ = Hacl.Spec.Bignum.Lib.cswap2 bit b1 b2 in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ p1 p2 = _ in
(match Lib.IntTypes.v bit = 1 with
| true -> p1 == b2 /\ p2 == b1
| _ -> p1 == b1 /\ p2 == b2)
<:
Type0)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.unit",
"Prims._assert",
"Prims.op_Equality",
"Prims.int",
"Prims.eq2",
"Lib.Sequence.eq_intro",
"Prims.bool",
"FStar.Pervasives.Native.tuple2",
"Prims.l_and",
"FStar.Pervasives.Native.Mktuple2",
"Lib.LoopCombinators.repeati",
"Hacl.Spec.Bignum.Lib.cswap2_f",
"Prims.l_Forall",
"Prims.nat",
"Prims.op_LessThan",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.index",
"Lib.LoopCombinators.repeati_inductive",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Bignum.Lib.lemma_cswap2_step",
"Lib.LoopCombinators.unfold_repeati",
"Prims.op_Addition",
"Lib.LoopCombinators.eq_repeati0",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Subtraction_Dot",
"Lib.IntTypes.uint"
] | [] | false | false | true | false | false | let cswap2_lemma #t #len bit b1 b2 =
| let mask = uint #t 0 -. bit in
Loops.eq_repeati0 len (cswap2_f #t #len mask) (b1, b2);
let p1, p2 =
Loops.repeati_inductive #(tuple2 (lbignum t len) (lbignum t len))
len
(fun i (p1, p2) ->
(p1, p2) == Loops.repeati i (cswap2_f #t #len mask) (b1, b2) /\
(forall (k: nat{k < i}).
(if v bit = 1
then p1.[ k ] == b2.[ k ] /\ p2.[ k ] == b1.[ k ]
else p1.[ k ] == b1.[ k ] /\ p2.[ k ] == b2.[ k ])) /\
(forall (k: nat{i <= k /\ k < len}). p1.[ k ] == b1.[ k ] /\ p2.[ k ] == b2.[ k ]))
(fun i (p1, p2) ->
Loops.unfold_repeati (i + 1) (cswap2_f #t #len mask) (b1, b2) i;
lemma_cswap2_step bit p1.[ i ] p2.[ i ];
cswap2_f #t #len mask i (p1, p2))
(b1, b2)
in
assert (if v bit = 1
then
(eq_intro p1 b2;
p1 == b2)
else
(eq_intro p1 b1;
p1 == b1));
assert (if v bit = 1
then
(eq_intro p2 b1;
p2 == b1)
else
(eq_intro p2 b2;
p2 == b2));
() | false |
Hacl.Bignum256.fsti | Hacl.Bignum256.t_limbs | val t_limbs:Hacl.Bignum.Definitions.limb_t | val t_limbs:Hacl.Bignum.Definitions.limb_t | let t_limbs: Hacl.Bignum.Definitions.limb_t = Lib.IntTypes.U64 | {
"file_name": "code/bignum/Hacl.Bignum256.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 62,
"end_line": 12,
"start_col": 0,
"start_line": 12
} | module Hacl.Bignum256
open FStar.Mul
module BN = Hacl.Bignum
module BS = Hacl.Bignum.SafeAPI
module MA = Hacl.Bignum.MontArithmetic
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Bignum.SafeAPI.fst.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum256.fsti"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Hacl.Bignum.Definitions.limb_t | Prims.Tot | [
"total"
] | [] | [
"Lib.IntTypes.U64"
] | [] | false | false | false | true | false | let t_limbs:Hacl.Bignum.Definitions.limb_t =
| Lib.IntTypes.U64 | false |
Hacl.Bignum256.fsti | Hacl.Bignum256.lbignum | val lbignum : t: Hacl.Bignum.Definitions.limb_t -> len: Lib.IntTypes.size_t -> Type0 | let lbignum = Hacl.Bignum.Definitions.lbignum | {
"file_name": "code/bignum/Hacl.Bignum256.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 45,
"end_line": 28,
"start_col": 0,
"start_line": 28
} | module Hacl.Bignum256
open FStar.Mul
module BN = Hacl.Bignum
module BS = Hacl.Bignum.SafeAPI
module MA = Hacl.Bignum.MontArithmetic
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let t_limbs: Hacl.Bignum.Definitions.limb_t = Lib.IntTypes.U64
inline_for_extraction noextract
let n_limbs: BN.meta_len t_limbs = 4ul
inline_for_extraction noextract
let n_bytes = n_limbs `FStar.UInt32.mul` 8ul
// A static assert that the number of bytes vs number of blocks matches. This is
// important for bn_to_bytes_be which takes a number of bytes, not a number of
// limbs. (It would be nice to fix this.)
let _ = assert_norm (Hacl.Bignum.Definitions.blocks n_bytes 8ul = n_limbs)
let _ = assert_norm (256ul = Lib.IntTypes.(size (bits t_limbs)) `FStar.UInt32.mul` n_limbs) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Bignum.SafeAPI.fst.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum256.fsti"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: Hacl.Bignum.Definitions.limb_t -> len: Lib.IntTypes.size_t -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.lbignum"
] | [] | false | false | false | true | true | let lbignum =
| Hacl.Bignum.Definitions.lbignum | false |
|
Hacl.Spec.Bignum.Lib.fst | Hacl.Spec.Bignum.Lib.bn_get_bits_limb_aux_lemma | val bn_get_bits_limb_aux_lemma:
#t:limb_t
-> #nLen:size_nat
-> n:lbignum t nLen
-> ind:size_nat{ind / bits t < nLen} ->
Lemma (
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let p1 = n.[i] >>. size j in
bn_v n / pow2 ind % pow2 pbits == bn_v n / pow2 ((i + 1) * pbits) % pow2 pbits * pow2 (pbits - j) % pow2 pbits + v p1) | val bn_get_bits_limb_aux_lemma:
#t:limb_t
-> #nLen:size_nat
-> n:lbignum t nLen
-> ind:size_nat{ind / bits t < nLen} ->
Lemma (
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let p1 = n.[i] >>. size j in
bn_v n / pow2 ind % pow2 pbits == bn_v n / pow2 ((i + 1) * pbits) % pow2 pbits * pow2 (pbits - j) % pow2 pbits + v p1) | let bn_get_bits_limb_aux_lemma #t #nLen n ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let p1 = n.[i] >>. size j in
let res = bn_v n / pow2 ind % pow2 pbits in
calc (==) {
bn_v n / pow2 ind % pow2 pbits;
(==) { Math.Lemmas.euclidean_division_definition res (pow2 (pbits - j)) }
res / pow2 (pbits - j) * pow2 (pbits - j) + res % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v n / pow2 ind) (pbits - j) pbits }
res / pow2 (pbits - j) * pow2 (pbits - j) + bn_v n / pow2 ind % pow2 (pbits - j);
(==) { bn_get_ith_bit_aux_lemma n ind }
res / pow2 (pbits - j) * pow2 (pbits - j) + v p1;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v n / pow2 ind) (pbits - j) pbits }
bn_v n / pow2 ind / pow2 (pbits - j) % pow2 j * pow2 (pbits - j) + v p1;
(==) { Math.Lemmas.division_multiplication_lemma (bn_v n) (pow2 ind) (pow2 (pbits - j)) }
bn_v n / (pow2 ind * pow2 (pbits - j)) % pow2 j * pow2 (pbits - j) + v p1;
(==) { Math.Lemmas.pow2_plus ind (pbits - j) }
bn_v n / pow2 (ind + pbits - j) % pow2 j * pow2 (pbits - j) + v p1;
(==) { Math.Lemmas.euclidean_division_definition ind pbits }
bn_v n / pow2 (i * pbits + pbits) % pow2 j * pow2 (pbits - j) + v p1;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (bn_v n / pow2 (i * pbits + pbits)) pbits (pbits - j) }
bn_v n / pow2 (i * pbits + pbits) * pow2 (pbits - j) % pow2 pbits + v p1;
(==) { Math.Lemmas.distributivity_add_left i 1 pbits }
bn_v n / pow2 ((i + 1) * pbits) * pow2 (pbits - j) % pow2 pbits + v p1;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (bn_v n / pow2 ((i + 1) * pbits)) (pow2 (pbits - j)) (pow2 pbits) }
bn_v n / pow2 ((i + 1) * pbits) % pow2 pbits * pow2 (pbits - j) % pow2 pbits + v p1;
} | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 453,
"start_col": 0,
"start_line": 424
} | module Hacl.Spec.Bignum.Lib
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module BB = Hacl.Spec.Bignum.Base
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Get and set i-th bit of a bignum
///
val limb_get_ith_bit: #t:limb_t -> a:limb t -> i:nat{i < bits t} -> limb t
let limb_get_ith_bit #t a i = (a >>. size i) &. uint #t 1
val limb_get_ith_bit_lemma: #t:limb_t -> a:limb t -> i:nat{i < bits t} ->
Lemma (v (limb_get_ith_bit a i) == v a / pow2 i % 2)
let limb_get_ith_bit_lemma #t a i =
let tmp1 = a >>. size i in
let tmp2 = tmp1 &. uint #t 1 in
mod_mask_lemma tmp1 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1));
assert (v tmp2 == v a / pow2 i % 2)
val bn_get_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> limb t
let bn_get_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
limb_get_ith_bit input.[i] j
val bn_get_ith_bit_aux_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} ->
Lemma (let i = ind / bits t in let j = ind % bits t in
v (b.[i] >>. size j) == (bn_v b / pow2 ind) % pow2 (bits t - j))
let bn_get_ith_bit_aux_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = b.[i] >>. size j in
calc (==) {
v b.[i] / pow2 j;
(==) { bn_eval_index b i }
(bn_v b / pow2 (pbits * i) % pow2 pbits) / pow2 j;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b / pow2 (pbits * i)) j pbits }
(bn_v b / pow2 (pbits * i) / pow2 j) % pow2 (pbits - j);
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b) (pow2 (pbits * i)) (pow2 j) }
(bn_v b / (pow2 (pbits * i) * pow2 j)) % pow2 (pbits - j);
(==) { Math.Lemmas.pow2_plus (pbits * i) j }
(bn_v b / pow2 (pbits * i + j)) % pow2 (pbits - j);
(==) { Math.Lemmas.euclidean_div_axiom ind pbits }
(bn_v b / pow2 ind) % pow2 (pbits - j);
};
assert (v res == (bn_v b / pow2 ind) % pow2 (pbits - j))
val bn_get_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} ->
Lemma (v (bn_get_ith_bit b i) == (bn_v b / pow2 i % 2))
let bn_get_ith_bit_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let res = limb_get_ith_bit b.[i] j in
limb_get_ith_bit_lemma b.[i] j;
calc (==) {
v b.[i] / pow2 j % 2;
(==) { bn_get_ith_bit_aux_lemma b ind }
(bn_v b / pow2 ind) % pow2 (pbits - j) % 2;
(==) { assert_norm (pow2 1 = 2);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 ind) 1 (pbits - j) }
(bn_v b / pow2 ind) % 2;
};
assert (v res == bn_v b / pow2 ind % 2)
val bn_set_ith_bit: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> lbignum t len
let bn_set_ith_bit #t #len input ind =
let i = ind / bits t in
let j = ind % bits t in
let inp = input.[i] <- input.[i] |. (uint #t 1 <<. size j) in
inp
val bn_set_ith_bit_lemma_aux: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a + b * pow2 c < pow2 (c + d) /\ a < pow2 c)
(ensures b < pow2 d)
let bn_set_ith_bit_lemma_aux a b c d =
Math.Lemmas.lemma_div_lt_nat (a + b * pow2 c) (c + d) c;
assert ((a + b * pow2 c) / pow2 c < pow2 d);
Math.Lemmas.lemma_div_plus a b (pow2 c);
assert (a / pow2 c + b < pow2 d);
Math.Lemmas.small_division_lemma_1 a (pow2 c)
val bn_lt_pow2_index_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> ind:size_nat{ind / bits t < len} -> Lemma
(requires bn_v b < pow2 ind)
(ensures (let i = ind / bits t in v b.[i] < pow2 (ind % bits t) /\
bn_v b == bn_v (slice b 0 i) + pow2 (i * bits t) * v b.[i] /\
bn_v (slice b (i + 1) len) = 0))
let bn_lt_pow2_index_lemma #t #len b ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
Math.Lemmas.euclidean_division_definition ind (pbits);
assert (bn_v b < pow2 (i * pbits + j));
Math.Lemmas.pow2_lt_compat (i * pbits + pbits) (i * pbits + j);
assert (bn_v b < pow2 (i * pbits + pbits));
bn_eval_split_i #t #len b (i + 1);
bn_eval_bound (slice b 0 (i + 1)) (i + 1);
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 (i + 1))) (bn_v (slice b (i + 1) len)) (pbits * (i + 1)) 0;
assert (bn_v b == bn_v (slice b 0 (i + 1)));
bn_eval_split_i #t #(i + 1) (slice b 0 (i + 1)) i;
bn_eval1 (slice b i (i + 1));
assert (bn_v b == bn_v (slice b 0 i) + pow2 (i * pbits) * v b.[i]);
bn_eval_bound #t #i (slice b 0 i) i;
bn_set_ith_bit_lemma_aux (bn_v (slice b 0 i)) (v b.[i]) (i * pbits) j;
assert (v b.[i] < pow2 j)
val bn_set_ith_bit_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i / bits t < len} -> Lemma
(requires bn_v b < pow2 i)
(ensures bn_v (bn_set_ith_bit b i) == bn_v b + pow2 i)
let bn_set_ith_bit_lemma #t #len input ind =
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
bn_lt_pow2_index_lemma #t #len input ind;
assert (v input.[i] < pow2 j);
let b = uint #t 1 <<. size j in
let inp = input.[i] <- input.[i] |. b in
FStar.Math.Lemmas.pow2_lt_compat pbits j;
FStar.Math.Lemmas.modulo_lemma (pow2 j) (pow2 pbits);
assert (v b == pow2 j);
logor_disjoint (input.[i]) b j;
assert (v inp.[i] == v input.[i] + v b);
calc (==) {
bn_v inp;
(==) { bn_eval_split_i #t #len inp (i + 1);
bn_eval_extensionality_j (slice inp (i + 1) len) (slice input (i + 1) len) (len - i - 1) }
bn_v (slice inp 0 (i + 1));
(==) { bn_eval_split_i #t #(i + 1) (slice inp 0 (i + 1)) i }
bn_v (slice inp 0 i) + pow2 (i * pbits) * bn_v (slice inp i (i + 1));
(==) { bn_eval1 (slice inp i (i + 1)) }
bn_v (slice inp 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { bn_eval_extensionality_j input inp i }
bn_v (slice input 0 i) + pow2 (i * pbits) * v inp.[i];
(==) { }
bn_v (slice input 0 i) + pow2 (i * pbits) * (v input.[i] + v b);
(==) { Math.Lemmas.distributivity_add_right (pow2 (i * pbits)) (v input.[i]) (v b) }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 (i * pbits) * v b;
(==) { Math.Lemmas.pow2_plus (i * pbits) j; Math.Lemmas.euclidean_division_definition ind pbits }
bn_v (slice input 0 i) + pow2 (i * pbits) * v input.[i] + pow2 ind;
(==) { }
bn_v input + pow2 ind;
}
///
/// % pow2 and / pow2
///
val bn_div_pow2: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i <= len} -> lbignum t (len - i)
let bn_div_pow2 #t #len b i =
slice b i len
val bn_div_pow2_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:size_nat{i < len} ->
Lemma (bn_v (bn_div_pow2 b i) == bn_v b / pow2 (bits t * i))
let bn_div_pow2_lemma #t #len c i =
let pbits = bits t in
calc (==) {
bn_v c / pow2 (pbits * i);
(==) { bn_eval_split_i c i }
(bn_v (slice c 0 i) + pow2 (pbits * i) * bn_v (slice c i len)) / pow2 (pbits * i);
(==) { Math.Lemmas.division_addition_lemma (bn_v (slice c 0 i)) (pow2 (pbits * i)) (bn_v (slice c i len)) }
bn_v (slice c 0 i) / pow2 (pbits * i) + bn_v (slice c i len);
(==) { bn_eval_bound (slice c 0 i) i; Math.Lemmas.small_division_lemma_1 (bn_v (slice c 0 i)) (pow2 (pbits * i)) }
bn_v (slice c i len);
};
assert (bn_v (slice c i len) == bn_v c / pow2 (pbits * i))
val bn_mod_pow2: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} -> lbignum t i
let bn_mod_pow2 #t #aLen a i = sub a 0 i
val bn_mod_pow2_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:nat{i <= aLen} ->
Lemma (bn_v (bn_mod_pow2 a i) == bn_v a % pow2 (bits t * i))
let bn_mod_pow2_lemma #t #aLen a i =
let pbits = bits t in
calc (==) {
bn_v a % pow2 (pbits * i);
(==) { bn_eval_split_i a i }
(bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v (slice a i aLen)) % pow2 (pbits * i);
(==) { Math.Lemmas.modulo_addition_lemma (bn_v (slice a 0 i)) (pow2 (pbits * i)) (bn_v (slice a i aLen)) }
(bn_v (slice a 0 i)) % pow2 (pbits * i);
(==) { bn_eval_bound (slice a 0 i) i; Math.Lemmas.small_mod (bn_v (slice a 0 i)) (pow2 (pbits * i)) }
bn_v (slice a 0 i);
}
///
/// Conditional swap
///
//the same as in curve25519
val lemma_cswap2_step:
#t:limb_t
-> bit:limb t{v bit <= 1}
-> p1:limb t
-> p2:limb t ->
Lemma
(let mask = uint #t 0 -. bit in
let dummy = mask &. (p1 ^. p2) in
let p1' = p1 ^. dummy in
let p2' = p2 ^. dummy in
if v bit = 1 then p1' == p2 /\ p2' == p1 else p1' == p1 /\ p2' == p2)
let lemma_cswap2_step #t bit p1 p2 =
let mask = uint #t 0 -. bit in
assert (v bit == 0 ==> v mask == 0);
assert (v bit == 1 ==> v mask == pow2 (bits t) - 1);
let dummy = mask &. (p1 ^. p2) in
logand_lemma mask (p1 ^. p2);
assert (v bit == 1 ==> v dummy == v (p1 ^. p2));
assert (v bit == 0 ==> v dummy == 0);
let p1' = p1 ^. dummy in
assert (v dummy == v (if v bit = 1 then (p1 ^. p2) else uint #t 0));
logxor_lemma p1 p2;
let p2' = p2 ^. dummy in
logxor_lemma p2 p1
val cswap2_f:
#t:limb_t
-> #len:size_nat
-> mask:limb t
-> i:nat{i < len}
-> tuple2 (lbignum t len) (lbignum t len) ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2_f #t #len mask i (p1, p2) =
let dummy = mask &. (p1.[i] ^. p2.[i]) in
let p1 = p1.[i] <- p1.[i] ^. dummy in
let p2 = p2.[i] <- p2.[i] ^. dummy in
(p1, p2)
val cswap2:
#t:limb_t
-> #len:size_nat
-> bit:limb t
-> b1:lbignum t len
-> b2:lbignum t len ->
tuple2 (lbignum t len) (lbignum t len)
let cswap2 #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.repeati len (cswap2_f #t #len mask) (b1, b2)
val cswap2_lemma:
#t:limb_t
-> #len:size_nat
-> bit:limb t{v bit <= 1}
-> b1:lbignum t len
-> b2:lbignum t len ->
Lemma (let (p1, p2) = cswap2 bit b1 b2 in
(if v bit = 1 then p1 == b2 /\ p2 == b1 else p1 == b1 /\ p2 == b2))
let cswap2_lemma #t #len bit b1 b2 =
let mask = uint #t 0 -. bit in
Loops.eq_repeati0 len (cswap2_f #t #len mask) (b1, b2);
let (p1, p2) =
Loops.repeati_inductive #(tuple2 (lbignum t len) (lbignum t len)) len
(fun i (p1, p2) ->
(p1, p2) == Loops.repeati i (cswap2_f #t #len mask) (b1, b2) /\
(forall (k:nat{k < i}).
(if v bit = 1 then p1.[k] == b2.[k] /\ p2.[k] == b1.[k] else p1.[k] == b1.[k] /\ p2.[k] == b2.[k])) /\
(forall (k:nat{i <= k /\ k < len}). p1.[k] == b1.[k] /\ p2.[k] == b2.[k]))
(fun i (p1, p2) ->
Loops.unfold_repeati (i + 1) (cswap2_f #t #len mask) (b1, b2) i;
lemma_cswap2_step bit p1.[i] p2.[i];
cswap2_f #t #len mask i (p1, p2)) (b1, b2) in
assert (if v bit = 1 then (eq_intro p1 b2; p1 == b2) else (eq_intro p1 b1; p1 == b1));
assert (if v bit = 1 then (eq_intro p2 b1; p2 == b1) else (eq_intro p2 b2; p2 == b2));
//eq_intro p1 (if v bit = 1 then b2 else b1);
//eq_intro p2 (if v bit = 1 then b1 else b2);
()
let bn_get_top_index_t (len:size_nat) (i:nat{i <= len}) = x:nat{x < len}
val bn_get_top_index_f:
#t:limb_t
-> #len:size_nat
-> b:lbignum t len
-> i:nat{i < len}
-> priv:bn_get_top_index_t len i ->
bn_get_top_index_t len (i + 1)
let bn_get_top_index_f #t #len b i priv =
let mask = eq_mask b.[i] (zeros t SEC) in
if v mask = 0 then i else priv
val bn_get_top_index: #t:limb_t -> #len:size_pos -> b:lbignum t len -> res:size_nat{res < len}
let bn_get_top_index #t #len b =
Loops.repeat_gen len (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0
val bn_get_top_index_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (let ind = bn_get_top_index #t #len b in
ind < len /\ (ind > 0 ==> v b.[ind] <> 0) /\ (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0))
let bn_get_top_index_lemma #t #len b =
Loops.eq_repeat_gen0 len (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0;
let res =
Loops.repeati_inductive #size_nat len
(fun i priv ->
priv == Loops.repeat_gen i (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0 /\
priv < len /\ (priv > 0 ==> v b.[priv] <> 0) /\ (forall (k:nat{priv < k /\ k < i}). v b.[k] = 0))
(fun i priv ->
Loops.unfold_repeat_gen (i + 1) (bn_get_top_index_t len) (bn_get_top_index_f #t #len b) 0 i;
let mask = eq_mask b.[i] (zeros t SEC) in
eq_mask_lemma b.[i] (zeros t SEC);
assert (if v mask = 0 then v b.[i] <> 0 else v b.[i] = 0);
let res = if v mask = 0 then i else priv in
res) 0 in
()
val bn_get_top_index_eval_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len -> ind:nat -> Lemma
(requires
ind < len /\ (ind > 0 ==> v b.[ind] <> 0) /\ (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0))
(ensures
bn_v b == bn_v (slice b 0 ind) + pow2 (bits t * ind) * v b.[ind])
let bn_get_top_index_eval_lemma #t #len b ind =
let pbits = bits t in
assert (forall (k:nat{ind < k /\ k < len}). v b.[k] = 0);
bn_eval_split_i b (ind + 1);
assert (bn_v b == bn_v (slice b 0 (ind + 1)) + pow2 (pbits * (ind + 1)) * bn_v (slice b (ind + 1) len));
eq_intro (slice b (ind + 1) len) (create (len - ind - 1) (uint #t 0));
bn_eval_zeroes #t (len - ind - 1) (len - ind - 1);
assert (bn_v b == bn_v (slice b 0 (ind + 1)));
bn_eval_split_i (slice b 0 (ind + 1)) ind;
assert (bn_v b == bn_v (slice b 0 ind) + pow2 (pbits * ind) * bn_v (slice b ind (ind + 1)));
bn_eval1 (slice b ind (ind + 1));
assert (bn_v b == bn_v (slice b 0 ind) + pow2 (pbits * ind) * v b.[ind])
val bn_low_bound_bits:
#t:limb_t
-> #len:size_pos{bits t * len <= max_size_t}
-> b:lbignum t len ->
res:size_nat{res / bits t < len}
let bn_low_bound_bits #t #len b =
bits t * bn_get_top_index b
val bn_low_bound_bits_lemma: #t:limb_t -> #len:size_pos -> b:lbignum t len -> Lemma
(requires 1 < bn_v b /\ bits t * len <= max_size_t /\ bn_v b % 2 = 1)
(ensures pow2 (bn_low_bound_bits b) < bn_v b)
let bn_low_bound_bits_lemma #t #len b =
let ind = bn_get_top_index #t #len b in
bn_get_top_index_lemma #t #len b;
bn_get_top_index_eval_lemma #t #len b ind;
assert (pow2 (bn_low_bound_bits b) <= bn_v b);
if ind = 0 then
assert_norm (pow2 0 = 1)
else
Math.Lemmas.pow2_multiplication_modulo_lemma_1 1 1 (bn_low_bound_bits b)
val bn_get_bits_limb:
#t:limb_t
-> #nLen:size_nat
-> n:lbignum t nLen
-> ind:size_nat{ind / bits t < nLen} ->
limb t
let bn_get_bits_limb #t #nLen n ind =
let i = ind / bits t in
let j = ind % bits t in
let p1 = n.[i] >>. size j in
let p2 = if i + 1 < nLen && 0 < j then p1 |. (n.[i + 1] <<. (size (bits t - j))) else p1 in
p2
val bn_get_bits_limb_aux_lemma:
#t:limb_t
-> #nLen:size_nat
-> n:lbignum t nLen
-> ind:size_nat{ind / bits t < nLen} ->
Lemma (
let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let p1 = n.[i] >>. size j in
bn_v n / pow2 ind % pow2 pbits == bn_v n / pow2 ((i + 1) * pbits) % pow2 pbits * pow2 (pbits - j) % pow2 pbits + v p1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.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.Bignum.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "BB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
n: Hacl.Spec.Bignum.Definitions.lbignum t nLen ->
ind: Lib.IntTypes.size_nat{ind / Lib.IntTypes.bits t < nLen}
-> FStar.Pervasives.Lemma
(ensures
(let pbits = Lib.IntTypes.bits t in
let i = ind / pbits in
let j = ind % pbits in
let p1 = n.[ i ] >>. Lib.IntTypes.size j in
Hacl.Spec.Bignum.Definitions.bn_v n / Prims.pow2 ind % Prims.pow2 pbits ==
(Hacl.Spec.Bignum.Definitions.bn_v n / Prims.pow2 ((i + 1) * pbits) % Prims.pow2 pbits) *
Prims.pow2 (pbits - j) %
Prims.pow2 pbits +
Lib.IntTypes.v p1)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Division",
"Lib.IntTypes.bits",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Modulus",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.pow2",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.op_Subtraction",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"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_modulo_modulo_lemma_1",
"Hacl.Spec.Bignum.Lib.bn_get_ith_bit_aux_lemma",
"FStar.Math.Lemmas.pow2_modulo_division_lemma_1",
"FStar.Math.Lemmas.division_multiplication_lemma",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2",
"FStar.Math.Lemmas.distributivity_add_left",
"FStar.Math.Lemmas.lemma_mod_mul_distr_l",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Greater_Greater_Dot",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Bignum.Definitions.limb",
"Lib.IntTypes.size"
] | [] | false | false | true | false | false | let bn_get_bits_limb_aux_lemma #t #nLen n ind =
| let pbits = bits t in
let i = ind / pbits in
let j = ind % pbits in
let p1 = n.[ i ] >>. size j in
let res = bn_v n / pow2 ind % pow2 pbits in
calc ( == ) {
bn_v n / pow2 ind % pow2 pbits;
( == ) { Math.Lemmas.euclidean_division_definition res (pow2 (pbits - j)) }
(res / pow2 (pbits - j)) * pow2 (pbits - j) + res % pow2 (pbits - j);
( == ) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v n / pow2 ind) (pbits - j) pbits }
(res / pow2 (pbits - j)) * pow2 (pbits - j) + bn_v n / pow2 ind % pow2 (pbits - j);
( == ) { bn_get_ith_bit_aux_lemma n ind }
(res / pow2 (pbits - j)) * pow2 (pbits - j) + v p1;
( == ) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v n / pow2 ind) (pbits - j) pbits }
(bn_v n / pow2 ind / pow2 (pbits - j) % pow2 j) * pow2 (pbits - j) + v p1;
( == ) { Math.Lemmas.division_multiplication_lemma (bn_v n) (pow2 ind) (pow2 (pbits - j)) }
(bn_v n / (pow2 ind * pow2 (pbits - j)) % pow2 j) * pow2 (pbits - j) + v p1;
( == ) { Math.Lemmas.pow2_plus ind (pbits - j) }
(bn_v n / pow2 (ind + pbits - j) % pow2 j) * pow2 (pbits - j) + v p1;
( == ) { Math.Lemmas.euclidean_division_definition ind pbits }
(bn_v n / pow2 (i * pbits + pbits) % pow2 j) * pow2 (pbits - j) + v p1;
( == ) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (bn_v n / pow2 (i * pbits + pbits))
pbits
(pbits - j) }
(bn_v n / pow2 (i * pbits + pbits)) * pow2 (pbits - j) % pow2 pbits + v p1;
( == ) { Math.Lemmas.distributivity_add_left i 1 pbits }
(bn_v n / pow2 ((i + 1) * pbits)) * pow2 (pbits - j) % pow2 pbits + v p1;
( == ) { Math.Lemmas.lemma_mod_mul_distr_l (bn_v n / pow2 ((i + 1) * pbits))
(pow2 (pbits - j))
(pow2 pbits) }
(bn_v n / pow2 ((i + 1) * pbits) % pow2 pbits) * pow2 (pbits - j) % pow2 pbits + v p1;
} | false |
Spec.Blake2.fst | Spec.Blake2.list_iv_S | val list_iv_S:List.Tot.llist (uint_t U32 PUB) 8 | val list_iv_S:List.Tot.llist (uint_t U32 PUB) 8 | let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 103,
"start_col": 0,
"start_line": 97
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"] | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | FStar.List.Tot.Properties.llist (Lib.IntTypes.int_t Lib.IntTypes.U32 Lib.IntTypes.PUB) 8 | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.list",
"Prims.Cons",
"FStar.UInt32.__uint_to_t",
"Prims.Nil"
] | [] | false | false | false | false | false | let list_iv_S:List.Tot.llist (uint_t U32 PUB) 8 =
| [@@ inline_let ]let l =
[
0x6A09E667ul;
0xBB67AE85ul;
0x3C6EF372ul;
0xA54FF53Aul;
0x510E527Ful;
0x9B05688Cul;
0x1F83D9ABul;
0x5BE0CD19ul
]
in
assert_norm (List.Tot.length l == 8);
l | false |
Spec.Blake2.fst | Spec.Blake2.serialize_blake2_params | val serialize_blake2_params (#a: alg) (p: blake2_params a) : lseq (word_t a) 8 | val serialize_blake2_params (#a: alg) (p: blake2_params a) : lseq (word_t a) 8 | let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 41,
"end_line": 72,
"start_col": 0,
"start_line": 69
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p: Spec.Blake2.Definitions.blake2_params a -> Lib.Sequence.lseq (Spec.Blake2.Definitions.word_t a) 8 | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Spec.Blake2.Definitions.blake2_params",
"Spec.Blake2.serialize_blake2s_params",
"Spec.Blake2.serialize_blake2b_params",
"Lib.Sequence.lseq",
"Spec.Blake2.Definitions.word_t"
] | [] | false | false | false | false | false | let serialize_blake2_params (#a: alg) (p: blake2_params a) : lseq (word_t a) 8 =
| match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p | false |
Spec.Blake2.fst | Spec.Blake2.rTable | val rTable (a: alg) : rtable_t a | val rTable (a: alg) : rtable_t a | let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B) | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 93,
"start_col": 0,
"start_line": 90
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
] | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Spec.Blake2.Definitions.alg -> Spec.Blake2.Definitions.rtable_t a | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Lib.Sequence.of_list",
"Lib.IntTypes.rotval",
"Lib.IntTypes.U32",
"Spec.Blake2.rTable_list_S",
"Lib.IntTypes.U64",
"Spec.Blake2.rTable_list_B",
"Spec.Blake2.Definitions.rtable_t"
] | [] | false | false | false | false | false | let rTable (a: alg) : rtable_t a =
| match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B) | false |
Spec.Blake2.fst | Spec.Blake2.list_iv_B | val list_iv_B:List.Tot.llist (uint_t U64 PUB) 8 | val list_iv_B:List.Tot.llist (uint_t U64 PUB) 8 | let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 115,
"start_col": 0,
"start_line": 107
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"] | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | FStar.List.Tot.Properties.llist (Lib.IntTypes.int_t Lib.IntTypes.U64 Lib.IntTypes.PUB) 8 | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.PUB",
"Prims.list",
"Prims.Cons",
"FStar.UInt64.__uint_to_t",
"Prims.Nil"
] | [] | false | false | false | false | false | let list_iv_B:List.Tot.llist (uint_t U64 PUB) 8 =
| [@@ inline_let ]let l =
[
0x6A09E667F3BCC908uL;
0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL;
0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL;
0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL;
0x5BE0CD19137E2179uL
]
in
assert_norm (List.Tot.length l == 8);
l | false |
Spec.Blake2.fst | Spec.Blake2.blake2_compress | val blake2_compress:
a:alg
-> s_iv:state a
-> m:block_s a
-> offset:limb_t a
-> flag:bool ->
Tot (state a) | val blake2_compress:
a:alg
-> s_iv:state a
-> m:block_s a
-> offset:limb_t a
-> flag:bool ->
Tot (state a) | let blake2_compress a s_iv m offset flag =
let m_w = blake2_compress0 a m in
let wv = blake2_compress1 a s_iv offset flag in
let wv = blake2_compress2 a wv m_w in
let s_iv = blake2_compress3 a wv s_iv in
s_iv | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 6,
"end_line": 298,
"start_col": 0,
"start_line": 293
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B
inline_for_extraction
let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B
[@"opaque_to_smt"]
let list_sigma: list_sigma_t =
[@inline_let]
let l : list sigma_elt_t = [
size 0; size 1; size 2; size 3; size 4; size 5; size 6; size 7;
size 8; size 9; size 10; size 11; size 12; size 13; size 14; size 15;
size 14; size 10; size 4; size 8; size 9; size 15; size 13; size 6;
size 1; size 12; size 0; size 2; size 11; size 7; size 5; size 3;
size 11; size 8; size 12; size 0; size 5; size 2; size 15; size 13;
size 10; size 14; size 3; size 6; size 7; size 1; size 9; size 4;
size 7; size 9; size 3; size 1; size 13; size 12; size 11; size 14;
size 2; size 6; size 5; size 10; size 4; size 0; size 15; size 8;
size 9; size 0; size 5; size 7; size 2; size 4; size 10; size 15;
size 14; size 1; size 11; size 12; size 6; size 8; size 3; size 13;
size 2; size 12; size 6; size 10; size 0; size 11; size 8; size 3;
size 4; size 13; size 7; size 5; size 15; size 14; size 1; size 9;
size 12; size 5; size 1; size 15; size 14; size 13; size 4; size 10;
size 0; size 7; size 6; size 3; size 9; size 2; size 8; size 11;
size 13; size 11; size 7; size 14; size 12; size 1; size 3; size 9;
size 5; size 0; size 15; size 4; size 8; size 6; size 2; size 10;
size 6; size 15; size 14; size 9; size 11; size 3; size 0; size 8;
size 12; size 2; size 13; size 7; size 1; size 4; size 10; size 5;
size 10; size 2; size 8; size 4; size 7; size 6; size 1; size 5;
size 15; size 11; size 9; size 14; size 3; size 12; size 13; size 0
] in
assert_norm(List.Tot.length l == 160);
l
inline_for_extraction
let sigmaTable:lseq sigma_elt_t size_sigmaTable =
assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma
(* Functions *)
let g1 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (r:rotval (wt a)) : Tot (state a) =
wv.[i] <- (wv.[i] ^| wv.[j]) >>>| r
let g2 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (x:row a) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j] +| x)
let g2z (a:alg) (wv:state a) (i:row_idx) (j:row_idx) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j])
val blake2_mixing:
a:alg
-> ws:state a
-> row a
-> row a ->
Tot (state a)
let blake2_mixing al wv x y =
let a = 0 in
let b = 1 in
let c = 2 in
let d = 3 in
let rt = rTable al in
let wv = g2 al wv a b x in
let wv = g1 al wv d a rt.[0] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[1] in
let wv = g2 al wv a b y in
let wv = g1 al wv d a rt.[2] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[3] in
wv
let diag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 1 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 3 in
wv
let undiag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 3 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 1 in
wv
inline_for_extraction
let gather_row (#a:alg) (m:block_w a) (i0 i1 i2 i3:sigma_elt_t) : row a =
create_row m.[v i0] m.[v i1] m.[v i2] m.[v i3]
val gather_state: a:alg -> m:block_w a -> start:nat{start <= 144} -> state a
let gather_state a m start =
let x = gather_row m sigmaTable.[start] sigmaTable.[start+2] sigmaTable.[start+4] sigmaTable.[start+6] in
let y = gather_row m sigmaTable.[start+1] sigmaTable.[start+3] sigmaTable.[start+5] sigmaTable.[start+7] in
let z = gather_row m sigmaTable.[start+8] sigmaTable.[start+10] sigmaTable.[start+12] sigmaTable.[start+14] in
let w = gather_row m sigmaTable.[start+9] sigmaTable.[start+11] sigmaTable.[start+13] sigmaTable.[start+15] in
let l = [x;y;z;w] in
assert_norm (List.Tot.length l == 4);
createL l
val blake2_round:
a:alg
-> m:block_w a
-> i:size_nat
-> wv:state a
-> state a
let blake2_round a m i wv =
let start = (i%10) * 16 in
let m_s = gather_state a m start in
let wv = blake2_mixing a wv m_s.[0] m_s.[1] in
let wv = diag wv in
let wv = blake2_mixing a wv m_s.[2] m_s.[3] in
undiag wv
val blake2_compress0:
a:alg
-> m:block_s a
-> block_w a
let blake2_compress0 a m =
uints_from_bytes_le m
val blake2_compress1:
a:alg
-> s_iv:state a
-> offset:limb_t a
-> flag:bool ->
Tot (state a)
let blake2_compress1 a s_iv offset flag =
let wv : state a = s_iv in
let low_offset = limb_to_word a offset in
let high_offset = limb_to_word a (shift_right #(limb_inttype a) offset (size (bits (wt a)))) in
let m_12 = low_offset in
let m_13 = high_offset in
let m_14 = if flag then (ones (wt a) SEC) else zero a in
let m_15 = zero a in
let mask = create_row m_12 m_13 m_14 m_15 in
let wv = wv.[3] <- wv.[3] ^| mask in
wv
val blake2_compress2:
a:alg
-> wv:state a
-> m:block_w a ->
Tot (state a)
let blake2_compress2 a wv m = repeati (rounds a) (blake2_round a m) wv
val blake2_compress3:
a:alg
-> wv:state a
-> s_iv:state a ->
Tot (state a)
let blake2_compress3 a wv s =
let s = s.[0] <- (s.[0] ^| wv.[0]) ^| wv.[2] in
let s = s.[1] <- (s.[1] ^| wv.[1]) ^| wv.[3] in
s
val blake2_compress:
a:alg
-> s_iv:state a
-> m:block_s a
-> offset:limb_t a
-> flag:bool ->
Tot (state a) | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Blake2.Definitions.alg ->
s_iv: Spec.Blake2.Definitions.state a ->
m: Spec.Blake2.Definitions.block_s a ->
offset: Spec.Blake2.Definitions.limb_t a ->
flag: Prims.bool
-> Spec.Blake2.Definitions.state a | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Spec.Blake2.Definitions.state",
"Spec.Blake2.Definitions.block_s",
"Spec.Blake2.Definitions.limb_t",
"Prims.bool",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Spec.Blake2.Definitions.wt",
"Lib.IntTypes.SEC",
"Spec.Blake2.blake2_compress3",
"Spec.Blake2.blake2_compress2",
"Spec.Blake2.blake2_compress1",
"Spec.Blake2.Definitions.block_w",
"Spec.Blake2.blake2_compress0"
] | [] | false | false | false | false | false | let blake2_compress a s_iv m offset flag =
| let m_w = blake2_compress0 a m in
let wv = blake2_compress1 a s_iv offset flag in
let wv = blake2_compress2 a wv m_w in
let s_iv = blake2_compress3 a wv s_iv in
s_iv | false |
Spec.Blake2.fst | Spec.Blake2.g1 | val g1 (a: alg) (wv: state a) (i j: row_idx) (r: rotval (wt a)) : Tot (state a) | val g1 (a: alg) (wv: state a) (i j: row_idx) (r: rotval (wt a)) : Tot (state a) | let g1 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (r:rotval (wt a)) : Tot (state a) =
wv.[i] <- (wv.[i] ^| wv.[j]) >>>| r | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 37,
"end_line": 166,
"start_col": 0,
"start_line": 165
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B
inline_for_extraction
let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B
[@"opaque_to_smt"]
let list_sigma: list_sigma_t =
[@inline_let]
let l : list sigma_elt_t = [
size 0; size 1; size 2; size 3; size 4; size 5; size 6; size 7;
size 8; size 9; size 10; size 11; size 12; size 13; size 14; size 15;
size 14; size 10; size 4; size 8; size 9; size 15; size 13; size 6;
size 1; size 12; size 0; size 2; size 11; size 7; size 5; size 3;
size 11; size 8; size 12; size 0; size 5; size 2; size 15; size 13;
size 10; size 14; size 3; size 6; size 7; size 1; size 9; size 4;
size 7; size 9; size 3; size 1; size 13; size 12; size 11; size 14;
size 2; size 6; size 5; size 10; size 4; size 0; size 15; size 8;
size 9; size 0; size 5; size 7; size 2; size 4; size 10; size 15;
size 14; size 1; size 11; size 12; size 6; size 8; size 3; size 13;
size 2; size 12; size 6; size 10; size 0; size 11; size 8; size 3;
size 4; size 13; size 7; size 5; size 15; size 14; size 1; size 9;
size 12; size 5; size 1; size 15; size 14; size 13; size 4; size 10;
size 0; size 7; size 6; size 3; size 9; size 2; size 8; size 11;
size 13; size 11; size 7; size 14; size 12; size 1; size 3; size 9;
size 5; size 0; size 15; size 4; size 8; size 6; size 2; size 10;
size 6; size 15; size 14; size 9; size 11; size 3; size 0; size 8;
size 12; size 2; size 13; size 7; size 1; size 4; size 10; size 5;
size 10; size 2; size 8; size 4; size 7; size 6; size 1; size 5;
size 15; size 11; size 9; size 14; size 3; size 12; size 13; size 0
] in
assert_norm(List.Tot.length l == 160);
l
inline_for_extraction
let sigmaTable:lseq sigma_elt_t size_sigmaTable =
assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Blake2.Definitions.alg ->
wv: Spec.Blake2.Definitions.state a ->
i: Spec.Blake2.Definitions.row_idx ->
j: Spec.Blake2.Definitions.row_idx ->
r: Lib.IntTypes.rotval (Spec.Blake2.Definitions.wt a)
-> Spec.Blake2.Definitions.state a | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Spec.Blake2.Definitions.state",
"Spec.Blake2.Definitions.row_idx",
"Lib.IntTypes.rotval",
"Spec.Blake2.Definitions.wt",
"Lib.Sequence.op_String_Assignment",
"Spec.Blake2.Definitions.row",
"Spec.Blake2.Definitions.op_Greater_Greater_Greater_Bar",
"Spec.Blake2.Definitions.op_Hat_Bar",
"Lib.Sequence.op_String_Access"
] | [] | false | false | false | false | false | let g1 (a: alg) (wv: state a) (i j: row_idx) (r: rotval (wt a)) : Tot (state a) =
| wv.[ i ] <- (wv.[ i ] ^| wv.[ j ]) >>>| r | false |
Spec.Blake2.fst | Spec.Blake2.list_iv | val list_iv (a: alg) : List.Tot.llist (pub_word_t a) 8 | val list_iv (a: alg) : List.Tot.llist (pub_word_t a) 8 | let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 24,
"end_line": 122,
"start_col": 0,
"start_line": 119
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"] | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Spec.Blake2.Definitions.alg
-> FStar.List.Tot.Properties.llist (Spec.Blake2.Definitions.pub_word_t a) 8 | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Spec.Blake2.list_iv_S",
"Spec.Blake2.list_iv_B",
"FStar.List.Tot.Properties.llist",
"Spec.Blake2.Definitions.pub_word_t"
] | [] | false | false | false | false | false | let list_iv (a: alg) : List.Tot.llist (pub_word_t a) 8 =
| match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B | false |
Spec.Blake2.fst | Spec.Blake2.serialize_blake2b_params | val serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 | val serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 | let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 66,
"start_col": 0,
"start_line": 42
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p: Spec.Blake2.Definitions.blake2b_params -> Lib.Sequence.lseq Lib.IntTypes.uint64 8 | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.blake2b_params",
"Lib.Sequence.createL",
"Lib.IntTypes.uint64",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.Cons",
"Prims.Nil",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.op_String_Access",
"Lib.Sequence.lseq",
"Lib.ByteSequence.uints_from_bytes_le",
"Spec.Blake2.Definitions.__proj__Mkblake2b_params__item__personal",
"Spec.Blake2.Definitions.__proj__Mkblake2b_params__item__salt",
"Lib.IntTypes.range",
"Lib.IntTypes.v",
"Lib.IntTypes.u64",
"Lib.IntTypes.op_Hat_Dot",
"Lib.IntTypes.U8",
"Spec.Blake2.Definitions.__proj__Mkblake2b_params__item__node_depth",
"Lib.IntTypes.op_Less_Less_Dot",
"Spec.Blake2.Definitions.__proj__Mkblake2b_params__item__inner_length",
"Lib.IntTypes.size",
"Lib.IntTypes.U32",
"Spec.Blake2.Definitions.__proj__Mkblake2b_params__item__node_offset",
"Spec.Blake2.Definitions.__proj__Mkblake2b_params__item__xof_length",
"Spec.Blake2.Definitions.__proj__Mkblake2b_params__item__digest_length",
"Spec.Blake2.Definitions.__proj__Mkblake2b_params__item__key_length",
"Spec.Blake2.Definitions.__proj__Mkblake2b_params__item__fanout",
"Spec.Blake2.Definitions.__proj__Mkblake2b_params__item__depth",
"Spec.Blake2.Definitions.__proj__Mkblake2b_params__item__leaf_length"
] | [] | false | false | false | false | false | let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
| let s0 =
(u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^. (u64 (v p.leaf_length) <<. (size 32))
in
let s1 = (u64 (v p.node_offset)) ^. (u64 (v p.xof_length) <<. (size 32)) in
let s2 = (u64 (v p.node_depth)) ^. (u64 (v p.inner_length) <<. (size 8)) in
let s3 = u64 0 in
let salt_u64:lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[ 0 ] in
let s5 = salt_u64.[ 1 ] in
let personal_u64:lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[ 0 ] in
let s7 = personal_u64.[ 1 ] in
[@@ inline_let ]let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l | false |
Spec.Blake2.fst | Spec.Blake2.g2z | val g2z (a: alg) (wv: state a) (i j: row_idx) : Tot (state a) | val g2z (a: alg) (wv: state a) (i j: row_idx) : Tot (state a) | let g2z (a:alg) (wv:state a) (i:row_idx) (j:row_idx) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j]) | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 30,
"end_line": 172,
"start_col": 0,
"start_line": 171
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B
inline_for_extraction
let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B
[@"opaque_to_smt"]
let list_sigma: list_sigma_t =
[@inline_let]
let l : list sigma_elt_t = [
size 0; size 1; size 2; size 3; size 4; size 5; size 6; size 7;
size 8; size 9; size 10; size 11; size 12; size 13; size 14; size 15;
size 14; size 10; size 4; size 8; size 9; size 15; size 13; size 6;
size 1; size 12; size 0; size 2; size 11; size 7; size 5; size 3;
size 11; size 8; size 12; size 0; size 5; size 2; size 15; size 13;
size 10; size 14; size 3; size 6; size 7; size 1; size 9; size 4;
size 7; size 9; size 3; size 1; size 13; size 12; size 11; size 14;
size 2; size 6; size 5; size 10; size 4; size 0; size 15; size 8;
size 9; size 0; size 5; size 7; size 2; size 4; size 10; size 15;
size 14; size 1; size 11; size 12; size 6; size 8; size 3; size 13;
size 2; size 12; size 6; size 10; size 0; size 11; size 8; size 3;
size 4; size 13; size 7; size 5; size 15; size 14; size 1; size 9;
size 12; size 5; size 1; size 15; size 14; size 13; size 4; size 10;
size 0; size 7; size 6; size 3; size 9; size 2; size 8; size 11;
size 13; size 11; size 7; size 14; size 12; size 1; size 3; size 9;
size 5; size 0; size 15; size 4; size 8; size 6; size 2; size 10;
size 6; size 15; size 14; size 9; size 11; size 3; size 0; size 8;
size 12; size 2; size 13; size 7; size 1; size 4; size 10; size 5;
size 10; size 2; size 8; size 4; size 7; size 6; size 1; size 5;
size 15; size 11; size 9; size 14; size 3; size 12; size 13; size 0
] in
assert_norm(List.Tot.length l == 160);
l
inline_for_extraction
let sigmaTable:lseq sigma_elt_t size_sigmaTable =
assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma
(* Functions *)
let g1 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (r:rotval (wt a)) : Tot (state a) =
wv.[i] <- (wv.[i] ^| wv.[j]) >>>| r
let g2 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (x:row a) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j] +| x) | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Blake2.Definitions.alg ->
wv: Spec.Blake2.Definitions.state a ->
i: Spec.Blake2.Definitions.row_idx ->
j: Spec.Blake2.Definitions.row_idx
-> Spec.Blake2.Definitions.state a | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Spec.Blake2.Definitions.state",
"Spec.Blake2.Definitions.row_idx",
"Lib.Sequence.op_String_Assignment",
"Spec.Blake2.Definitions.row",
"Spec.Blake2.Definitions.op_Plus_Bar",
"Lib.Sequence.op_String_Access"
] | [] | false | false | false | false | false | let g2z (a: alg) (wv: state a) (i j: row_idx) : Tot (state a) =
| wv.[ i ] <- (wv.[ i ] +| wv.[ j ]) | false |
Spec.Blake2.fst | Spec.Blake2.sigmaTable | val sigmaTable:lseq sigma_elt_t size_sigmaTable | val sigmaTable:lseq sigma_elt_t size_sigmaTable | let sigmaTable:lseq sigma_elt_t size_sigmaTable =
assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 20,
"end_line": 162,
"start_col": 0,
"start_line": 160
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B
inline_for_extraction
let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B
[@"opaque_to_smt"]
let list_sigma: list_sigma_t =
[@inline_let]
let l : list sigma_elt_t = [
size 0; size 1; size 2; size 3; size 4; size 5; size 6; size 7;
size 8; size 9; size 10; size 11; size 12; size 13; size 14; size 15;
size 14; size 10; size 4; size 8; size 9; size 15; size 13; size 6;
size 1; size 12; size 0; size 2; size 11; size 7; size 5; size 3;
size 11; size 8; size 12; size 0; size 5; size 2; size 15; size 13;
size 10; size 14; size 3; size 6; size 7; size 1; size 9; size 4;
size 7; size 9; size 3; size 1; size 13; size 12; size 11; size 14;
size 2; size 6; size 5; size 10; size 4; size 0; size 15; size 8;
size 9; size 0; size 5; size 7; size 2; size 4; size 10; size 15;
size 14; size 1; size 11; size 12; size 6; size 8; size 3; size 13;
size 2; size 12; size 6; size 10; size 0; size 11; size 8; size 3;
size 4; size 13; size 7; size 5; size 15; size 14; size 1; size 9;
size 12; size 5; size 1; size 15; size 14; size 13; size 4; size 10;
size 0; size 7; size 6; size 3; size 9; size 2; size 8; size 11;
size 13; size 11; size 7; size 14; size 12; size 1; size 3; size 9;
size 5; size 0; size 15; size 4; size 8; size 6; size 2; size 10;
size 6; size 15; size 14; size 9; size 11; size 3; size 0; size 8;
size 12; size 2; size 13; size 7; size 1; size 4; size 10; size 5;
size 10; size 2; size 8; size 4; size 7; size 6; size 1; size 5;
size 15; size 11; size 9; size 14; size 3; size 12; size 13; size 0
] in
assert_norm(List.Tot.length l == 160);
l | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Lib.Sequence.lseq Spec.Blake2.Definitions.sigma_elt_t Spec.Blake2.Definitions.size_sigmaTable | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.of_list",
"Spec.Blake2.Definitions.sigma_elt_t",
"Spec.Blake2.list_sigma",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.nat",
"FStar.List.Tot.Base.length",
"Spec.Blake2.Definitions.size_sigmaTable"
] | [] | false | false | false | true | false | let sigmaTable:lseq sigma_elt_t size_sigmaTable =
| assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma | false |
Spec.Blake2.fst | Spec.Blake2.serialize_blake2s_params | val serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 | val serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 | let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 37,
"start_col": 0,
"start_line": 18
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p: Spec.Blake2.Definitions.blake2s_params -> Lib.Sequence.lseq Lib.IntTypes.uint32 8 | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.blake2s_params",
"Lib.Sequence.createL",
"Lib.IntTypes.uint32",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.SEC",
"Prims.Cons",
"Prims.Nil",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.op_String_Access",
"Lib.Sequence.lseq",
"Lib.ByteSequence.uints_from_bytes_le",
"Spec.Blake2.Definitions.__proj__Mkblake2s_params__item__personal",
"Spec.Blake2.Definitions.__proj__Mkblake2s_params__item__salt",
"Lib.IntTypes.op_Hat_Dot",
"Lib.IntTypes.u32",
"Lib.IntTypes.v",
"Lib.IntTypes.U16",
"Spec.Blake2.Definitions.__proj__Mkblake2s_params__item__xof_length",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.IntTypes.U8",
"Spec.Blake2.Definitions.__proj__Mkblake2s_params__item__node_depth",
"Lib.IntTypes.size",
"Spec.Blake2.Definitions.__proj__Mkblake2s_params__item__inner_length",
"Spec.Blake2.Definitions.__proj__Mkblake2s_params__item__node_offset",
"Spec.Blake2.Definitions.__proj__Mkblake2s_params__item__leaf_length",
"Spec.Blake2.Definitions.__proj__Mkblake2s_params__item__digest_length",
"Spec.Blake2.Definitions.__proj__Mkblake2s_params__item__key_length",
"Spec.Blake2.Definitions.__proj__Mkblake2s_params__item__fanout",
"Spec.Blake2.Definitions.__proj__Mkblake2s_params__item__depth"
] | [] | false | false | false | false | false | let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
| let s0 =
(u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^. (u32 (v p.depth) <<. (size 24))
in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 =
(u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^. (u32 (v p.inner_length) <<. (size 24))
in
let salt_u32:lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[ 0 ] in
let s5 = salt_u32.[ 1 ] in
let personal_u32:lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[ 0 ] in
let s7 = personal_u32.[ 1 ] in
[@@ inline_let ]let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l | false |
Spec.Blake2.fst | Spec.Blake2.ivTable | val ivTable (a: alg) : lseq (pub_word_t a) 8 | val ivTable (a: alg) : lseq (pub_word_t a) 8 | let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 32,
"end_line": 128,
"start_col": 0,
"start_line": 125
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Spec.Blake2.Definitions.alg -> Lib.Sequence.lseq (Spec.Blake2.Definitions.pub_word_t a) 8 | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Lib.Sequence.of_list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Spec.Blake2.list_iv_S",
"Lib.IntTypes.U64",
"Spec.Blake2.list_iv_B",
"Lib.Sequence.lseq",
"Spec.Blake2.Definitions.pub_word_t"
] | [] | false | false | false | false | false | let ivTable (a: alg) : lseq (pub_word_t a) 8 =
| match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B | false |
Hacl.Bignum256.fsti | Hacl.Bignum256.n_bytes | val n_bytes : FStar.UInt32.t | let n_bytes = n_limbs `FStar.UInt32.mul` 8ul | {
"file_name": "code/bignum/Hacl.Bignum256.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 44,
"end_line": 18,
"start_col": 0,
"start_line": 18
} | module Hacl.Bignum256
open FStar.Mul
module BN = Hacl.Bignum
module BS = Hacl.Bignum.SafeAPI
module MA = Hacl.Bignum.MontArithmetic
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let t_limbs: Hacl.Bignum.Definitions.limb_t = Lib.IntTypes.U64
inline_for_extraction noextract
let n_limbs: BN.meta_len t_limbs = 4ul | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Bignum.SafeAPI.fst.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum256.fsti"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | FStar.UInt32.t | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt32.mul",
"Hacl.Bignum256.n_limbs",
"FStar.UInt32.__uint_to_t"
] | [] | false | false | false | true | false | let n_bytes =
| n_limbs `FStar.UInt32.mul` 8ul | false |
|
Spec.Blake2.fst | Spec.Blake2.blake2_mixing | val blake2_mixing:
a:alg
-> ws:state a
-> row a
-> row a ->
Tot (state a) | val blake2_mixing:
a:alg
-> ws:state a
-> row a
-> row a ->
Tot (state a) | let blake2_mixing al wv x y =
let a = 0 in
let b = 1 in
let c = 2 in
let d = 3 in
let rt = rTable al in
let wv = g2 al wv a b x in
let wv = g1 al wv d a rt.[0] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[1] in
let wv = g2 al wv a b y in
let wv = g1 al wv d a rt.[2] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[3] in
wv | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 196,
"start_col": 0,
"start_line": 182
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B
inline_for_extraction
let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B
[@"opaque_to_smt"]
let list_sigma: list_sigma_t =
[@inline_let]
let l : list sigma_elt_t = [
size 0; size 1; size 2; size 3; size 4; size 5; size 6; size 7;
size 8; size 9; size 10; size 11; size 12; size 13; size 14; size 15;
size 14; size 10; size 4; size 8; size 9; size 15; size 13; size 6;
size 1; size 12; size 0; size 2; size 11; size 7; size 5; size 3;
size 11; size 8; size 12; size 0; size 5; size 2; size 15; size 13;
size 10; size 14; size 3; size 6; size 7; size 1; size 9; size 4;
size 7; size 9; size 3; size 1; size 13; size 12; size 11; size 14;
size 2; size 6; size 5; size 10; size 4; size 0; size 15; size 8;
size 9; size 0; size 5; size 7; size 2; size 4; size 10; size 15;
size 14; size 1; size 11; size 12; size 6; size 8; size 3; size 13;
size 2; size 12; size 6; size 10; size 0; size 11; size 8; size 3;
size 4; size 13; size 7; size 5; size 15; size 14; size 1; size 9;
size 12; size 5; size 1; size 15; size 14; size 13; size 4; size 10;
size 0; size 7; size 6; size 3; size 9; size 2; size 8; size 11;
size 13; size 11; size 7; size 14; size 12; size 1; size 3; size 9;
size 5; size 0; size 15; size 4; size 8; size 6; size 2; size 10;
size 6; size 15; size 14; size 9; size 11; size 3; size 0; size 8;
size 12; size 2; size 13; size 7; size 1; size 4; size 10; size 5;
size 10; size 2; size 8; size 4; size 7; size 6; size 1; size 5;
size 15; size 11; size 9; size 14; size 3; size 12; size 13; size 0
] in
assert_norm(List.Tot.length l == 160);
l
inline_for_extraction
let sigmaTable:lseq sigma_elt_t size_sigmaTable =
assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma
(* Functions *)
let g1 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (r:rotval (wt a)) : Tot (state a) =
wv.[i] <- (wv.[i] ^| wv.[j]) >>>| r
let g2 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (x:row a) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j] +| x)
let g2z (a:alg) (wv:state a) (i:row_idx) (j:row_idx) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j])
val blake2_mixing:
a:alg
-> ws:state a
-> row a
-> row a ->
Tot (state a) | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Blake2.Definitions.alg ->
ws: Spec.Blake2.Definitions.state a ->
x: Spec.Blake2.Definitions.row a ->
y: Spec.Blake2.Definitions.row a
-> Spec.Blake2.Definitions.state a | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Spec.Blake2.Definitions.state",
"Spec.Blake2.Definitions.row",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Spec.Blake2.Definitions.wt",
"Lib.IntTypes.SEC",
"Spec.Blake2.g1",
"Lib.Sequence.op_String_Access",
"Lib.IntTypes.rotval",
"Spec.Blake2.g2z",
"Spec.Blake2.g2",
"Spec.Blake2.rTable",
"Prims.int"
] | [] | false | false | false | false | false | let blake2_mixing al wv x y =
| let a = 0 in
let b = 1 in
let c = 2 in
let d = 3 in
let rt = rTable al in
let wv = g2 al wv a b x in
let wv = g1 al wv d a rt.[ 0 ] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[ 1 ] in
let wv = g2 al wv a b y in
let wv = g1 al wv d a rt.[ 2 ] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[ 3 ] in
wv | false |
Spec.Blake2.fst | Spec.Blake2.g2 | val g2 (a: alg) (wv: state a) (i j: row_idx) (x: row a) : Tot (state a) | val g2 (a: alg) (wv: state a) (i j: row_idx) (x: row a) : Tot (state a) | let g2 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (x:row a) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j] +| x) | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 35,
"end_line": 169,
"start_col": 0,
"start_line": 168
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B
inline_for_extraction
let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B
[@"opaque_to_smt"]
let list_sigma: list_sigma_t =
[@inline_let]
let l : list sigma_elt_t = [
size 0; size 1; size 2; size 3; size 4; size 5; size 6; size 7;
size 8; size 9; size 10; size 11; size 12; size 13; size 14; size 15;
size 14; size 10; size 4; size 8; size 9; size 15; size 13; size 6;
size 1; size 12; size 0; size 2; size 11; size 7; size 5; size 3;
size 11; size 8; size 12; size 0; size 5; size 2; size 15; size 13;
size 10; size 14; size 3; size 6; size 7; size 1; size 9; size 4;
size 7; size 9; size 3; size 1; size 13; size 12; size 11; size 14;
size 2; size 6; size 5; size 10; size 4; size 0; size 15; size 8;
size 9; size 0; size 5; size 7; size 2; size 4; size 10; size 15;
size 14; size 1; size 11; size 12; size 6; size 8; size 3; size 13;
size 2; size 12; size 6; size 10; size 0; size 11; size 8; size 3;
size 4; size 13; size 7; size 5; size 15; size 14; size 1; size 9;
size 12; size 5; size 1; size 15; size 14; size 13; size 4; size 10;
size 0; size 7; size 6; size 3; size 9; size 2; size 8; size 11;
size 13; size 11; size 7; size 14; size 12; size 1; size 3; size 9;
size 5; size 0; size 15; size 4; size 8; size 6; size 2; size 10;
size 6; size 15; size 14; size 9; size 11; size 3; size 0; size 8;
size 12; size 2; size 13; size 7; size 1; size 4; size 10; size 5;
size 10; size 2; size 8; size 4; size 7; size 6; size 1; size 5;
size 15; size 11; size 9; size 14; size 3; size 12; size 13; size 0
] in
assert_norm(List.Tot.length l == 160);
l
inline_for_extraction
let sigmaTable:lseq sigma_elt_t size_sigmaTable =
assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma
(* Functions *)
let g1 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (r:rotval (wt a)) : Tot (state a) =
wv.[i] <- (wv.[i] ^| wv.[j]) >>>| r | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Blake2.Definitions.alg ->
wv: Spec.Blake2.Definitions.state a ->
i: Spec.Blake2.Definitions.row_idx ->
j: Spec.Blake2.Definitions.row_idx ->
x: Spec.Blake2.Definitions.row a
-> Spec.Blake2.Definitions.state a | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Spec.Blake2.Definitions.state",
"Spec.Blake2.Definitions.row_idx",
"Spec.Blake2.Definitions.row",
"Lib.Sequence.op_String_Assignment",
"Spec.Blake2.Definitions.op_Plus_Bar",
"Lib.Sequence.op_String_Access"
] | [] | false | false | false | false | false | let g2 (a: alg) (wv: state a) (i j: row_idx) (x: row a) : Tot (state a) =
| wv.[ i ] <- (wv.[ i ] +| wv.[ j ] +| x) | false |
Spec.Blake2.fst | Spec.Blake2.blake2_compress0 | val blake2_compress0:
a:alg
-> m:block_s a
-> block_w a | val blake2_compress0:
a:alg
-> m:block_s a
-> block_w a | let blake2_compress0 a m =
uints_from_bytes_le m | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 23,
"end_line": 244,
"start_col": 0,
"start_line": 243
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B
inline_for_extraction
let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B
[@"opaque_to_smt"]
let list_sigma: list_sigma_t =
[@inline_let]
let l : list sigma_elt_t = [
size 0; size 1; size 2; size 3; size 4; size 5; size 6; size 7;
size 8; size 9; size 10; size 11; size 12; size 13; size 14; size 15;
size 14; size 10; size 4; size 8; size 9; size 15; size 13; size 6;
size 1; size 12; size 0; size 2; size 11; size 7; size 5; size 3;
size 11; size 8; size 12; size 0; size 5; size 2; size 15; size 13;
size 10; size 14; size 3; size 6; size 7; size 1; size 9; size 4;
size 7; size 9; size 3; size 1; size 13; size 12; size 11; size 14;
size 2; size 6; size 5; size 10; size 4; size 0; size 15; size 8;
size 9; size 0; size 5; size 7; size 2; size 4; size 10; size 15;
size 14; size 1; size 11; size 12; size 6; size 8; size 3; size 13;
size 2; size 12; size 6; size 10; size 0; size 11; size 8; size 3;
size 4; size 13; size 7; size 5; size 15; size 14; size 1; size 9;
size 12; size 5; size 1; size 15; size 14; size 13; size 4; size 10;
size 0; size 7; size 6; size 3; size 9; size 2; size 8; size 11;
size 13; size 11; size 7; size 14; size 12; size 1; size 3; size 9;
size 5; size 0; size 15; size 4; size 8; size 6; size 2; size 10;
size 6; size 15; size 14; size 9; size 11; size 3; size 0; size 8;
size 12; size 2; size 13; size 7; size 1; size 4; size 10; size 5;
size 10; size 2; size 8; size 4; size 7; size 6; size 1; size 5;
size 15; size 11; size 9; size 14; size 3; size 12; size 13; size 0
] in
assert_norm(List.Tot.length l == 160);
l
inline_for_extraction
let sigmaTable:lseq sigma_elt_t size_sigmaTable =
assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma
(* Functions *)
let g1 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (r:rotval (wt a)) : Tot (state a) =
wv.[i] <- (wv.[i] ^| wv.[j]) >>>| r
let g2 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (x:row a) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j] +| x)
let g2z (a:alg) (wv:state a) (i:row_idx) (j:row_idx) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j])
val blake2_mixing:
a:alg
-> ws:state a
-> row a
-> row a ->
Tot (state a)
let blake2_mixing al wv x y =
let a = 0 in
let b = 1 in
let c = 2 in
let d = 3 in
let rt = rTable al in
let wv = g2 al wv a b x in
let wv = g1 al wv d a rt.[0] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[1] in
let wv = g2 al wv a b y in
let wv = g1 al wv d a rt.[2] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[3] in
wv
let diag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 1 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 3 in
wv
let undiag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 3 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 1 in
wv
inline_for_extraction
let gather_row (#a:alg) (m:block_w a) (i0 i1 i2 i3:sigma_elt_t) : row a =
create_row m.[v i0] m.[v i1] m.[v i2] m.[v i3]
val gather_state: a:alg -> m:block_w a -> start:nat{start <= 144} -> state a
let gather_state a m start =
let x = gather_row m sigmaTable.[start] sigmaTable.[start+2] sigmaTable.[start+4] sigmaTable.[start+6] in
let y = gather_row m sigmaTable.[start+1] sigmaTable.[start+3] sigmaTable.[start+5] sigmaTable.[start+7] in
let z = gather_row m sigmaTable.[start+8] sigmaTable.[start+10] sigmaTable.[start+12] sigmaTable.[start+14] in
let w = gather_row m sigmaTable.[start+9] sigmaTable.[start+11] sigmaTable.[start+13] sigmaTable.[start+15] in
let l = [x;y;z;w] in
assert_norm (List.Tot.length l == 4);
createL l
val blake2_round:
a:alg
-> m:block_w a
-> i:size_nat
-> wv:state a
-> state a
let blake2_round a m i wv =
let start = (i%10) * 16 in
let m_s = gather_state a m start in
let wv = blake2_mixing a wv m_s.[0] m_s.[1] in
let wv = diag wv in
let wv = blake2_mixing a wv m_s.[2] m_s.[3] in
undiag wv
val blake2_compress0:
a:alg
-> m:block_s a | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Spec.Blake2.Definitions.alg -> m: Spec.Blake2.Definitions.block_s a
-> Spec.Blake2.Definitions.block_w a | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Spec.Blake2.Definitions.block_s",
"Lib.ByteSequence.uints_from_bytes_le",
"Spec.Blake2.Definitions.wt",
"Lib.IntTypes.SEC",
"Spec.Blake2.Definitions.size_block_w",
"Spec.Blake2.Definitions.block_w"
] | [] | false | false | false | false | false | let blake2_compress0 a m =
| uints_from_bytes_le m | false |
Spec.Blake2.fst | Spec.Blake2.gather_row | val gather_row (#a: alg) (m: block_w a) (i0 i1 i2 i3: sigma_elt_t) : row a | val gather_row (#a: alg) (m: block_w a) (i0 i1 i2 i3: sigma_elt_t) : row a | let gather_row (#a:alg) (m:block_w a) (i0 i1 i2 i3:sigma_elt_t) : row a =
create_row m.[v i0] m.[v i1] m.[v i2] m.[v i3] | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 48,
"end_line": 212,
"start_col": 0,
"start_line": 211
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B
inline_for_extraction
let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B
[@"opaque_to_smt"]
let list_sigma: list_sigma_t =
[@inline_let]
let l : list sigma_elt_t = [
size 0; size 1; size 2; size 3; size 4; size 5; size 6; size 7;
size 8; size 9; size 10; size 11; size 12; size 13; size 14; size 15;
size 14; size 10; size 4; size 8; size 9; size 15; size 13; size 6;
size 1; size 12; size 0; size 2; size 11; size 7; size 5; size 3;
size 11; size 8; size 12; size 0; size 5; size 2; size 15; size 13;
size 10; size 14; size 3; size 6; size 7; size 1; size 9; size 4;
size 7; size 9; size 3; size 1; size 13; size 12; size 11; size 14;
size 2; size 6; size 5; size 10; size 4; size 0; size 15; size 8;
size 9; size 0; size 5; size 7; size 2; size 4; size 10; size 15;
size 14; size 1; size 11; size 12; size 6; size 8; size 3; size 13;
size 2; size 12; size 6; size 10; size 0; size 11; size 8; size 3;
size 4; size 13; size 7; size 5; size 15; size 14; size 1; size 9;
size 12; size 5; size 1; size 15; size 14; size 13; size 4; size 10;
size 0; size 7; size 6; size 3; size 9; size 2; size 8; size 11;
size 13; size 11; size 7; size 14; size 12; size 1; size 3; size 9;
size 5; size 0; size 15; size 4; size 8; size 6; size 2; size 10;
size 6; size 15; size 14; size 9; size 11; size 3; size 0; size 8;
size 12; size 2; size 13; size 7; size 1; size 4; size 10; size 5;
size 10; size 2; size 8; size 4; size 7; size 6; size 1; size 5;
size 15; size 11; size 9; size 14; size 3; size 12; size 13; size 0
] in
assert_norm(List.Tot.length l == 160);
l
inline_for_extraction
let sigmaTable:lseq sigma_elt_t size_sigmaTable =
assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma
(* Functions *)
let g1 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (r:rotval (wt a)) : Tot (state a) =
wv.[i] <- (wv.[i] ^| wv.[j]) >>>| r
let g2 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (x:row a) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j] +| x)
let g2z (a:alg) (wv:state a) (i:row_idx) (j:row_idx) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j])
val blake2_mixing:
a:alg
-> ws:state a
-> row a
-> row a ->
Tot (state a)
let blake2_mixing al wv x y =
let a = 0 in
let b = 1 in
let c = 2 in
let d = 3 in
let rt = rTable al in
let wv = g2 al wv a b x in
let wv = g1 al wv d a rt.[0] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[1] in
let wv = g2 al wv a b y in
let wv = g1 al wv d a rt.[2] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[3] in
wv
let diag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 1 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 3 in
wv
let undiag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 3 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 1 in
wv | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
m: Spec.Blake2.Definitions.block_w a ->
i0: Spec.Blake2.Definitions.sigma_elt_t ->
i1: Spec.Blake2.Definitions.sigma_elt_t ->
i2: Spec.Blake2.Definitions.sigma_elt_t ->
i3: Spec.Blake2.Definitions.sigma_elt_t
-> Spec.Blake2.Definitions.row a | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Spec.Blake2.Definitions.block_w",
"Spec.Blake2.Definitions.sigma_elt_t",
"Spec.Blake2.Definitions.create_row",
"Lib.Sequence.op_String_Access",
"Spec.Blake2.Definitions.word_t",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Spec.Blake2.Definitions.row"
] | [] | false | false | false | false | false | let gather_row (#a: alg) (m: block_w a) (i0 i1 i2 i3: sigma_elt_t) : row a =
| create_row m.[ v i0 ] m.[ v i1 ] m.[ v i2 ] m.[ v i3 ] | false |
Spec.Blake2.fst | Spec.Blake2.rTable_list_B | val rTable_list_B:List.Tot.llist (rotval U64) 4 | val rTable_list_B:List.Tot.llist (rotval U64) 4 | let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
] | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 87,
"start_col": 0,
"start_line": 84
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"] | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | FStar.List.Tot.Properties.llist (Lib.IntTypes.rotval Lib.IntTypes.U64) 4 | Prims.Tot | [
"total"
] | [] | [
"Prims.Cons",
"Lib.IntTypes.rotval",
"Lib.IntTypes.U64",
"Lib.IntTypes.size",
"Prims.Nil"
] | [] | false | false | false | false | false | let rTable_list_B:List.Tot.llist (rotval U64) 4 =
| [size 32; size 24; size 16; size 63] | false |
Spec.Blake2.fst | Spec.Blake2.blake2_compress2 | val blake2_compress2:
a:alg
-> wv:state a
-> m:block_w a ->
Tot (state a) | val blake2_compress2:
a:alg
-> wv:state a
-> m:block_w a ->
Tot (state a) | let blake2_compress2 a wv m = repeati (rounds a) (blake2_round a m) wv | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 70,
"end_line": 272,
"start_col": 0,
"start_line": 272
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B
inline_for_extraction
let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B
[@"opaque_to_smt"]
let list_sigma: list_sigma_t =
[@inline_let]
let l : list sigma_elt_t = [
size 0; size 1; size 2; size 3; size 4; size 5; size 6; size 7;
size 8; size 9; size 10; size 11; size 12; size 13; size 14; size 15;
size 14; size 10; size 4; size 8; size 9; size 15; size 13; size 6;
size 1; size 12; size 0; size 2; size 11; size 7; size 5; size 3;
size 11; size 8; size 12; size 0; size 5; size 2; size 15; size 13;
size 10; size 14; size 3; size 6; size 7; size 1; size 9; size 4;
size 7; size 9; size 3; size 1; size 13; size 12; size 11; size 14;
size 2; size 6; size 5; size 10; size 4; size 0; size 15; size 8;
size 9; size 0; size 5; size 7; size 2; size 4; size 10; size 15;
size 14; size 1; size 11; size 12; size 6; size 8; size 3; size 13;
size 2; size 12; size 6; size 10; size 0; size 11; size 8; size 3;
size 4; size 13; size 7; size 5; size 15; size 14; size 1; size 9;
size 12; size 5; size 1; size 15; size 14; size 13; size 4; size 10;
size 0; size 7; size 6; size 3; size 9; size 2; size 8; size 11;
size 13; size 11; size 7; size 14; size 12; size 1; size 3; size 9;
size 5; size 0; size 15; size 4; size 8; size 6; size 2; size 10;
size 6; size 15; size 14; size 9; size 11; size 3; size 0; size 8;
size 12; size 2; size 13; size 7; size 1; size 4; size 10; size 5;
size 10; size 2; size 8; size 4; size 7; size 6; size 1; size 5;
size 15; size 11; size 9; size 14; size 3; size 12; size 13; size 0
] in
assert_norm(List.Tot.length l == 160);
l
inline_for_extraction
let sigmaTable:lseq sigma_elt_t size_sigmaTable =
assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma
(* Functions *)
let g1 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (r:rotval (wt a)) : Tot (state a) =
wv.[i] <- (wv.[i] ^| wv.[j]) >>>| r
let g2 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (x:row a) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j] +| x)
let g2z (a:alg) (wv:state a) (i:row_idx) (j:row_idx) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j])
val blake2_mixing:
a:alg
-> ws:state a
-> row a
-> row a ->
Tot (state a)
let blake2_mixing al wv x y =
let a = 0 in
let b = 1 in
let c = 2 in
let d = 3 in
let rt = rTable al in
let wv = g2 al wv a b x in
let wv = g1 al wv d a rt.[0] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[1] in
let wv = g2 al wv a b y in
let wv = g1 al wv d a rt.[2] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[3] in
wv
let diag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 1 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 3 in
wv
let undiag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 3 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 1 in
wv
inline_for_extraction
let gather_row (#a:alg) (m:block_w a) (i0 i1 i2 i3:sigma_elt_t) : row a =
create_row m.[v i0] m.[v i1] m.[v i2] m.[v i3]
val gather_state: a:alg -> m:block_w a -> start:nat{start <= 144} -> state a
let gather_state a m start =
let x = gather_row m sigmaTable.[start] sigmaTable.[start+2] sigmaTable.[start+4] sigmaTable.[start+6] in
let y = gather_row m sigmaTable.[start+1] sigmaTable.[start+3] sigmaTable.[start+5] sigmaTable.[start+7] in
let z = gather_row m sigmaTable.[start+8] sigmaTable.[start+10] sigmaTable.[start+12] sigmaTable.[start+14] in
let w = gather_row m sigmaTable.[start+9] sigmaTable.[start+11] sigmaTable.[start+13] sigmaTable.[start+15] in
let l = [x;y;z;w] in
assert_norm (List.Tot.length l == 4);
createL l
val blake2_round:
a:alg
-> m:block_w a
-> i:size_nat
-> wv:state a
-> state a
let blake2_round a m i wv =
let start = (i%10) * 16 in
let m_s = gather_state a m start in
let wv = blake2_mixing a wv m_s.[0] m_s.[1] in
let wv = diag wv in
let wv = blake2_mixing a wv m_s.[2] m_s.[3] in
undiag wv
val blake2_compress0:
a:alg
-> m:block_s a
-> block_w a
let blake2_compress0 a m =
uints_from_bytes_le m
val blake2_compress1:
a:alg
-> s_iv:state a
-> offset:limb_t a
-> flag:bool ->
Tot (state a)
let blake2_compress1 a s_iv offset flag =
let wv : state a = s_iv in
let low_offset = limb_to_word a offset in
let high_offset = limb_to_word a (shift_right #(limb_inttype a) offset (size (bits (wt a)))) in
let m_12 = low_offset in
let m_13 = high_offset in
let m_14 = if flag then (ones (wt a) SEC) else zero a in
let m_15 = zero a in
let mask = create_row m_12 m_13 m_14 m_15 in
let wv = wv.[3] <- wv.[3] ^| mask in
wv
val blake2_compress2:
a:alg
-> wv:state a
-> m:block_w a ->
Tot (state a) | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Blake2.Definitions.alg ->
wv: Spec.Blake2.Definitions.state a ->
m: Spec.Blake2.Definitions.block_w a
-> Spec.Blake2.Definitions.state a | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Spec.Blake2.Definitions.state",
"Spec.Blake2.Definitions.block_w",
"Lib.LoopCombinators.repeati",
"Spec.Blake2.Definitions.rounds",
"Spec.Blake2.blake2_round"
] | [] | false | false | false | false | false | let blake2_compress2 a wv m =
| repeati (rounds a) (blake2_round a m) wv | false |
Spec.Blake2.fst | Spec.Blake2.blake2_round | val blake2_round:
a:alg
-> m:block_w a
-> i:size_nat
-> wv:state a
-> state a | val blake2_round:
a:alg
-> m:block_w a
-> i:size_nat
-> wv:state a
-> state a | let blake2_round a m i wv =
let start = (i%10) * 16 in
let m_s = gather_state a m start in
let wv = blake2_mixing a wv m_s.[0] m_s.[1] in
let wv = diag wv in
let wv = blake2_mixing a wv m_s.[2] m_s.[3] in
undiag wv | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 237,
"start_col": 0,
"start_line": 231
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B
inline_for_extraction
let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B
[@"opaque_to_smt"]
let list_sigma: list_sigma_t =
[@inline_let]
let l : list sigma_elt_t = [
size 0; size 1; size 2; size 3; size 4; size 5; size 6; size 7;
size 8; size 9; size 10; size 11; size 12; size 13; size 14; size 15;
size 14; size 10; size 4; size 8; size 9; size 15; size 13; size 6;
size 1; size 12; size 0; size 2; size 11; size 7; size 5; size 3;
size 11; size 8; size 12; size 0; size 5; size 2; size 15; size 13;
size 10; size 14; size 3; size 6; size 7; size 1; size 9; size 4;
size 7; size 9; size 3; size 1; size 13; size 12; size 11; size 14;
size 2; size 6; size 5; size 10; size 4; size 0; size 15; size 8;
size 9; size 0; size 5; size 7; size 2; size 4; size 10; size 15;
size 14; size 1; size 11; size 12; size 6; size 8; size 3; size 13;
size 2; size 12; size 6; size 10; size 0; size 11; size 8; size 3;
size 4; size 13; size 7; size 5; size 15; size 14; size 1; size 9;
size 12; size 5; size 1; size 15; size 14; size 13; size 4; size 10;
size 0; size 7; size 6; size 3; size 9; size 2; size 8; size 11;
size 13; size 11; size 7; size 14; size 12; size 1; size 3; size 9;
size 5; size 0; size 15; size 4; size 8; size 6; size 2; size 10;
size 6; size 15; size 14; size 9; size 11; size 3; size 0; size 8;
size 12; size 2; size 13; size 7; size 1; size 4; size 10; size 5;
size 10; size 2; size 8; size 4; size 7; size 6; size 1; size 5;
size 15; size 11; size 9; size 14; size 3; size 12; size 13; size 0
] in
assert_norm(List.Tot.length l == 160);
l
inline_for_extraction
let sigmaTable:lseq sigma_elt_t size_sigmaTable =
assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma
(* Functions *)
let g1 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (r:rotval (wt a)) : Tot (state a) =
wv.[i] <- (wv.[i] ^| wv.[j]) >>>| r
let g2 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (x:row a) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j] +| x)
let g2z (a:alg) (wv:state a) (i:row_idx) (j:row_idx) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j])
val blake2_mixing:
a:alg
-> ws:state a
-> row a
-> row a ->
Tot (state a)
let blake2_mixing al wv x y =
let a = 0 in
let b = 1 in
let c = 2 in
let d = 3 in
let rt = rTable al in
let wv = g2 al wv a b x in
let wv = g1 al wv d a rt.[0] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[1] in
let wv = g2 al wv a b y in
let wv = g1 al wv d a rt.[2] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[3] in
wv
let diag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 1 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 3 in
wv
let undiag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 3 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 1 in
wv
inline_for_extraction
let gather_row (#a:alg) (m:block_w a) (i0 i1 i2 i3:sigma_elt_t) : row a =
create_row m.[v i0] m.[v i1] m.[v i2] m.[v i3]
val gather_state: a:alg -> m:block_w a -> start:nat{start <= 144} -> state a
let gather_state a m start =
let x = gather_row m sigmaTable.[start] sigmaTable.[start+2] sigmaTable.[start+4] sigmaTable.[start+6] in
let y = gather_row m sigmaTable.[start+1] sigmaTable.[start+3] sigmaTable.[start+5] sigmaTable.[start+7] in
let z = gather_row m sigmaTable.[start+8] sigmaTable.[start+10] sigmaTable.[start+12] sigmaTable.[start+14] in
let w = gather_row m sigmaTable.[start+9] sigmaTable.[start+11] sigmaTable.[start+13] sigmaTable.[start+15] in
let l = [x;y;z;w] in
assert_norm (List.Tot.length l == 4);
createL l
val blake2_round:
a:alg
-> m:block_w a
-> i:size_nat
-> wv:state a
-> state a | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Blake2.Definitions.alg ->
m: Spec.Blake2.Definitions.block_w a ->
i: Lib.IntTypes.size_nat ->
wv: Spec.Blake2.Definitions.state a
-> Spec.Blake2.Definitions.state a | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Spec.Blake2.Definitions.block_w",
"Lib.IntTypes.size_nat",
"Spec.Blake2.Definitions.state",
"Spec.Blake2.undiag",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Spec.Blake2.Definitions.wt",
"Lib.IntTypes.SEC",
"Spec.Blake2.blake2_mixing",
"Lib.Sequence.op_String_Access",
"Spec.Blake2.Definitions.row",
"Spec.Blake2.diag",
"Spec.Blake2.gather_state",
"Prims.int",
"FStar.Mul.op_Star",
"Prims.op_Modulus"
] | [] | false | false | false | false | false | let blake2_round a m i wv =
| let start = (i % 10) * 16 in
let m_s = gather_state a m start in
let wv = blake2_mixing a wv m_s.[ 0 ] m_s.[ 1 ] in
let wv = diag wv in
let wv = blake2_mixing a wv m_s.[ 2 ] m_s.[ 3 ] in
undiag wv | false |
Spec.Blake2.fst | Spec.Blake2.blake2_compress1 | val blake2_compress1:
a:alg
-> s_iv:state a
-> offset:limb_t a
-> flag:bool ->
Tot (state a) | val blake2_compress1:
a:alg
-> s_iv:state a
-> offset:limb_t a
-> flag:bool ->
Tot (state a) | let blake2_compress1 a s_iv offset flag =
let wv : state a = s_iv in
let low_offset = limb_to_word a offset in
let high_offset = limb_to_word a (shift_right #(limb_inttype a) offset (size (bits (wt a)))) in
let m_12 = low_offset in
let m_13 = high_offset in
let m_14 = if flag then (ones (wt a) SEC) else zero a in
let m_15 = zero a in
let mask = create_row m_12 m_13 m_14 m_15 in
let wv = wv.[3] <- wv.[3] ^| mask in
wv | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 263,
"start_col": 0,
"start_line": 253
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B
inline_for_extraction
let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B
[@"opaque_to_smt"]
let list_sigma: list_sigma_t =
[@inline_let]
let l : list sigma_elt_t = [
size 0; size 1; size 2; size 3; size 4; size 5; size 6; size 7;
size 8; size 9; size 10; size 11; size 12; size 13; size 14; size 15;
size 14; size 10; size 4; size 8; size 9; size 15; size 13; size 6;
size 1; size 12; size 0; size 2; size 11; size 7; size 5; size 3;
size 11; size 8; size 12; size 0; size 5; size 2; size 15; size 13;
size 10; size 14; size 3; size 6; size 7; size 1; size 9; size 4;
size 7; size 9; size 3; size 1; size 13; size 12; size 11; size 14;
size 2; size 6; size 5; size 10; size 4; size 0; size 15; size 8;
size 9; size 0; size 5; size 7; size 2; size 4; size 10; size 15;
size 14; size 1; size 11; size 12; size 6; size 8; size 3; size 13;
size 2; size 12; size 6; size 10; size 0; size 11; size 8; size 3;
size 4; size 13; size 7; size 5; size 15; size 14; size 1; size 9;
size 12; size 5; size 1; size 15; size 14; size 13; size 4; size 10;
size 0; size 7; size 6; size 3; size 9; size 2; size 8; size 11;
size 13; size 11; size 7; size 14; size 12; size 1; size 3; size 9;
size 5; size 0; size 15; size 4; size 8; size 6; size 2; size 10;
size 6; size 15; size 14; size 9; size 11; size 3; size 0; size 8;
size 12; size 2; size 13; size 7; size 1; size 4; size 10; size 5;
size 10; size 2; size 8; size 4; size 7; size 6; size 1; size 5;
size 15; size 11; size 9; size 14; size 3; size 12; size 13; size 0
] in
assert_norm(List.Tot.length l == 160);
l
inline_for_extraction
let sigmaTable:lseq sigma_elt_t size_sigmaTable =
assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma
(* Functions *)
let g1 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (r:rotval (wt a)) : Tot (state a) =
wv.[i] <- (wv.[i] ^| wv.[j]) >>>| r
let g2 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (x:row a) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j] +| x)
let g2z (a:alg) (wv:state a) (i:row_idx) (j:row_idx) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j])
val blake2_mixing:
a:alg
-> ws:state a
-> row a
-> row a ->
Tot (state a)
let blake2_mixing al wv x y =
let a = 0 in
let b = 1 in
let c = 2 in
let d = 3 in
let rt = rTable al in
let wv = g2 al wv a b x in
let wv = g1 al wv d a rt.[0] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[1] in
let wv = g2 al wv a b y in
let wv = g1 al wv d a rt.[2] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[3] in
wv
let diag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 1 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 3 in
wv
let undiag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 3 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 1 in
wv
inline_for_extraction
let gather_row (#a:alg) (m:block_w a) (i0 i1 i2 i3:sigma_elt_t) : row a =
create_row m.[v i0] m.[v i1] m.[v i2] m.[v i3]
val gather_state: a:alg -> m:block_w a -> start:nat{start <= 144} -> state a
let gather_state a m start =
let x = gather_row m sigmaTable.[start] sigmaTable.[start+2] sigmaTable.[start+4] sigmaTable.[start+6] in
let y = gather_row m sigmaTable.[start+1] sigmaTable.[start+3] sigmaTable.[start+5] sigmaTable.[start+7] in
let z = gather_row m sigmaTable.[start+8] sigmaTable.[start+10] sigmaTable.[start+12] sigmaTable.[start+14] in
let w = gather_row m sigmaTable.[start+9] sigmaTable.[start+11] sigmaTable.[start+13] sigmaTable.[start+15] in
let l = [x;y;z;w] in
assert_norm (List.Tot.length l == 4);
createL l
val blake2_round:
a:alg
-> m:block_w a
-> i:size_nat
-> wv:state a
-> state a
let blake2_round a m i wv =
let start = (i%10) * 16 in
let m_s = gather_state a m start in
let wv = blake2_mixing a wv m_s.[0] m_s.[1] in
let wv = diag wv in
let wv = blake2_mixing a wv m_s.[2] m_s.[3] in
undiag wv
val blake2_compress0:
a:alg
-> m:block_s a
-> block_w a
let blake2_compress0 a m =
uints_from_bytes_le m
val blake2_compress1:
a:alg
-> s_iv:state a
-> offset:limb_t a
-> flag:bool ->
Tot (state a) | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Blake2.Definitions.alg ->
s_iv: Spec.Blake2.Definitions.state a ->
offset: Spec.Blake2.Definitions.limb_t a ->
flag: Prims.bool
-> Spec.Blake2.Definitions.state a | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Spec.Blake2.Definitions.state",
"Spec.Blake2.Definitions.limb_t",
"Prims.bool",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Spec.Blake2.Definitions.wt",
"Lib.IntTypes.SEC",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.upd",
"Spec.Blake2.Definitions.op_Hat_Bar",
"Lib.Sequence.index",
"Prims.l_Forall",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.l_imp",
"Prims.op_LessThan",
"Prims.op_disEquality",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.op_String_Assignment",
"Lib.Sequence.op_String_Access",
"Spec.Blake2.Definitions.create_row",
"Spec.Blake2.Definitions.zero",
"Lib.IntTypes.ones",
"Spec.Blake2.Definitions.word_t",
"Spec.Blake2.Definitions.limb_to_word",
"Lib.IntTypes.shift_right",
"Spec.Blake2.Definitions.limb_inttype",
"Lib.IntTypes.size",
"Lib.IntTypes.bits"
] | [] | false | false | false | false | false | let blake2_compress1 a s_iv offset flag =
| let wv:state a = s_iv in
let low_offset = limb_to_word a offset in
let high_offset = limb_to_word a (shift_right #(limb_inttype a) offset (size (bits (wt a)))) in
let m_12 = low_offset in
let m_13 = high_offset in
let m_14 = if flag then (ones (wt a) SEC) else zero a in
let m_15 = zero a in
let mask = create_row m_12 m_13 m_14 m_15 in
let wv = wv.[ 3 ] <- wv.[ 3 ] ^| mask in
wv | false |
Spec.Blake2.fst | Spec.Blake2.diag | val diag (#a: alg) (wv: state a) : state a | val diag (#a: alg) (wv: state a) : state a | let diag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 1 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 3 in
wv | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 202,
"start_col": 0,
"start_line": 198
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B
inline_for_extraction
let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B
[@"opaque_to_smt"]
let list_sigma: list_sigma_t =
[@inline_let]
let l : list sigma_elt_t = [
size 0; size 1; size 2; size 3; size 4; size 5; size 6; size 7;
size 8; size 9; size 10; size 11; size 12; size 13; size 14; size 15;
size 14; size 10; size 4; size 8; size 9; size 15; size 13; size 6;
size 1; size 12; size 0; size 2; size 11; size 7; size 5; size 3;
size 11; size 8; size 12; size 0; size 5; size 2; size 15; size 13;
size 10; size 14; size 3; size 6; size 7; size 1; size 9; size 4;
size 7; size 9; size 3; size 1; size 13; size 12; size 11; size 14;
size 2; size 6; size 5; size 10; size 4; size 0; size 15; size 8;
size 9; size 0; size 5; size 7; size 2; size 4; size 10; size 15;
size 14; size 1; size 11; size 12; size 6; size 8; size 3; size 13;
size 2; size 12; size 6; size 10; size 0; size 11; size 8; size 3;
size 4; size 13; size 7; size 5; size 15; size 14; size 1; size 9;
size 12; size 5; size 1; size 15; size 14; size 13; size 4; size 10;
size 0; size 7; size 6; size 3; size 9; size 2; size 8; size 11;
size 13; size 11; size 7; size 14; size 12; size 1; size 3; size 9;
size 5; size 0; size 15; size 4; size 8; size 6; size 2; size 10;
size 6; size 15; size 14; size 9; size 11; size 3; size 0; size 8;
size 12; size 2; size 13; size 7; size 1; size 4; size 10; size 5;
size 10; size 2; size 8; size 4; size 7; size 6; size 1; size 5;
size 15; size 11; size 9; size 14; size 3; size 12; size 13; size 0
] in
assert_norm(List.Tot.length l == 160);
l
inline_for_extraction
let sigmaTable:lseq sigma_elt_t size_sigmaTable =
assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma
(* Functions *)
let g1 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (r:rotval (wt a)) : Tot (state a) =
wv.[i] <- (wv.[i] ^| wv.[j]) >>>| r
let g2 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (x:row a) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j] +| x)
let g2z (a:alg) (wv:state a) (i:row_idx) (j:row_idx) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j])
val blake2_mixing:
a:alg
-> ws:state a
-> row a
-> row a ->
Tot (state a)
let blake2_mixing al wv x y =
let a = 0 in
let b = 1 in
let c = 2 in
let d = 3 in
let rt = rTable al in
let wv = g2 al wv a b x in
let wv = g1 al wv d a rt.[0] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[1] in
let wv = g2 al wv a b y in
let wv = g1 al wv d a rt.[2] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[3] in
wv | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | wv: Spec.Blake2.Definitions.state a -> Spec.Blake2.Definitions.state a | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Spec.Blake2.Definitions.state",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Spec.Blake2.Definitions.wt",
"Lib.IntTypes.SEC",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.upd",
"Spec.Blake2.Definitions.rotr",
"Lib.Sequence.index",
"Prims.l_Forall",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.l_imp",
"Prims.op_LessThan",
"Prims.op_disEquality",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.op_String_Assignment",
"Spec.Blake2.Definitions.row",
"Lib.Sequence.op_String_Access"
] | [] | false | false | false | false | false | let diag (#a: alg) (wv: state a) : state a =
| let wv = wv.[ 1 ] <- rotr wv.[ 1 ] 1 in
let wv = wv.[ 2 ] <- rotr wv.[ 2 ] 2 in
let wv = wv.[ 3 ] <- rotr wv.[ 3 ] 3 in
wv | false |
Spec.Blake2.fst | Spec.Blake2.rTable_list_S | val rTable_list_S:List.Tot.llist (rotval U32) 4 | val rTable_list_S:List.Tot.llist (rotval U32) 4 | let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
] | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 80,
"start_col": 0,
"start_line": 77
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"] | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | FStar.List.Tot.Properties.llist (Lib.IntTypes.rotval Lib.IntTypes.U32) 4 | Prims.Tot | [
"total"
] | [] | [
"Prims.Cons",
"Lib.IntTypes.rotval",
"Lib.IntTypes.U32",
"Lib.IntTypes.size",
"Prims.Nil"
] | [] | false | false | false | false | false | let rTable_list_S:List.Tot.llist (rotval U32) 4 =
| [size 16; size 12; size 8; size 7] | false |
Hacl.Bignum256.fsti | Hacl.Bignum256.n_limbs | val n_limbs:BN.meta_len t_limbs | val n_limbs:BN.meta_len t_limbs | let n_limbs: BN.meta_len t_limbs = 4ul | {
"file_name": "code/bignum/Hacl.Bignum256.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 15,
"start_col": 0,
"start_line": 15
} | module Hacl.Bignum256
open FStar.Mul
module BN = Hacl.Bignum
module BS = Hacl.Bignum.SafeAPI
module MA = Hacl.Bignum.MontArithmetic
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let t_limbs: Hacl.Bignum.Definitions.limb_t = Lib.IntTypes.U64 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Bignum.SafeAPI.fst.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum256.fsti"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Hacl.Bignum.meta_len Hacl.Bignum256.t_limbs | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt32.__uint_to_t"
] | [] | false | false | false | true | false | let n_limbs:BN.meta_len t_limbs =
| 4ul | false |
Spec.Blake2.fst | Spec.Blake2.blake2_update_block | val blake2_update_block:
a:alg
-> flag:bool
-> totlen:nat{totlen <= max_limb a}
-> d:block_s a
-> s_iv:state a ->
Tot (state a) | val blake2_update_block:
a:alg
-> flag:bool
-> totlen:nat{totlen <= max_limb a}
-> d:block_s a
-> s_iv:state a ->
Tot (state a) | let blake2_update_block a flag totlen d s =
let offset = nat_to_limb a totlen in
blake2_compress a s d offset flag | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 35,
"end_line": 311,
"start_col": 0,
"start_line": 309
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B
inline_for_extraction
let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B
[@"opaque_to_smt"]
let list_sigma: list_sigma_t =
[@inline_let]
let l : list sigma_elt_t = [
size 0; size 1; size 2; size 3; size 4; size 5; size 6; size 7;
size 8; size 9; size 10; size 11; size 12; size 13; size 14; size 15;
size 14; size 10; size 4; size 8; size 9; size 15; size 13; size 6;
size 1; size 12; size 0; size 2; size 11; size 7; size 5; size 3;
size 11; size 8; size 12; size 0; size 5; size 2; size 15; size 13;
size 10; size 14; size 3; size 6; size 7; size 1; size 9; size 4;
size 7; size 9; size 3; size 1; size 13; size 12; size 11; size 14;
size 2; size 6; size 5; size 10; size 4; size 0; size 15; size 8;
size 9; size 0; size 5; size 7; size 2; size 4; size 10; size 15;
size 14; size 1; size 11; size 12; size 6; size 8; size 3; size 13;
size 2; size 12; size 6; size 10; size 0; size 11; size 8; size 3;
size 4; size 13; size 7; size 5; size 15; size 14; size 1; size 9;
size 12; size 5; size 1; size 15; size 14; size 13; size 4; size 10;
size 0; size 7; size 6; size 3; size 9; size 2; size 8; size 11;
size 13; size 11; size 7; size 14; size 12; size 1; size 3; size 9;
size 5; size 0; size 15; size 4; size 8; size 6; size 2; size 10;
size 6; size 15; size 14; size 9; size 11; size 3; size 0; size 8;
size 12; size 2; size 13; size 7; size 1; size 4; size 10; size 5;
size 10; size 2; size 8; size 4; size 7; size 6; size 1; size 5;
size 15; size 11; size 9; size 14; size 3; size 12; size 13; size 0
] in
assert_norm(List.Tot.length l == 160);
l
inline_for_extraction
let sigmaTable:lseq sigma_elt_t size_sigmaTable =
assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma
(* Functions *)
let g1 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (r:rotval (wt a)) : Tot (state a) =
wv.[i] <- (wv.[i] ^| wv.[j]) >>>| r
let g2 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (x:row a) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j] +| x)
let g2z (a:alg) (wv:state a) (i:row_idx) (j:row_idx) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j])
val blake2_mixing:
a:alg
-> ws:state a
-> row a
-> row a ->
Tot (state a)
let blake2_mixing al wv x y =
let a = 0 in
let b = 1 in
let c = 2 in
let d = 3 in
let rt = rTable al in
let wv = g2 al wv a b x in
let wv = g1 al wv d a rt.[0] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[1] in
let wv = g2 al wv a b y in
let wv = g1 al wv d a rt.[2] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[3] in
wv
let diag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 1 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 3 in
wv
let undiag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 3 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 1 in
wv
inline_for_extraction
let gather_row (#a:alg) (m:block_w a) (i0 i1 i2 i3:sigma_elt_t) : row a =
create_row m.[v i0] m.[v i1] m.[v i2] m.[v i3]
val gather_state: a:alg -> m:block_w a -> start:nat{start <= 144} -> state a
let gather_state a m start =
let x = gather_row m sigmaTable.[start] sigmaTable.[start+2] sigmaTable.[start+4] sigmaTable.[start+6] in
let y = gather_row m sigmaTable.[start+1] sigmaTable.[start+3] sigmaTable.[start+5] sigmaTable.[start+7] in
let z = gather_row m sigmaTable.[start+8] sigmaTable.[start+10] sigmaTable.[start+12] sigmaTable.[start+14] in
let w = gather_row m sigmaTable.[start+9] sigmaTable.[start+11] sigmaTable.[start+13] sigmaTable.[start+15] in
let l = [x;y;z;w] in
assert_norm (List.Tot.length l == 4);
createL l
val blake2_round:
a:alg
-> m:block_w a
-> i:size_nat
-> wv:state a
-> state a
let blake2_round a m i wv =
let start = (i%10) * 16 in
let m_s = gather_state a m start in
let wv = blake2_mixing a wv m_s.[0] m_s.[1] in
let wv = diag wv in
let wv = blake2_mixing a wv m_s.[2] m_s.[3] in
undiag wv
val blake2_compress0:
a:alg
-> m:block_s a
-> block_w a
let blake2_compress0 a m =
uints_from_bytes_le m
val blake2_compress1:
a:alg
-> s_iv:state a
-> offset:limb_t a
-> flag:bool ->
Tot (state a)
let blake2_compress1 a s_iv offset flag =
let wv : state a = s_iv in
let low_offset = limb_to_word a offset in
let high_offset = limb_to_word a (shift_right #(limb_inttype a) offset (size (bits (wt a)))) in
let m_12 = low_offset in
let m_13 = high_offset in
let m_14 = if flag then (ones (wt a) SEC) else zero a in
let m_15 = zero a in
let mask = create_row m_12 m_13 m_14 m_15 in
let wv = wv.[3] <- wv.[3] ^| mask in
wv
val blake2_compress2:
a:alg
-> wv:state a
-> m:block_w a ->
Tot (state a)
let blake2_compress2 a wv m = repeati (rounds a) (blake2_round a m) wv
val blake2_compress3:
a:alg
-> wv:state a
-> s_iv:state a ->
Tot (state a)
let blake2_compress3 a wv s =
let s = s.[0] <- (s.[0] ^| wv.[0]) ^| wv.[2] in
let s = s.[1] <- (s.[1] ^| wv.[1]) ^| wv.[3] in
s
val blake2_compress:
a:alg
-> s_iv:state a
-> m:block_s a
-> offset:limb_t a
-> flag:bool ->
Tot (state a)
let blake2_compress a s_iv m offset flag =
let m_w = blake2_compress0 a m in
let wv = blake2_compress1 a s_iv offset flag in
let wv = blake2_compress2 a wv m_w in
let s_iv = blake2_compress3 a wv s_iv in
s_iv
val blake2_update_block:
a:alg
-> flag:bool
-> totlen:nat{totlen <= max_limb a}
-> d:block_s a
-> s_iv:state a ->
Tot (state a) | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Blake2.Definitions.alg ->
flag: Prims.bool ->
totlen: Prims.nat{totlen <= Spec.Blake2.Definitions.max_limb a} ->
d: Spec.Blake2.Definitions.block_s a ->
s_iv: Spec.Blake2.Definitions.state a
-> Spec.Blake2.Definitions.state a | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Prims.bool",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Spec.Blake2.Definitions.max_limb",
"Spec.Blake2.Definitions.block_s",
"Spec.Blake2.Definitions.state",
"Spec.Blake2.blake2_compress",
"Spec.Blake2.Definitions.limb_t",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Spec.Blake2.Definitions.wt",
"Lib.IntTypes.U64",
"Lib.IntTypes.U128",
"Prims.l_and",
"Prims.op_GreaterThanOrEqual",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Spec.Blake2.Definitions.nat_to_limb"
] | [] | false | false | false | false | false | let blake2_update_block a flag totlen d s =
| let offset = nat_to_limb a totlen in
blake2_compress a s d offset flag | false |
Spec.Blake2.fst | Spec.Blake2.undiag | val undiag (#a: alg) (wv: state a) : state a | val undiag (#a: alg) (wv: state a) : state a | let undiag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 3 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 1 in
wv | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 208,
"start_col": 0,
"start_line": 204
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B
inline_for_extraction
let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B
[@"opaque_to_smt"]
let list_sigma: list_sigma_t =
[@inline_let]
let l : list sigma_elt_t = [
size 0; size 1; size 2; size 3; size 4; size 5; size 6; size 7;
size 8; size 9; size 10; size 11; size 12; size 13; size 14; size 15;
size 14; size 10; size 4; size 8; size 9; size 15; size 13; size 6;
size 1; size 12; size 0; size 2; size 11; size 7; size 5; size 3;
size 11; size 8; size 12; size 0; size 5; size 2; size 15; size 13;
size 10; size 14; size 3; size 6; size 7; size 1; size 9; size 4;
size 7; size 9; size 3; size 1; size 13; size 12; size 11; size 14;
size 2; size 6; size 5; size 10; size 4; size 0; size 15; size 8;
size 9; size 0; size 5; size 7; size 2; size 4; size 10; size 15;
size 14; size 1; size 11; size 12; size 6; size 8; size 3; size 13;
size 2; size 12; size 6; size 10; size 0; size 11; size 8; size 3;
size 4; size 13; size 7; size 5; size 15; size 14; size 1; size 9;
size 12; size 5; size 1; size 15; size 14; size 13; size 4; size 10;
size 0; size 7; size 6; size 3; size 9; size 2; size 8; size 11;
size 13; size 11; size 7; size 14; size 12; size 1; size 3; size 9;
size 5; size 0; size 15; size 4; size 8; size 6; size 2; size 10;
size 6; size 15; size 14; size 9; size 11; size 3; size 0; size 8;
size 12; size 2; size 13; size 7; size 1; size 4; size 10; size 5;
size 10; size 2; size 8; size 4; size 7; size 6; size 1; size 5;
size 15; size 11; size 9; size 14; size 3; size 12; size 13; size 0
] in
assert_norm(List.Tot.length l == 160);
l
inline_for_extraction
let sigmaTable:lseq sigma_elt_t size_sigmaTable =
assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma
(* Functions *)
let g1 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (r:rotval (wt a)) : Tot (state a) =
wv.[i] <- (wv.[i] ^| wv.[j]) >>>| r
let g2 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (x:row a) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j] +| x)
let g2z (a:alg) (wv:state a) (i:row_idx) (j:row_idx) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j])
val blake2_mixing:
a:alg
-> ws:state a
-> row a
-> row a ->
Tot (state a)
let blake2_mixing al wv x y =
let a = 0 in
let b = 1 in
let c = 2 in
let d = 3 in
let rt = rTable al in
let wv = g2 al wv a b x in
let wv = g1 al wv d a rt.[0] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[1] in
let wv = g2 al wv a b y in
let wv = g1 al wv d a rt.[2] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[3] in
wv
let diag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 1 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 3 in
wv | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | wv: Spec.Blake2.Definitions.state a -> Spec.Blake2.Definitions.state a | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Spec.Blake2.Definitions.state",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Spec.Blake2.Definitions.wt",
"Lib.IntTypes.SEC",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.upd",
"Spec.Blake2.Definitions.rotr",
"Lib.Sequence.index",
"Prims.l_Forall",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.l_imp",
"Prims.op_LessThan",
"Prims.op_disEquality",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.op_String_Assignment",
"Spec.Blake2.Definitions.row",
"Lib.Sequence.op_String_Access"
] | [] | false | false | false | false | false | let undiag (#a: alg) (wv: state a) : state a =
| let wv = wv.[ 1 ] <- rotr wv.[ 1 ] 3 in
let wv = wv.[ 2 ] <- rotr wv.[ 2 ] 2 in
let wv = wv.[ 3 ] <- rotr wv.[ 3 ] 1 in
wv | false |
Spec.Blake2.fst | Spec.Blake2.gather_state | val gather_state: a:alg -> m:block_w a -> start:nat{start <= 144} -> state a | val gather_state: a:alg -> m:block_w a -> start:nat{start <= 144} -> state a | let gather_state a m start =
let x = gather_row m sigmaTable.[start] sigmaTable.[start+2] sigmaTable.[start+4] sigmaTable.[start+6] in
let y = gather_row m sigmaTable.[start+1] sigmaTable.[start+3] sigmaTable.[start+5] sigmaTable.[start+7] in
let z = gather_row m sigmaTable.[start+8] sigmaTable.[start+10] sigmaTable.[start+12] sigmaTable.[start+14] in
let w = gather_row m sigmaTable.[start+9] sigmaTable.[start+11] sigmaTable.[start+13] sigmaTable.[start+15] in
let l = [x;y;z;w] in
assert_norm (List.Tot.length l == 4);
createL l | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 222,
"start_col": 0,
"start_line": 215
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B
inline_for_extraction
let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B
[@"opaque_to_smt"]
let list_sigma: list_sigma_t =
[@inline_let]
let l : list sigma_elt_t = [
size 0; size 1; size 2; size 3; size 4; size 5; size 6; size 7;
size 8; size 9; size 10; size 11; size 12; size 13; size 14; size 15;
size 14; size 10; size 4; size 8; size 9; size 15; size 13; size 6;
size 1; size 12; size 0; size 2; size 11; size 7; size 5; size 3;
size 11; size 8; size 12; size 0; size 5; size 2; size 15; size 13;
size 10; size 14; size 3; size 6; size 7; size 1; size 9; size 4;
size 7; size 9; size 3; size 1; size 13; size 12; size 11; size 14;
size 2; size 6; size 5; size 10; size 4; size 0; size 15; size 8;
size 9; size 0; size 5; size 7; size 2; size 4; size 10; size 15;
size 14; size 1; size 11; size 12; size 6; size 8; size 3; size 13;
size 2; size 12; size 6; size 10; size 0; size 11; size 8; size 3;
size 4; size 13; size 7; size 5; size 15; size 14; size 1; size 9;
size 12; size 5; size 1; size 15; size 14; size 13; size 4; size 10;
size 0; size 7; size 6; size 3; size 9; size 2; size 8; size 11;
size 13; size 11; size 7; size 14; size 12; size 1; size 3; size 9;
size 5; size 0; size 15; size 4; size 8; size 6; size 2; size 10;
size 6; size 15; size 14; size 9; size 11; size 3; size 0; size 8;
size 12; size 2; size 13; size 7; size 1; size 4; size 10; size 5;
size 10; size 2; size 8; size 4; size 7; size 6; size 1; size 5;
size 15; size 11; size 9; size 14; size 3; size 12; size 13; size 0
] in
assert_norm(List.Tot.length l == 160);
l
inline_for_extraction
let sigmaTable:lseq sigma_elt_t size_sigmaTable =
assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma
(* Functions *)
let g1 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (r:rotval (wt a)) : Tot (state a) =
wv.[i] <- (wv.[i] ^| wv.[j]) >>>| r
let g2 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (x:row a) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j] +| x)
let g2z (a:alg) (wv:state a) (i:row_idx) (j:row_idx) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j])
val blake2_mixing:
a:alg
-> ws:state a
-> row a
-> row a ->
Tot (state a)
let blake2_mixing al wv x y =
let a = 0 in
let b = 1 in
let c = 2 in
let d = 3 in
let rt = rTable al in
let wv = g2 al wv a b x in
let wv = g1 al wv d a rt.[0] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[1] in
let wv = g2 al wv a b y in
let wv = g1 al wv d a rt.[2] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[3] in
wv
let diag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 1 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 3 in
wv
let undiag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 3 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 1 in
wv
inline_for_extraction
let gather_row (#a:alg) (m:block_w a) (i0 i1 i2 i3:sigma_elt_t) : row a =
create_row m.[v i0] m.[v i1] m.[v i2] m.[v i3] | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Blake2.Definitions.alg ->
m: Spec.Blake2.Definitions.block_w a ->
start: Prims.nat{start <= 144}
-> Spec.Blake2.Definitions.state a | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Spec.Blake2.Definitions.block_w",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.Sequence.createL",
"Spec.Blake2.Definitions.row",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.list",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Spec.Blake2.Definitions.wt",
"Lib.IntTypes.SEC",
"Prims.Cons",
"Prims.Nil",
"Spec.Blake2.gather_row",
"Lib.Sequence.op_String_Access",
"Spec.Blake2.Definitions.sigma_elt_t",
"Spec.Blake2.Definitions.size_sigmaTable",
"Spec.Blake2.sigmaTable",
"Prims.op_Addition",
"Spec.Blake2.Definitions.state"
] | [] | false | false | false | false | false | let gather_state a m start =
| let x =
gather_row m
sigmaTable.[ start ]
sigmaTable.[ start + 2 ]
sigmaTable.[ start + 4 ]
sigmaTable.[ start + 6 ]
in
let y =
gather_row m
sigmaTable.[ start + 1 ]
sigmaTable.[ start + 3 ]
sigmaTable.[ start + 5 ]
sigmaTable.[ start + 7 ]
in
let z =
gather_row m
sigmaTable.[ start + 8 ]
sigmaTable.[ start + 10 ]
sigmaTable.[ start + 12 ]
sigmaTable.[ start + 14 ]
in
let w =
gather_row m
sigmaTable.[ start + 9 ]
sigmaTable.[ start + 11 ]
sigmaTable.[ start + 13 ]
sigmaTable.[ start + 15 ]
in
let l = [x; y; z; w] in
assert_norm (List.Tot.length l == 4);
createL l | false |
Spec.Blake2.fst | Spec.Blake2.blake2_compress3 | val blake2_compress3:
a:alg
-> wv:state a
-> s_iv:state a ->
Tot (state a) | val blake2_compress3:
a:alg
-> wv:state a
-> s_iv:state a ->
Tot (state a) | let blake2_compress3 a wv s =
let s = s.[0] <- (s.[0] ^| wv.[0]) ^| wv.[2] in
let s = s.[1] <- (s.[1] ^| wv.[1]) ^| wv.[3] in
s | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 283,
"start_col": 0,
"start_line": 280
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B
inline_for_extraction
let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B
[@"opaque_to_smt"]
let list_sigma: list_sigma_t =
[@inline_let]
let l : list sigma_elt_t = [
size 0; size 1; size 2; size 3; size 4; size 5; size 6; size 7;
size 8; size 9; size 10; size 11; size 12; size 13; size 14; size 15;
size 14; size 10; size 4; size 8; size 9; size 15; size 13; size 6;
size 1; size 12; size 0; size 2; size 11; size 7; size 5; size 3;
size 11; size 8; size 12; size 0; size 5; size 2; size 15; size 13;
size 10; size 14; size 3; size 6; size 7; size 1; size 9; size 4;
size 7; size 9; size 3; size 1; size 13; size 12; size 11; size 14;
size 2; size 6; size 5; size 10; size 4; size 0; size 15; size 8;
size 9; size 0; size 5; size 7; size 2; size 4; size 10; size 15;
size 14; size 1; size 11; size 12; size 6; size 8; size 3; size 13;
size 2; size 12; size 6; size 10; size 0; size 11; size 8; size 3;
size 4; size 13; size 7; size 5; size 15; size 14; size 1; size 9;
size 12; size 5; size 1; size 15; size 14; size 13; size 4; size 10;
size 0; size 7; size 6; size 3; size 9; size 2; size 8; size 11;
size 13; size 11; size 7; size 14; size 12; size 1; size 3; size 9;
size 5; size 0; size 15; size 4; size 8; size 6; size 2; size 10;
size 6; size 15; size 14; size 9; size 11; size 3; size 0; size 8;
size 12; size 2; size 13; size 7; size 1; size 4; size 10; size 5;
size 10; size 2; size 8; size 4; size 7; size 6; size 1; size 5;
size 15; size 11; size 9; size 14; size 3; size 12; size 13; size 0
] in
assert_norm(List.Tot.length l == 160);
l
inline_for_extraction
let sigmaTable:lseq sigma_elt_t size_sigmaTable =
assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma
(* Functions *)
let g1 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (r:rotval (wt a)) : Tot (state a) =
wv.[i] <- (wv.[i] ^| wv.[j]) >>>| r
let g2 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (x:row a) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j] +| x)
let g2z (a:alg) (wv:state a) (i:row_idx) (j:row_idx) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j])
val blake2_mixing:
a:alg
-> ws:state a
-> row a
-> row a ->
Tot (state a)
let blake2_mixing al wv x y =
let a = 0 in
let b = 1 in
let c = 2 in
let d = 3 in
let rt = rTable al in
let wv = g2 al wv a b x in
let wv = g1 al wv d a rt.[0] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[1] in
let wv = g2 al wv a b y in
let wv = g1 al wv d a rt.[2] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[3] in
wv
let diag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 1 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 3 in
wv
let undiag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 3 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 1 in
wv
inline_for_extraction
let gather_row (#a:alg) (m:block_w a) (i0 i1 i2 i3:sigma_elt_t) : row a =
create_row m.[v i0] m.[v i1] m.[v i2] m.[v i3]
val gather_state: a:alg -> m:block_w a -> start:nat{start <= 144} -> state a
let gather_state a m start =
let x = gather_row m sigmaTable.[start] sigmaTable.[start+2] sigmaTable.[start+4] sigmaTable.[start+6] in
let y = gather_row m sigmaTable.[start+1] sigmaTable.[start+3] sigmaTable.[start+5] sigmaTable.[start+7] in
let z = gather_row m sigmaTable.[start+8] sigmaTable.[start+10] sigmaTable.[start+12] sigmaTable.[start+14] in
let w = gather_row m sigmaTable.[start+9] sigmaTable.[start+11] sigmaTable.[start+13] sigmaTable.[start+15] in
let l = [x;y;z;w] in
assert_norm (List.Tot.length l == 4);
createL l
val blake2_round:
a:alg
-> m:block_w a
-> i:size_nat
-> wv:state a
-> state a
let blake2_round a m i wv =
let start = (i%10) * 16 in
let m_s = gather_state a m start in
let wv = blake2_mixing a wv m_s.[0] m_s.[1] in
let wv = diag wv in
let wv = blake2_mixing a wv m_s.[2] m_s.[3] in
undiag wv
val blake2_compress0:
a:alg
-> m:block_s a
-> block_w a
let blake2_compress0 a m =
uints_from_bytes_le m
val blake2_compress1:
a:alg
-> s_iv:state a
-> offset:limb_t a
-> flag:bool ->
Tot (state a)
let blake2_compress1 a s_iv offset flag =
let wv : state a = s_iv in
let low_offset = limb_to_word a offset in
let high_offset = limb_to_word a (shift_right #(limb_inttype a) offset (size (bits (wt a)))) in
let m_12 = low_offset in
let m_13 = high_offset in
let m_14 = if flag then (ones (wt a) SEC) else zero a in
let m_15 = zero a in
let mask = create_row m_12 m_13 m_14 m_15 in
let wv = wv.[3] <- wv.[3] ^| mask in
wv
val blake2_compress2:
a:alg
-> wv:state a
-> m:block_w a ->
Tot (state a)
let blake2_compress2 a wv m = repeati (rounds a) (blake2_round a m) wv
val blake2_compress3:
a:alg
-> wv:state a
-> s_iv:state a ->
Tot (state a) | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Blake2.Definitions.alg ->
wv: Spec.Blake2.Definitions.state a ->
s_iv: Spec.Blake2.Definitions.state a
-> Spec.Blake2.Definitions.state a | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Spec.Blake2.Definitions.state",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Spec.Blake2.Definitions.wt",
"Lib.IntTypes.SEC",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.upd",
"Spec.Blake2.Definitions.op_Hat_Bar",
"Lib.Sequence.index",
"Prims.l_Forall",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.l_imp",
"Prims.op_LessThan",
"Prims.op_disEquality",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.op_String_Assignment",
"Spec.Blake2.Definitions.row",
"Lib.Sequence.op_String_Access"
] | [] | false | false | false | false | false | let blake2_compress3 a wv s =
| let s = s.[ 0 ] <- (s.[ 0 ] ^| wv.[ 0 ]) ^| wv.[ 2 ] in
let s = s.[ 1 ] <- (s.[ 1 ] ^| wv.[ 1 ]) ^| wv.[ 3 ] in
s | false |
PulseCore.InstantiatedSemantics.fst | PulseCore.InstantiatedSemantics.pure | val pure (p:prop) : slprop | val pure (p:prop) : slprop | let pure p = pure p | {
"file_name": "lib/pulse_core/PulseCore.InstantiatedSemantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 19,
"end_line": 60,
"start_col": 0,
"start_line": 60
} | module PulseCore.InstantiatedSemantics
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module U = FStar.Universe
module F = FStar.FunctionalExtensionality
open PulseCore.Memory
let laws ()
: squash (
Sem.associative star /\
Sem.commutative star /\
Sem.is_unit emp star
)
= let equiv_eq (x y:slprop)
: Lemma (x `equiv` y <==> x == y)
[SMTPat (x `equiv` y)]
= introduce x `equiv` y ==> x == y
with _h . slprop_extensionality x y
in
let _ : squash (Sem.associative star) =
introduce
forall x y z.
((x `star` y) `star` z) ==
(x `star` (y `star` z))
with star_associative x y z
in
let _ : squash (Sem.commutative star) =
introduce
forall x y.
x `star` y == y `star` x
with star_commutative x y
in
let _ : squash (Sem.is_unit emp star) =
introduce
forall x.
(x `star` emp) == x /\
(emp `star` x) == x
with emp_unit x
in
()
let state0 (e:inames) : Sem.state = {
max_act = U.raise_t u#0 u#100 unit;
s = mem;
is_full_mem = full_mem_pred;
pred = slprop;
emp = emp;
star = star;
interp = interp;
evolves = mem_evolves;
invariant = locks_invariant e;
laws = laws ()
}
let state : Sem.state = state0 Set.empty
let slprop = slprop
let _eq : squash (slprop == state.pred) = () | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.InstantiatedSemantics.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p: Prims.prop -> PulseCore.InstantiatedSemantics.slprop | Prims.Tot | [
"total"
] | [] | [
"Prims.prop",
"PulseCore.Memory.pure",
"PulseCore.InstantiatedSemantics.slprop"
] | [] | false | false | false | true | false | let pure p =
| pure p | false |
PulseCore.InstantiatedSemantics.fst | PulseCore.InstantiatedSemantics.slprop | val slprop : Type u#2 | val slprop : Type u#2 | let slprop = slprop | {
"file_name": "lib/pulse_core/PulseCore.InstantiatedSemantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 19,
"end_line": 57,
"start_col": 0,
"start_line": 57
} | module PulseCore.InstantiatedSemantics
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module U = FStar.Universe
module F = FStar.FunctionalExtensionality
open PulseCore.Memory
let laws ()
: squash (
Sem.associative star /\
Sem.commutative star /\
Sem.is_unit emp star
)
= let equiv_eq (x y:slprop)
: Lemma (x `equiv` y <==> x == y)
[SMTPat (x `equiv` y)]
= introduce x `equiv` y ==> x == y
with _h . slprop_extensionality x y
in
let _ : squash (Sem.associative star) =
introduce
forall x y z.
((x `star` y) `star` z) ==
(x `star` (y `star` z))
with star_associative x y z
in
let _ : squash (Sem.commutative star) =
introduce
forall x y.
x `star` y == y `star` x
with star_commutative x y
in
let _ : squash (Sem.is_unit emp star) =
introduce
forall x.
(x `star` emp) == x /\
(emp `star` x) == x
with emp_unit x
in
()
let state0 (e:inames) : Sem.state = {
max_act = U.raise_t u#0 u#100 unit;
s = mem;
is_full_mem = full_mem_pred;
pred = slprop;
emp = emp;
star = star;
interp = interp;
evolves = mem_evolves;
invariant = locks_invariant e;
laws = laws ()
}
let state : Sem.state = state0 Set.empty | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.InstantiatedSemantics.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Type | Prims.Tot | [
"total"
] | [] | [
"PulseCore.Memory.slprop"
] | [] | false | false | false | true | true | let slprop =
| slprop | false |
PulseCore.InstantiatedSemantics.fst | PulseCore.InstantiatedSemantics.emp | val emp : slprop | val emp : slprop | let emp = emp | {
"file_name": "lib/pulse_core/PulseCore.InstantiatedSemantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 13,
"end_line": 59,
"start_col": 0,
"start_line": 59
} | module PulseCore.InstantiatedSemantics
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module U = FStar.Universe
module F = FStar.FunctionalExtensionality
open PulseCore.Memory
let laws ()
: squash (
Sem.associative star /\
Sem.commutative star /\
Sem.is_unit emp star
)
= let equiv_eq (x y:slprop)
: Lemma (x `equiv` y <==> x == y)
[SMTPat (x `equiv` y)]
= introduce x `equiv` y ==> x == y
with _h . slprop_extensionality x y
in
let _ : squash (Sem.associative star) =
introduce
forall x y z.
((x `star` y) `star` z) ==
(x `star` (y `star` z))
with star_associative x y z
in
let _ : squash (Sem.commutative star) =
introduce
forall x y.
x `star` y == y `star` x
with star_commutative x y
in
let _ : squash (Sem.is_unit emp star) =
introduce
forall x.
(x `star` emp) == x /\
(emp `star` x) == x
with emp_unit x
in
()
let state0 (e:inames) : Sem.state = {
max_act = U.raise_t u#0 u#100 unit;
s = mem;
is_full_mem = full_mem_pred;
pred = slprop;
emp = emp;
star = star;
interp = interp;
evolves = mem_evolves;
invariant = locks_invariant e;
laws = laws ()
}
let state : Sem.state = state0 Set.empty
let slprop = slprop | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.InstantiatedSemantics.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | PulseCore.InstantiatedSemantics.slprop | Prims.Tot | [
"total"
] | [] | [
"PulseCore.Memory.emp"
] | [] | false | false | false | true | false | let emp =
| emp | false |
Spec.Blake2.fst | Spec.Blake2.get_blocki | val get_blocki (a: alg) (m: bytes) (i: nat{i < length m / size_block a}) : block_s a | val get_blocki (a: alg) (m: bytes) (i: nat{i < length m / size_block a}) : block_s a | let get_blocki (a:alg) (m:bytes) (i:nat{i < length m / size_block a}) : block_s a =
Seq.slice m (i * size_block a) ((i+1) * size_block a) | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 55,
"end_line": 322,
"start_col": 0,
"start_line": 321
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B
inline_for_extraction
let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B
[@"opaque_to_smt"]
let list_sigma: list_sigma_t =
[@inline_let]
let l : list sigma_elt_t = [
size 0; size 1; size 2; size 3; size 4; size 5; size 6; size 7;
size 8; size 9; size 10; size 11; size 12; size 13; size 14; size 15;
size 14; size 10; size 4; size 8; size 9; size 15; size 13; size 6;
size 1; size 12; size 0; size 2; size 11; size 7; size 5; size 3;
size 11; size 8; size 12; size 0; size 5; size 2; size 15; size 13;
size 10; size 14; size 3; size 6; size 7; size 1; size 9; size 4;
size 7; size 9; size 3; size 1; size 13; size 12; size 11; size 14;
size 2; size 6; size 5; size 10; size 4; size 0; size 15; size 8;
size 9; size 0; size 5; size 7; size 2; size 4; size 10; size 15;
size 14; size 1; size 11; size 12; size 6; size 8; size 3; size 13;
size 2; size 12; size 6; size 10; size 0; size 11; size 8; size 3;
size 4; size 13; size 7; size 5; size 15; size 14; size 1; size 9;
size 12; size 5; size 1; size 15; size 14; size 13; size 4; size 10;
size 0; size 7; size 6; size 3; size 9; size 2; size 8; size 11;
size 13; size 11; size 7; size 14; size 12; size 1; size 3; size 9;
size 5; size 0; size 15; size 4; size 8; size 6; size 2; size 10;
size 6; size 15; size 14; size 9; size 11; size 3; size 0; size 8;
size 12; size 2; size 13; size 7; size 1; size 4; size 10; size 5;
size 10; size 2; size 8; size 4; size 7; size 6; size 1; size 5;
size 15; size 11; size 9; size 14; size 3; size 12; size 13; size 0
] in
assert_norm(List.Tot.length l == 160);
l
inline_for_extraction
let sigmaTable:lseq sigma_elt_t size_sigmaTable =
assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma
(* Functions *)
let g1 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (r:rotval (wt a)) : Tot (state a) =
wv.[i] <- (wv.[i] ^| wv.[j]) >>>| r
let g2 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (x:row a) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j] +| x)
let g2z (a:alg) (wv:state a) (i:row_idx) (j:row_idx) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j])
val blake2_mixing:
a:alg
-> ws:state a
-> row a
-> row a ->
Tot (state a)
let blake2_mixing al wv x y =
let a = 0 in
let b = 1 in
let c = 2 in
let d = 3 in
let rt = rTable al in
let wv = g2 al wv a b x in
let wv = g1 al wv d a rt.[0] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[1] in
let wv = g2 al wv a b y in
let wv = g1 al wv d a rt.[2] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[3] in
wv
let diag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 1 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 3 in
wv
let undiag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 3 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 1 in
wv
inline_for_extraction
let gather_row (#a:alg) (m:block_w a) (i0 i1 i2 i3:sigma_elt_t) : row a =
create_row m.[v i0] m.[v i1] m.[v i2] m.[v i3]
val gather_state: a:alg -> m:block_w a -> start:nat{start <= 144} -> state a
let gather_state a m start =
let x = gather_row m sigmaTable.[start] sigmaTable.[start+2] sigmaTable.[start+4] sigmaTable.[start+6] in
let y = gather_row m sigmaTable.[start+1] sigmaTable.[start+3] sigmaTable.[start+5] sigmaTable.[start+7] in
let z = gather_row m sigmaTable.[start+8] sigmaTable.[start+10] sigmaTable.[start+12] sigmaTable.[start+14] in
let w = gather_row m sigmaTable.[start+9] sigmaTable.[start+11] sigmaTable.[start+13] sigmaTable.[start+15] in
let l = [x;y;z;w] in
assert_norm (List.Tot.length l == 4);
createL l
val blake2_round:
a:alg
-> m:block_w a
-> i:size_nat
-> wv:state a
-> state a
let blake2_round a m i wv =
let start = (i%10) * 16 in
let m_s = gather_state a m start in
let wv = blake2_mixing a wv m_s.[0] m_s.[1] in
let wv = diag wv in
let wv = blake2_mixing a wv m_s.[2] m_s.[3] in
undiag wv
val blake2_compress0:
a:alg
-> m:block_s a
-> block_w a
let blake2_compress0 a m =
uints_from_bytes_le m
val blake2_compress1:
a:alg
-> s_iv:state a
-> offset:limb_t a
-> flag:bool ->
Tot (state a)
let blake2_compress1 a s_iv offset flag =
let wv : state a = s_iv in
let low_offset = limb_to_word a offset in
let high_offset = limb_to_word a (shift_right #(limb_inttype a) offset (size (bits (wt a)))) in
let m_12 = low_offset in
let m_13 = high_offset in
let m_14 = if flag then (ones (wt a) SEC) else zero a in
let m_15 = zero a in
let mask = create_row m_12 m_13 m_14 m_15 in
let wv = wv.[3] <- wv.[3] ^| mask in
wv
val blake2_compress2:
a:alg
-> wv:state a
-> m:block_w a ->
Tot (state a)
let blake2_compress2 a wv m = repeati (rounds a) (blake2_round a m) wv
val blake2_compress3:
a:alg
-> wv:state a
-> s_iv:state a ->
Tot (state a)
let blake2_compress3 a wv s =
let s = s.[0] <- (s.[0] ^| wv.[0]) ^| wv.[2] in
let s = s.[1] <- (s.[1] ^| wv.[1]) ^| wv.[3] in
s
val blake2_compress:
a:alg
-> s_iv:state a
-> m:block_s a
-> offset:limb_t a
-> flag:bool ->
Tot (state a)
let blake2_compress a s_iv m offset flag =
let m_w = blake2_compress0 a m in
let wv = blake2_compress1 a s_iv offset flag in
let wv = blake2_compress2 a wv m_w in
let s_iv = blake2_compress3 a wv s_iv in
s_iv
val blake2_update_block:
a:alg
-> flag:bool
-> totlen:nat{totlen <= max_limb a}
-> d:block_s a
-> s_iv:state a ->
Tot (state a)
let blake2_update_block a flag totlen d s =
let offset = nat_to_limb a totlen in
blake2_compress a s d offset flag
val blake2_update1:
a:alg
-> prev:nat
-> m:bytes
-> i:nat{i < length m / size_block a /\ prev + length m <= max_limb a}
-> s:state a ->
Tot (state a) | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Blake2.Definitions.alg ->
m: Lib.ByteSequence.bytes ->
i: Prims.nat{i < Lib.Sequence.length m / Spec.Blake2.Definitions.size_block a}
-> Spec.Blake2.Definitions.block_s a | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Lib.ByteSequence.bytes",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Division",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.Blake2.Definitions.size_block",
"FStar.Seq.Base.slice",
"FStar.Mul.op_Star",
"Prims.op_Addition",
"Spec.Blake2.Definitions.block_s"
] | [] | false | false | false | false | false | let get_blocki (a: alg) (m: bytes) (i: nat{i < length m / size_block a}) : block_s a =
| Seq.slice m (i * size_block a) ((i + 1) * size_block a) | false |
Spec.Blake2.fst | Spec.Blake2.split | val split (a: alg) (len: nat)
: nb_rem:
(nat & nat)
{ let nb, rem = nb_rem in
nb * size_block a + rem == len } | val split (a: alg) (len: nat)
: nb_rem:
(nat & nat)
{ let nb, rem = nb_rem in
nb * size_block a + rem == len } | let split (a:alg) (len:nat)
: nb_rem:(nat & nat){let (nb,rem) = nb_rem in
nb * size_block a + rem == len} =
UpdateMulti.split_at_last_lazy_nb_rem (size_block a) len | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 58,
"end_line": 360,
"start_col": 0,
"start_line": 357
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B
inline_for_extraction
let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B
[@"opaque_to_smt"]
let list_sigma: list_sigma_t =
[@inline_let]
let l : list sigma_elt_t = [
size 0; size 1; size 2; size 3; size 4; size 5; size 6; size 7;
size 8; size 9; size 10; size 11; size 12; size 13; size 14; size 15;
size 14; size 10; size 4; size 8; size 9; size 15; size 13; size 6;
size 1; size 12; size 0; size 2; size 11; size 7; size 5; size 3;
size 11; size 8; size 12; size 0; size 5; size 2; size 15; size 13;
size 10; size 14; size 3; size 6; size 7; size 1; size 9; size 4;
size 7; size 9; size 3; size 1; size 13; size 12; size 11; size 14;
size 2; size 6; size 5; size 10; size 4; size 0; size 15; size 8;
size 9; size 0; size 5; size 7; size 2; size 4; size 10; size 15;
size 14; size 1; size 11; size 12; size 6; size 8; size 3; size 13;
size 2; size 12; size 6; size 10; size 0; size 11; size 8; size 3;
size 4; size 13; size 7; size 5; size 15; size 14; size 1; size 9;
size 12; size 5; size 1; size 15; size 14; size 13; size 4; size 10;
size 0; size 7; size 6; size 3; size 9; size 2; size 8; size 11;
size 13; size 11; size 7; size 14; size 12; size 1; size 3; size 9;
size 5; size 0; size 15; size 4; size 8; size 6; size 2; size 10;
size 6; size 15; size 14; size 9; size 11; size 3; size 0; size 8;
size 12; size 2; size 13; size 7; size 1; size 4; size 10; size 5;
size 10; size 2; size 8; size 4; size 7; size 6; size 1; size 5;
size 15; size 11; size 9; size 14; size 3; size 12; size 13; size 0
] in
assert_norm(List.Tot.length l == 160);
l
inline_for_extraction
let sigmaTable:lseq sigma_elt_t size_sigmaTable =
assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma
(* Functions *)
let g1 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (r:rotval (wt a)) : Tot (state a) =
wv.[i] <- (wv.[i] ^| wv.[j]) >>>| r
let g2 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (x:row a) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j] +| x)
let g2z (a:alg) (wv:state a) (i:row_idx) (j:row_idx) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j])
val blake2_mixing:
a:alg
-> ws:state a
-> row a
-> row a ->
Tot (state a)
let blake2_mixing al wv x y =
let a = 0 in
let b = 1 in
let c = 2 in
let d = 3 in
let rt = rTable al in
let wv = g2 al wv a b x in
let wv = g1 al wv d a rt.[0] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[1] in
let wv = g2 al wv a b y in
let wv = g1 al wv d a rt.[2] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[3] in
wv
let diag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 1 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 3 in
wv
let undiag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 3 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 1 in
wv
inline_for_extraction
let gather_row (#a:alg) (m:block_w a) (i0 i1 i2 i3:sigma_elt_t) : row a =
create_row m.[v i0] m.[v i1] m.[v i2] m.[v i3]
val gather_state: a:alg -> m:block_w a -> start:nat{start <= 144} -> state a
let gather_state a m start =
let x = gather_row m sigmaTable.[start] sigmaTable.[start+2] sigmaTable.[start+4] sigmaTable.[start+6] in
let y = gather_row m sigmaTable.[start+1] sigmaTable.[start+3] sigmaTable.[start+5] sigmaTable.[start+7] in
let z = gather_row m sigmaTable.[start+8] sigmaTable.[start+10] sigmaTable.[start+12] sigmaTable.[start+14] in
let w = gather_row m sigmaTable.[start+9] sigmaTable.[start+11] sigmaTable.[start+13] sigmaTable.[start+15] in
let l = [x;y;z;w] in
assert_norm (List.Tot.length l == 4);
createL l
val blake2_round:
a:alg
-> m:block_w a
-> i:size_nat
-> wv:state a
-> state a
let blake2_round a m i wv =
let start = (i%10) * 16 in
let m_s = gather_state a m start in
let wv = blake2_mixing a wv m_s.[0] m_s.[1] in
let wv = diag wv in
let wv = blake2_mixing a wv m_s.[2] m_s.[3] in
undiag wv
val blake2_compress0:
a:alg
-> m:block_s a
-> block_w a
let blake2_compress0 a m =
uints_from_bytes_le m
val blake2_compress1:
a:alg
-> s_iv:state a
-> offset:limb_t a
-> flag:bool ->
Tot (state a)
let blake2_compress1 a s_iv offset flag =
let wv : state a = s_iv in
let low_offset = limb_to_word a offset in
let high_offset = limb_to_word a (shift_right #(limb_inttype a) offset (size (bits (wt a)))) in
let m_12 = low_offset in
let m_13 = high_offset in
let m_14 = if flag then (ones (wt a) SEC) else zero a in
let m_15 = zero a in
let mask = create_row m_12 m_13 m_14 m_15 in
let wv = wv.[3] <- wv.[3] ^| mask in
wv
val blake2_compress2:
a:alg
-> wv:state a
-> m:block_w a ->
Tot (state a)
let blake2_compress2 a wv m = repeati (rounds a) (blake2_round a m) wv
val blake2_compress3:
a:alg
-> wv:state a
-> s_iv:state a ->
Tot (state a)
let blake2_compress3 a wv s =
let s = s.[0] <- (s.[0] ^| wv.[0]) ^| wv.[2] in
let s = s.[1] <- (s.[1] ^| wv.[1]) ^| wv.[3] in
s
val blake2_compress:
a:alg
-> s_iv:state a
-> m:block_s a
-> offset:limb_t a
-> flag:bool ->
Tot (state a)
let blake2_compress a s_iv m offset flag =
let m_w = blake2_compress0 a m in
let wv = blake2_compress1 a s_iv offset flag in
let wv = blake2_compress2 a wv m_w in
let s_iv = blake2_compress3 a wv s_iv in
s_iv
val blake2_update_block:
a:alg
-> flag:bool
-> totlen:nat{totlen <= max_limb a}
-> d:block_s a
-> s_iv:state a ->
Tot (state a)
let blake2_update_block a flag totlen d s =
let offset = nat_to_limb a totlen in
blake2_compress a s d offset flag
val blake2_update1:
a:alg
-> prev:nat
-> m:bytes
-> i:nat{i < length m / size_block a /\ prev + length m <= max_limb a}
-> s:state a ->
Tot (state a)
let get_blocki (a:alg) (m:bytes) (i:nat{i < length m / size_block a}) : block_s a =
Seq.slice m (i * size_block a) ((i+1) * size_block a)
let blake2_update1 a prev m i s =
let totlen = prev + (i+1) * size_block a in
let d = get_blocki a m i in
blake2_update_block a false totlen d s
val blake2_update_last:
a:alg
-> prev:nat
-> rem:nat
-> m:bytes{prev + length m <= max_limb a /\ rem <= length m /\ rem <= size_block a}
-> s:state a ->
Tot (state a)
let get_last_padded_block (a:alg) (m:bytes)
(rem:nat{rem <= length m /\ rem <= size_block a}) : block_s a =
let last = Seq.slice m (length m - rem) (length m) in
let last_block = create (size_block a) (u8 0) in
let last_block = update_sub last_block 0 rem last in
last_block
let blake2_update_last a prev rem m s =
let inlen = length m in
let totlen = prev + inlen in
let last_block = get_last_padded_block a m rem in
blake2_update_block a true totlen last_block s
val blake2_update_blocks:
a:alg
-> prev:nat
-> m:bytes{prev + length m <= max_limb a}
-> s:state a ->
Tot (state a) | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Spec.Blake2.Definitions.alg -> len: Prims.nat
-> nb_rem:
(Prims.nat * Prims.nat)
{ let _ = nb_rem in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ nb rem = _ in
nb * Spec.Blake2.Definitions.size_block a + rem == len)
<:
Type0 } | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Prims.nat",
"Lib.UpdateMulti.split_at_last_lazy_nb_rem",
"Spec.Blake2.Definitions.size_block",
"FStar.Pervasives.Native.tuple2",
"Prims.eq2",
"Prims.int",
"Prims.op_Addition",
"FStar.Mul.op_Star"
] | [] | false | false | false | false | false | let split (a: alg) (len: nat)
: nb_rem:
(nat & nat)
{ let nb, rem = nb_rem in
nb * size_block a + rem == len } =
| UpdateMulti.split_at_last_lazy_nb_rem (size_block a) len | false |
Spec.Blake2.fst | Spec.Blake2.blake2_update_key | val blake2_update_key:
a:alg
-> kk:size_nat{0 < kk /\ kk <= max_key a}
-> k:lbytes kk
-> ll:nat
-> s:state a ->
Tot (state a) | val blake2_update_key:
a:alg
-> kk:size_nat{0 < kk /\ kk <= max_key a}
-> k:lbytes kk
-> ll:nat
-> s:state a ->
Tot (state a) | let blake2_update_key a kk k ll s =
let key_block = blake2_key_block a kk k in
if ll = 0 then
blake2_update_block a true (size_block a) key_block s
else
blake2_update_block a false (size_block a) key_block s | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 60,
"end_line": 426,
"start_col": 0,
"start_line": 421
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B
inline_for_extraction
let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B
[@"opaque_to_smt"]
let list_sigma: list_sigma_t =
[@inline_let]
let l : list sigma_elt_t = [
size 0; size 1; size 2; size 3; size 4; size 5; size 6; size 7;
size 8; size 9; size 10; size 11; size 12; size 13; size 14; size 15;
size 14; size 10; size 4; size 8; size 9; size 15; size 13; size 6;
size 1; size 12; size 0; size 2; size 11; size 7; size 5; size 3;
size 11; size 8; size 12; size 0; size 5; size 2; size 15; size 13;
size 10; size 14; size 3; size 6; size 7; size 1; size 9; size 4;
size 7; size 9; size 3; size 1; size 13; size 12; size 11; size 14;
size 2; size 6; size 5; size 10; size 4; size 0; size 15; size 8;
size 9; size 0; size 5; size 7; size 2; size 4; size 10; size 15;
size 14; size 1; size 11; size 12; size 6; size 8; size 3; size 13;
size 2; size 12; size 6; size 10; size 0; size 11; size 8; size 3;
size 4; size 13; size 7; size 5; size 15; size 14; size 1; size 9;
size 12; size 5; size 1; size 15; size 14; size 13; size 4; size 10;
size 0; size 7; size 6; size 3; size 9; size 2; size 8; size 11;
size 13; size 11; size 7; size 14; size 12; size 1; size 3; size 9;
size 5; size 0; size 15; size 4; size 8; size 6; size 2; size 10;
size 6; size 15; size 14; size 9; size 11; size 3; size 0; size 8;
size 12; size 2; size 13; size 7; size 1; size 4; size 10; size 5;
size 10; size 2; size 8; size 4; size 7; size 6; size 1; size 5;
size 15; size 11; size 9; size 14; size 3; size 12; size 13; size 0
] in
assert_norm(List.Tot.length l == 160);
l
inline_for_extraction
let sigmaTable:lseq sigma_elt_t size_sigmaTable =
assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma
(* Functions *)
let g1 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (r:rotval (wt a)) : Tot (state a) =
wv.[i] <- (wv.[i] ^| wv.[j]) >>>| r
let g2 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (x:row a) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j] +| x)
let g2z (a:alg) (wv:state a) (i:row_idx) (j:row_idx) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j])
val blake2_mixing:
a:alg
-> ws:state a
-> row a
-> row a ->
Tot (state a)
let blake2_mixing al wv x y =
let a = 0 in
let b = 1 in
let c = 2 in
let d = 3 in
let rt = rTable al in
let wv = g2 al wv a b x in
let wv = g1 al wv d a rt.[0] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[1] in
let wv = g2 al wv a b y in
let wv = g1 al wv d a rt.[2] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[3] in
wv
let diag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 1 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 3 in
wv
let undiag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 3 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 1 in
wv
inline_for_extraction
let gather_row (#a:alg) (m:block_w a) (i0 i1 i2 i3:sigma_elt_t) : row a =
create_row m.[v i0] m.[v i1] m.[v i2] m.[v i3]
val gather_state: a:alg -> m:block_w a -> start:nat{start <= 144} -> state a
let gather_state a m start =
let x = gather_row m sigmaTable.[start] sigmaTable.[start+2] sigmaTable.[start+4] sigmaTable.[start+6] in
let y = gather_row m sigmaTable.[start+1] sigmaTable.[start+3] sigmaTable.[start+5] sigmaTable.[start+7] in
let z = gather_row m sigmaTable.[start+8] sigmaTable.[start+10] sigmaTable.[start+12] sigmaTable.[start+14] in
let w = gather_row m sigmaTable.[start+9] sigmaTable.[start+11] sigmaTable.[start+13] sigmaTable.[start+15] in
let l = [x;y;z;w] in
assert_norm (List.Tot.length l == 4);
createL l
val blake2_round:
a:alg
-> m:block_w a
-> i:size_nat
-> wv:state a
-> state a
let blake2_round a m i wv =
let start = (i%10) * 16 in
let m_s = gather_state a m start in
let wv = blake2_mixing a wv m_s.[0] m_s.[1] in
let wv = diag wv in
let wv = blake2_mixing a wv m_s.[2] m_s.[3] in
undiag wv
val blake2_compress0:
a:alg
-> m:block_s a
-> block_w a
let blake2_compress0 a m =
uints_from_bytes_le m
val blake2_compress1:
a:alg
-> s_iv:state a
-> offset:limb_t a
-> flag:bool ->
Tot (state a)
let blake2_compress1 a s_iv offset flag =
let wv : state a = s_iv in
let low_offset = limb_to_word a offset in
let high_offset = limb_to_word a (shift_right #(limb_inttype a) offset (size (bits (wt a)))) in
let m_12 = low_offset in
let m_13 = high_offset in
let m_14 = if flag then (ones (wt a) SEC) else zero a in
let m_15 = zero a in
let mask = create_row m_12 m_13 m_14 m_15 in
let wv = wv.[3] <- wv.[3] ^| mask in
wv
val blake2_compress2:
a:alg
-> wv:state a
-> m:block_w a ->
Tot (state a)
let blake2_compress2 a wv m = repeati (rounds a) (blake2_round a m) wv
val blake2_compress3:
a:alg
-> wv:state a
-> s_iv:state a ->
Tot (state a)
let blake2_compress3 a wv s =
let s = s.[0] <- (s.[0] ^| wv.[0]) ^| wv.[2] in
let s = s.[1] <- (s.[1] ^| wv.[1]) ^| wv.[3] in
s
val blake2_compress:
a:alg
-> s_iv:state a
-> m:block_s a
-> offset:limb_t a
-> flag:bool ->
Tot (state a)
let blake2_compress a s_iv m offset flag =
let m_w = blake2_compress0 a m in
let wv = blake2_compress1 a s_iv offset flag in
let wv = blake2_compress2 a wv m_w in
let s_iv = blake2_compress3 a wv s_iv in
s_iv
val blake2_update_block:
a:alg
-> flag:bool
-> totlen:nat{totlen <= max_limb a}
-> d:block_s a
-> s_iv:state a ->
Tot (state a)
let blake2_update_block a flag totlen d s =
let offset = nat_to_limb a totlen in
blake2_compress a s d offset flag
val blake2_update1:
a:alg
-> prev:nat
-> m:bytes
-> i:nat{i < length m / size_block a /\ prev + length m <= max_limb a}
-> s:state a ->
Tot (state a)
let get_blocki (a:alg) (m:bytes) (i:nat{i < length m / size_block a}) : block_s a =
Seq.slice m (i * size_block a) ((i+1) * size_block a)
let blake2_update1 a prev m i s =
let totlen = prev + (i+1) * size_block a in
let d = get_blocki a m i in
blake2_update_block a false totlen d s
val blake2_update_last:
a:alg
-> prev:nat
-> rem:nat
-> m:bytes{prev + length m <= max_limb a /\ rem <= length m /\ rem <= size_block a}
-> s:state a ->
Tot (state a)
let get_last_padded_block (a:alg) (m:bytes)
(rem:nat{rem <= length m /\ rem <= size_block a}) : block_s a =
let last = Seq.slice m (length m - rem) (length m) in
let last_block = create (size_block a) (u8 0) in
let last_block = update_sub last_block 0 rem last in
last_block
let blake2_update_last a prev rem m s =
let inlen = length m in
let totlen = prev + inlen in
let last_block = get_last_padded_block a m rem in
blake2_update_block a true totlen last_block s
val blake2_update_blocks:
a:alg
-> prev:nat
-> m:bytes{prev + length m <= max_limb a}
-> s:state a ->
Tot (state a)
let split (a:alg) (len:nat)
: nb_rem:(nat & nat){let (nb,rem) = nb_rem in
nb * size_block a + rem == len} =
UpdateMulti.split_at_last_lazy_nb_rem (size_block a) len
let blake2_update_blocks a prev m s =
let (nb,rem) = split a (length m) in
let s = repeati nb (blake2_update1 a prev m) s in
blake2_update_last a prev rem m s
val blake2_init_hash:
a:alg
-> p:blake2_params a
-> kk:size_nat{kk <= max_key a}
-> nn:size_nat{1 <= nn /\ nn <= max_output a} ->
Tot (state a)
let blake2_init_hash a p kk nn =
let iv0 = secret (ivTable a).[0] in
let iv1 = secret (ivTable a).[1] in
let iv2 = secret (ivTable a).[2] in
let iv3 = secret (ivTable a).[3] in
let iv4 = secret (ivTable a).[4] in
let iv5 = secret (ivTable a).[5] in
let iv6 = secret (ivTable a).[6] in
let iv7 = secret (ivTable a).[7] in
let r0 = create_row #a iv0 iv1 iv2 iv3 in
let r1 = create_row #a iv4 iv5 iv6 iv7 in
let p: blake2_params a =
set_key_length (set_digest_length p nn) kk
in
let s = serialize_blake2_params p in
let iv0' = iv0 ^. s.[0] in
let iv1' = iv1 ^. s.[1] in
let iv2' = iv2 ^. s.[2] in
let iv3' = iv3 ^. s.[3] in
let iv4' = iv4 ^. s.[4] in
let iv5' = iv5 ^. s.[5] in
let iv6' = iv6 ^. s.[6] in
let iv7' = iv7 ^. s.[7] in
let r0' = create_row #a iv0' iv1' iv2' iv3' in
let r1' = create_row #a iv4' iv5' iv6' iv7' in
let s_iv = createL [r0';r1';r0;r1] in
s_iv
val blake2_key_block:
a:alg
-> kk:size_nat{0 < kk /\ kk <= max_key a}
-> k:lbytes kk
-> block_s a
let blake2_key_block a kk k =
let key_block = create (size_block a) (u8 0) in
let key_block = update_sub key_block 0 kk k in
key_block
/// This function must be called only if the key is non empty (see the precondition)
val blake2_update_key:
a:alg
-> kk:size_nat{0 < kk /\ kk <= max_key a}
-> k:lbytes kk
-> ll:nat
-> s:state a -> | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Blake2.Definitions.alg ->
kk: Lib.IntTypes.size_nat{0 < kk /\ kk <= Spec.Blake2.Definitions.max_key a} ->
k: Lib.ByteSequence.lbytes kk ->
ll: Prims.nat ->
s: Spec.Blake2.Definitions.state a
-> Spec.Blake2.Definitions.state a | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"Spec.Blake2.Definitions.max_key",
"Lib.ByteSequence.lbytes",
"Prims.nat",
"Spec.Blake2.Definitions.state",
"Prims.op_Equality",
"Prims.int",
"Spec.Blake2.blake2_update_block",
"Spec.Blake2.Definitions.size_block",
"Prims.bool",
"Spec.Blake2.Definitions.block_s",
"Spec.Blake2.blake2_key_block"
] | [] | false | false | false | false | false | let blake2_update_key a kk k ll s =
| let key_block = blake2_key_block a kk k in
if ll = 0
then blake2_update_block a true (size_block a) key_block s
else blake2_update_block a false (size_block a) key_block s | false |
PulseCore.InstantiatedSemantics.fst | PulseCore.InstantiatedSemantics.slprop_equiv | val slprop_equiv (p q:slprop) : prop | val slprop_equiv (p q:slprop) : prop | let slprop_equiv p q = Mem.equiv p q | {
"file_name": "lib/pulse_core/PulseCore.InstantiatedSemantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 36,
"end_line": 68,
"start_col": 0,
"start_line": 68
} | module PulseCore.InstantiatedSemantics
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module U = FStar.Universe
module F = FStar.FunctionalExtensionality
open PulseCore.Memory
let laws ()
: squash (
Sem.associative star /\
Sem.commutative star /\
Sem.is_unit emp star
)
= let equiv_eq (x y:slprop)
: Lemma (x `equiv` y <==> x == y)
[SMTPat (x `equiv` y)]
= introduce x `equiv` y ==> x == y
with _h . slprop_extensionality x y
in
let _ : squash (Sem.associative star) =
introduce
forall x y z.
((x `star` y) `star` z) ==
(x `star` (y `star` z))
with star_associative x y z
in
let _ : squash (Sem.commutative star) =
introduce
forall x y.
x `star` y == y `star` x
with star_commutative x y
in
let _ : squash (Sem.is_unit emp star) =
introduce
forall x.
(x `star` emp) == x /\
(emp `star` x) == x
with emp_unit x
in
()
let state0 (e:inames) : Sem.state = {
max_act = U.raise_t u#0 u#100 unit;
s = mem;
is_full_mem = full_mem_pred;
pred = slprop;
emp = emp;
star = star;
interp = interp;
evolves = mem_evolves;
invariant = locks_invariant e;
laws = laws ()
}
let state : Sem.state = state0 Set.empty
let slprop = slprop
let _eq : squash (slprop == state.pred) = ()
let emp = emp
let pure p = pure p
let ( ** ) p q = p `star` q
let ( exists* ) #a p = h_exists (F.on_dom a p)
let prop_squash_idem (p:prop)
: Tot (squash (p == squash p))
= FStar.PropositionalExtensionality.apply p (squash p) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.InstantiatedSemantics.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p: PulseCore.InstantiatedSemantics.slprop -> q: PulseCore.InstantiatedSemantics.slprop -> Prims.prop | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.Memory.equiv",
"Prims.prop"
] | [] | false | false | false | true | true | let slprop_equiv p q =
| Mem.equiv p q | false |
Spec.Blake2.fst | Spec.Blake2.blake2_update | val blake2_update:
a:alg
-> kk:size_nat{kk <= max_key a}
-> k:lbytes kk
-> d:bytes{if kk = 0 then length d <= max_limb a else length d + (size_block a) <= max_limb a}
-> s:state a ->
Tot (state a) | val blake2_update:
a:alg
-> kk:size_nat{kk <= max_key a}
-> k:lbytes kk
-> d:bytes{if kk = 0 then length d <= max_limb a else length d + (size_block a) <= max_limb a}
-> s:state a ->
Tot (state a) | let blake2_update a kk k d s =
let ll = length d in
if kk > 0 then
let s = blake2_update_key a kk k ll s in
if ll = 0 then s // Skip update_last if ll = 0 (but kk > 0)
else blake2_update_blocks a (size_block a) d s
else blake2_update_blocks a 0 d s | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 35,
"end_line": 441,
"start_col": 0,
"start_line": 435
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B
inline_for_extraction
let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B
[@"opaque_to_smt"]
let list_sigma: list_sigma_t =
[@inline_let]
let l : list sigma_elt_t = [
size 0; size 1; size 2; size 3; size 4; size 5; size 6; size 7;
size 8; size 9; size 10; size 11; size 12; size 13; size 14; size 15;
size 14; size 10; size 4; size 8; size 9; size 15; size 13; size 6;
size 1; size 12; size 0; size 2; size 11; size 7; size 5; size 3;
size 11; size 8; size 12; size 0; size 5; size 2; size 15; size 13;
size 10; size 14; size 3; size 6; size 7; size 1; size 9; size 4;
size 7; size 9; size 3; size 1; size 13; size 12; size 11; size 14;
size 2; size 6; size 5; size 10; size 4; size 0; size 15; size 8;
size 9; size 0; size 5; size 7; size 2; size 4; size 10; size 15;
size 14; size 1; size 11; size 12; size 6; size 8; size 3; size 13;
size 2; size 12; size 6; size 10; size 0; size 11; size 8; size 3;
size 4; size 13; size 7; size 5; size 15; size 14; size 1; size 9;
size 12; size 5; size 1; size 15; size 14; size 13; size 4; size 10;
size 0; size 7; size 6; size 3; size 9; size 2; size 8; size 11;
size 13; size 11; size 7; size 14; size 12; size 1; size 3; size 9;
size 5; size 0; size 15; size 4; size 8; size 6; size 2; size 10;
size 6; size 15; size 14; size 9; size 11; size 3; size 0; size 8;
size 12; size 2; size 13; size 7; size 1; size 4; size 10; size 5;
size 10; size 2; size 8; size 4; size 7; size 6; size 1; size 5;
size 15; size 11; size 9; size 14; size 3; size 12; size 13; size 0
] in
assert_norm(List.Tot.length l == 160);
l
inline_for_extraction
let sigmaTable:lseq sigma_elt_t size_sigmaTable =
assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma
(* Functions *)
let g1 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (r:rotval (wt a)) : Tot (state a) =
wv.[i] <- (wv.[i] ^| wv.[j]) >>>| r
let g2 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (x:row a) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j] +| x)
let g2z (a:alg) (wv:state a) (i:row_idx) (j:row_idx) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j])
val blake2_mixing:
a:alg
-> ws:state a
-> row a
-> row a ->
Tot (state a)
let blake2_mixing al wv x y =
let a = 0 in
let b = 1 in
let c = 2 in
let d = 3 in
let rt = rTable al in
let wv = g2 al wv a b x in
let wv = g1 al wv d a rt.[0] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[1] in
let wv = g2 al wv a b y in
let wv = g1 al wv d a rt.[2] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[3] in
wv
let diag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 1 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 3 in
wv
let undiag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 3 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 1 in
wv
inline_for_extraction
let gather_row (#a:alg) (m:block_w a) (i0 i1 i2 i3:sigma_elt_t) : row a =
create_row m.[v i0] m.[v i1] m.[v i2] m.[v i3]
val gather_state: a:alg -> m:block_w a -> start:nat{start <= 144} -> state a
let gather_state a m start =
let x = gather_row m sigmaTable.[start] sigmaTable.[start+2] sigmaTable.[start+4] sigmaTable.[start+6] in
let y = gather_row m sigmaTable.[start+1] sigmaTable.[start+3] sigmaTable.[start+5] sigmaTable.[start+7] in
let z = gather_row m sigmaTable.[start+8] sigmaTable.[start+10] sigmaTable.[start+12] sigmaTable.[start+14] in
let w = gather_row m sigmaTable.[start+9] sigmaTable.[start+11] sigmaTable.[start+13] sigmaTable.[start+15] in
let l = [x;y;z;w] in
assert_norm (List.Tot.length l == 4);
createL l
val blake2_round:
a:alg
-> m:block_w a
-> i:size_nat
-> wv:state a
-> state a
let blake2_round a m i wv =
let start = (i%10) * 16 in
let m_s = gather_state a m start in
let wv = blake2_mixing a wv m_s.[0] m_s.[1] in
let wv = diag wv in
let wv = blake2_mixing a wv m_s.[2] m_s.[3] in
undiag wv
val blake2_compress0:
a:alg
-> m:block_s a
-> block_w a
let blake2_compress0 a m =
uints_from_bytes_le m
val blake2_compress1:
a:alg
-> s_iv:state a
-> offset:limb_t a
-> flag:bool ->
Tot (state a)
let blake2_compress1 a s_iv offset flag =
let wv : state a = s_iv in
let low_offset = limb_to_word a offset in
let high_offset = limb_to_word a (shift_right #(limb_inttype a) offset (size (bits (wt a)))) in
let m_12 = low_offset in
let m_13 = high_offset in
let m_14 = if flag then (ones (wt a) SEC) else zero a in
let m_15 = zero a in
let mask = create_row m_12 m_13 m_14 m_15 in
let wv = wv.[3] <- wv.[3] ^| mask in
wv
val blake2_compress2:
a:alg
-> wv:state a
-> m:block_w a ->
Tot (state a)
let blake2_compress2 a wv m = repeati (rounds a) (blake2_round a m) wv
val blake2_compress3:
a:alg
-> wv:state a
-> s_iv:state a ->
Tot (state a)
let blake2_compress3 a wv s =
let s = s.[0] <- (s.[0] ^| wv.[0]) ^| wv.[2] in
let s = s.[1] <- (s.[1] ^| wv.[1]) ^| wv.[3] in
s
val blake2_compress:
a:alg
-> s_iv:state a
-> m:block_s a
-> offset:limb_t a
-> flag:bool ->
Tot (state a)
let blake2_compress a s_iv m offset flag =
let m_w = blake2_compress0 a m in
let wv = blake2_compress1 a s_iv offset flag in
let wv = blake2_compress2 a wv m_w in
let s_iv = blake2_compress3 a wv s_iv in
s_iv
val blake2_update_block:
a:alg
-> flag:bool
-> totlen:nat{totlen <= max_limb a}
-> d:block_s a
-> s_iv:state a ->
Tot (state a)
let blake2_update_block a flag totlen d s =
let offset = nat_to_limb a totlen in
blake2_compress a s d offset flag
val blake2_update1:
a:alg
-> prev:nat
-> m:bytes
-> i:nat{i < length m / size_block a /\ prev + length m <= max_limb a}
-> s:state a ->
Tot (state a)
let get_blocki (a:alg) (m:bytes) (i:nat{i < length m / size_block a}) : block_s a =
Seq.slice m (i * size_block a) ((i+1) * size_block a)
let blake2_update1 a prev m i s =
let totlen = prev + (i+1) * size_block a in
let d = get_blocki a m i in
blake2_update_block a false totlen d s
val blake2_update_last:
a:alg
-> prev:nat
-> rem:nat
-> m:bytes{prev + length m <= max_limb a /\ rem <= length m /\ rem <= size_block a}
-> s:state a ->
Tot (state a)
let get_last_padded_block (a:alg) (m:bytes)
(rem:nat{rem <= length m /\ rem <= size_block a}) : block_s a =
let last = Seq.slice m (length m - rem) (length m) in
let last_block = create (size_block a) (u8 0) in
let last_block = update_sub last_block 0 rem last in
last_block
let blake2_update_last a prev rem m s =
let inlen = length m in
let totlen = prev + inlen in
let last_block = get_last_padded_block a m rem in
blake2_update_block a true totlen last_block s
val blake2_update_blocks:
a:alg
-> prev:nat
-> m:bytes{prev + length m <= max_limb a}
-> s:state a ->
Tot (state a)
let split (a:alg) (len:nat)
: nb_rem:(nat & nat){let (nb,rem) = nb_rem in
nb * size_block a + rem == len} =
UpdateMulti.split_at_last_lazy_nb_rem (size_block a) len
let blake2_update_blocks a prev m s =
let (nb,rem) = split a (length m) in
let s = repeati nb (blake2_update1 a prev m) s in
blake2_update_last a prev rem m s
val blake2_init_hash:
a:alg
-> p:blake2_params a
-> kk:size_nat{kk <= max_key a}
-> nn:size_nat{1 <= nn /\ nn <= max_output a} ->
Tot (state a)
let blake2_init_hash a p kk nn =
let iv0 = secret (ivTable a).[0] in
let iv1 = secret (ivTable a).[1] in
let iv2 = secret (ivTable a).[2] in
let iv3 = secret (ivTable a).[3] in
let iv4 = secret (ivTable a).[4] in
let iv5 = secret (ivTable a).[5] in
let iv6 = secret (ivTable a).[6] in
let iv7 = secret (ivTable a).[7] in
let r0 = create_row #a iv0 iv1 iv2 iv3 in
let r1 = create_row #a iv4 iv5 iv6 iv7 in
let p: blake2_params a =
set_key_length (set_digest_length p nn) kk
in
let s = serialize_blake2_params p in
let iv0' = iv0 ^. s.[0] in
let iv1' = iv1 ^. s.[1] in
let iv2' = iv2 ^. s.[2] in
let iv3' = iv3 ^. s.[3] in
let iv4' = iv4 ^. s.[4] in
let iv5' = iv5 ^. s.[5] in
let iv6' = iv6 ^. s.[6] in
let iv7' = iv7 ^. s.[7] in
let r0' = create_row #a iv0' iv1' iv2' iv3' in
let r1' = create_row #a iv4' iv5' iv6' iv7' in
let s_iv = createL [r0';r1';r0;r1] in
s_iv
val blake2_key_block:
a:alg
-> kk:size_nat{0 < kk /\ kk <= max_key a}
-> k:lbytes kk
-> block_s a
let blake2_key_block a kk k =
let key_block = create (size_block a) (u8 0) in
let key_block = update_sub key_block 0 kk k in
key_block
/// This function must be called only if the key is non empty (see the precondition)
val blake2_update_key:
a:alg
-> kk:size_nat{0 < kk /\ kk <= max_key a}
-> k:lbytes kk
-> ll:nat
-> s:state a ->
Tot (state a)
let blake2_update_key a kk k ll s =
let key_block = blake2_key_block a kk k in
if ll = 0 then
blake2_update_block a true (size_block a) key_block s
else
blake2_update_block a false (size_block a) key_block s
val blake2_update:
a:alg
-> kk:size_nat{kk <= max_key a}
-> k:lbytes kk
-> d:bytes{if kk = 0 then length d <= max_limb a else length d + (size_block a) <= max_limb a}
-> s:state a -> | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Blake2.Definitions.alg ->
kk: Lib.IntTypes.size_nat{kk <= Spec.Blake2.Definitions.max_key a} ->
k: Lib.ByteSequence.lbytes kk ->
d:
Lib.ByteSequence.bytes
{ (match kk = 0 with
| true -> Lib.Sequence.length d <= Spec.Blake2.Definitions.max_limb a
| _ ->
Lib.Sequence.length d + Spec.Blake2.Definitions.size_block a <=
Spec.Blake2.Definitions.max_limb a)
<:
Type0 } ->
s: Spec.Blake2.Definitions.state a
-> Spec.Blake2.Definitions.state a | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Spec.Blake2.Definitions.max_key",
"Lib.ByteSequence.lbytes",
"Lib.ByteSequence.bytes",
"Prims.op_Equality",
"Prims.int",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.Blake2.Definitions.max_limb",
"Prims.bool",
"Prims.op_Addition",
"Spec.Blake2.Definitions.size_block",
"Spec.Blake2.Definitions.state",
"Prims.op_GreaterThan",
"Spec.Blake2.blake2_update_blocks",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Spec.Blake2.Definitions.wt",
"Spec.Blake2.blake2_update_key",
"Prims.nat"
] | [] | false | false | false | false | false | let blake2_update a kk k d s =
| let ll = length d in
if kk > 0
then
let s = blake2_update_key a kk k ll s in
if ll = 0 then s else blake2_update_blocks a (size_block a) d s
else blake2_update_blocks a 0 d s | false |
PulseCore.InstantiatedSemantics.fst | PulseCore.InstantiatedSemantics.lower | val lower (t: Type u#a) : Type0 | val lower (t: Type u#a) : Type0 | let lower (t:Type u#a) : Type0 = unit -> Dv t | {
"file_name": "lib/pulse_core/PulseCore.InstantiatedSemantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 45,
"end_line": 114,
"start_col": 0,
"start_line": 114
} | module PulseCore.InstantiatedSemantics
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module U = FStar.Universe
module F = FStar.FunctionalExtensionality
open PulseCore.Memory
let laws ()
: squash (
Sem.associative star /\
Sem.commutative star /\
Sem.is_unit emp star
)
= let equiv_eq (x y:slprop)
: Lemma (x `equiv` y <==> x == y)
[SMTPat (x `equiv` y)]
= introduce x `equiv` y ==> x == y
with _h . slprop_extensionality x y
in
let _ : squash (Sem.associative star) =
introduce
forall x y z.
((x `star` y) `star` z) ==
(x `star` (y `star` z))
with star_associative x y z
in
let _ : squash (Sem.commutative star) =
introduce
forall x y.
x `star` y == y `star` x
with star_commutative x y
in
let _ : squash (Sem.is_unit emp star) =
introduce
forall x.
(x `star` emp) == x /\
(emp `star` x) == x
with emp_unit x
in
()
let state0 (e:inames) : Sem.state = {
max_act = U.raise_t u#0 u#100 unit;
s = mem;
is_full_mem = full_mem_pred;
pred = slprop;
emp = emp;
star = star;
interp = interp;
evolves = mem_evolves;
invariant = locks_invariant e;
laws = laws ()
}
let state : Sem.state = state0 Set.empty
let slprop = slprop
let _eq : squash (slprop == state.pred) = ()
let emp = emp
let pure p = pure p
let ( ** ) p q = p `star` q
let ( exists* ) #a p = h_exists (F.on_dom a p)
let prop_squash_idem (p:prop)
: Tot (squash (p == squash p))
= FStar.PropositionalExtensionality.apply p (squash p)
let slprop_equiv p q = Mem.equiv p q
let unsquash (p:squash (slprop_equiv 'p 'q)) : slprop_equiv 'p 'q =
prop_squash_idem (slprop_equiv 'p 'q);
coerce_eq () p
let slprop_equiv_refl p = unsquash ()
let slprop_equiv_elim p q =
introduce (p `slprop_equiv` q) ==> p==q
with _ . Mem.slprop_extensionality p q
let slprop_equiv_unit p = unsquash ()
let slprop_equiv_comm p1 p2 = unsquash ()
let slprop_equiv_assoc p1 p2 p3 = unsquash ()
module T = FStar.Tactics.V2
let slprop_equiv_exists
(#a:Type)
(p q: a -> slprop)
(_:squash (forall x. slprop_equiv (p x) (q x)))
= introduce forall x. p x == q x
with slprop_equiv_elim (p x) (q x);
F.extensionality _ _ p q;
let pf : squash (eq2 #(F.arrow a (fun _ -> slprop))
(F.on_dom a p)
(F.on_dom a q)) = ()
in
let x : squash (op_exists_Star p == op_exists_Star q) = _ by (
T.norm [delta_only [`%op_exists_Star; `%F.on_dom]; unascribe];
let bindings = T.cur_vars() in
let bindings = List.Tot.rev bindings in
match bindings with
| hd::_ -> (
match T.term_as_formula hd.sort with
| T.Comp (T.Eq _) lhs rhs ->
T.grewrite lhs rhs;
T.trefl();
T.exact (T.binding_to_term hd)
| _ -> T.fail "Unexpected type of hd"
)
| _ ->
T.fail "empty bindings"
) in
unsquash x | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.InstantiatedSemantics.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: Type -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.unit"
] | [] | false | false | false | true | true | let lower (t: Type u#a) : Type0 =
| unit -> Dv t | false |
Spec.Blake2.fst | Spec.Blake2.get_last_padded_block | val get_last_padded_block (a: alg) (m: bytes) (rem: nat{rem <= length m /\ rem <= size_block a})
: block_s a | val get_last_padded_block (a: alg) (m: bytes) (rem: nat{rem <= length m /\ rem <= size_block a})
: block_s a | let get_last_padded_block (a:alg) (m:bytes)
(rem:nat{rem <= length m /\ rem <= size_block a}) : block_s a =
let last = Seq.slice m (length m - rem) (length m) in
let last_block = create (size_block a) (u8 0) in
let last_block = update_sub last_block 0 rem last in
last_block | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 12,
"end_line": 342,
"start_col": 0,
"start_line": 337
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B
inline_for_extraction
let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B
[@"opaque_to_smt"]
let list_sigma: list_sigma_t =
[@inline_let]
let l : list sigma_elt_t = [
size 0; size 1; size 2; size 3; size 4; size 5; size 6; size 7;
size 8; size 9; size 10; size 11; size 12; size 13; size 14; size 15;
size 14; size 10; size 4; size 8; size 9; size 15; size 13; size 6;
size 1; size 12; size 0; size 2; size 11; size 7; size 5; size 3;
size 11; size 8; size 12; size 0; size 5; size 2; size 15; size 13;
size 10; size 14; size 3; size 6; size 7; size 1; size 9; size 4;
size 7; size 9; size 3; size 1; size 13; size 12; size 11; size 14;
size 2; size 6; size 5; size 10; size 4; size 0; size 15; size 8;
size 9; size 0; size 5; size 7; size 2; size 4; size 10; size 15;
size 14; size 1; size 11; size 12; size 6; size 8; size 3; size 13;
size 2; size 12; size 6; size 10; size 0; size 11; size 8; size 3;
size 4; size 13; size 7; size 5; size 15; size 14; size 1; size 9;
size 12; size 5; size 1; size 15; size 14; size 13; size 4; size 10;
size 0; size 7; size 6; size 3; size 9; size 2; size 8; size 11;
size 13; size 11; size 7; size 14; size 12; size 1; size 3; size 9;
size 5; size 0; size 15; size 4; size 8; size 6; size 2; size 10;
size 6; size 15; size 14; size 9; size 11; size 3; size 0; size 8;
size 12; size 2; size 13; size 7; size 1; size 4; size 10; size 5;
size 10; size 2; size 8; size 4; size 7; size 6; size 1; size 5;
size 15; size 11; size 9; size 14; size 3; size 12; size 13; size 0
] in
assert_norm(List.Tot.length l == 160);
l
inline_for_extraction
let sigmaTable:lseq sigma_elt_t size_sigmaTable =
assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma
(* Functions *)
let g1 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (r:rotval (wt a)) : Tot (state a) =
wv.[i] <- (wv.[i] ^| wv.[j]) >>>| r
let g2 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (x:row a) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j] +| x)
let g2z (a:alg) (wv:state a) (i:row_idx) (j:row_idx) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j])
val blake2_mixing:
a:alg
-> ws:state a
-> row a
-> row a ->
Tot (state a)
let blake2_mixing al wv x y =
let a = 0 in
let b = 1 in
let c = 2 in
let d = 3 in
let rt = rTable al in
let wv = g2 al wv a b x in
let wv = g1 al wv d a rt.[0] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[1] in
let wv = g2 al wv a b y in
let wv = g1 al wv d a rt.[2] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[3] in
wv
let diag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 1 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 3 in
wv
let undiag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 3 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 1 in
wv
inline_for_extraction
let gather_row (#a:alg) (m:block_w a) (i0 i1 i2 i3:sigma_elt_t) : row a =
create_row m.[v i0] m.[v i1] m.[v i2] m.[v i3]
val gather_state: a:alg -> m:block_w a -> start:nat{start <= 144} -> state a
let gather_state a m start =
let x = gather_row m sigmaTable.[start] sigmaTable.[start+2] sigmaTable.[start+4] sigmaTable.[start+6] in
let y = gather_row m sigmaTable.[start+1] sigmaTable.[start+3] sigmaTable.[start+5] sigmaTable.[start+7] in
let z = gather_row m sigmaTable.[start+8] sigmaTable.[start+10] sigmaTable.[start+12] sigmaTable.[start+14] in
let w = gather_row m sigmaTable.[start+9] sigmaTable.[start+11] sigmaTable.[start+13] sigmaTable.[start+15] in
let l = [x;y;z;w] in
assert_norm (List.Tot.length l == 4);
createL l
val blake2_round:
a:alg
-> m:block_w a
-> i:size_nat
-> wv:state a
-> state a
let blake2_round a m i wv =
let start = (i%10) * 16 in
let m_s = gather_state a m start in
let wv = blake2_mixing a wv m_s.[0] m_s.[1] in
let wv = diag wv in
let wv = blake2_mixing a wv m_s.[2] m_s.[3] in
undiag wv
val blake2_compress0:
a:alg
-> m:block_s a
-> block_w a
let blake2_compress0 a m =
uints_from_bytes_le m
val blake2_compress1:
a:alg
-> s_iv:state a
-> offset:limb_t a
-> flag:bool ->
Tot (state a)
let blake2_compress1 a s_iv offset flag =
let wv : state a = s_iv in
let low_offset = limb_to_word a offset in
let high_offset = limb_to_word a (shift_right #(limb_inttype a) offset (size (bits (wt a)))) in
let m_12 = low_offset in
let m_13 = high_offset in
let m_14 = if flag then (ones (wt a) SEC) else zero a in
let m_15 = zero a in
let mask = create_row m_12 m_13 m_14 m_15 in
let wv = wv.[3] <- wv.[3] ^| mask in
wv
val blake2_compress2:
a:alg
-> wv:state a
-> m:block_w a ->
Tot (state a)
let blake2_compress2 a wv m = repeati (rounds a) (blake2_round a m) wv
val blake2_compress3:
a:alg
-> wv:state a
-> s_iv:state a ->
Tot (state a)
let blake2_compress3 a wv s =
let s = s.[0] <- (s.[0] ^| wv.[0]) ^| wv.[2] in
let s = s.[1] <- (s.[1] ^| wv.[1]) ^| wv.[3] in
s
val blake2_compress:
a:alg
-> s_iv:state a
-> m:block_s a
-> offset:limb_t a
-> flag:bool ->
Tot (state a)
let blake2_compress a s_iv m offset flag =
let m_w = blake2_compress0 a m in
let wv = blake2_compress1 a s_iv offset flag in
let wv = blake2_compress2 a wv m_w in
let s_iv = blake2_compress3 a wv s_iv in
s_iv
val blake2_update_block:
a:alg
-> flag:bool
-> totlen:nat{totlen <= max_limb a}
-> d:block_s a
-> s_iv:state a ->
Tot (state a)
let blake2_update_block a flag totlen d s =
let offset = nat_to_limb a totlen in
blake2_compress a s d offset flag
val blake2_update1:
a:alg
-> prev:nat
-> m:bytes
-> i:nat{i < length m / size_block a /\ prev + length m <= max_limb a}
-> s:state a ->
Tot (state a)
let get_blocki (a:alg) (m:bytes) (i:nat{i < length m / size_block a}) : block_s a =
Seq.slice m (i * size_block a) ((i+1) * size_block a)
let blake2_update1 a prev m i s =
let totlen = prev + (i+1) * size_block a in
let d = get_blocki a m i in
blake2_update_block a false totlen d s
val blake2_update_last:
a:alg
-> prev:nat
-> rem:nat
-> m:bytes{prev + length m <= max_limb a /\ rem <= length m /\ rem <= size_block a}
-> s:state a ->
Tot (state a) | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Blake2.Definitions.alg ->
m: Lib.ByteSequence.bytes ->
rem: Prims.nat{rem <= Lib.Sequence.length m /\ rem <= Spec.Blake2.Definitions.size_block a}
-> Spec.Blake2.Definitions.block_s a | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Lib.ByteSequence.bytes",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.Blake2.Definitions.size_block",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Prims.eq2",
"Lib.Sequence.sub",
"Prims.l_Forall",
"Prims.l_or",
"Prims.op_LessThan",
"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",
"Prims.l_imp",
"Lib.Sequence.create",
"Lib.IntTypes.u8",
"FStar.Seq.Base.slice",
"Prims.op_Subtraction",
"Spec.Blake2.Definitions.block_s"
] | [] | false | false | false | false | false | let get_last_padded_block (a: alg) (m: bytes) (rem: nat{rem <= length m /\ rem <= size_block a})
: block_s a =
| let last = Seq.slice m (length m - rem) (length m) in
let last_block = create (size_block a) (u8 0) in
let last_block = update_sub last_block 0 rem last in
last_block | false |
PulseCore.InstantiatedSemantics.fst | PulseCore.InstantiatedSemantics.return | val return (#a:Type u#a) (x:a) (p:a -> slprop)
: stt a (p x) p | val return (#a:Type u#a) (x:a) (p:a -> slprop)
: stt a (p x) p | let return (#a:Type u#a) (x:a) (p:a -> slprop)
: stt a (p x) p
= fun _ -> Sem.ret x (F.on_dom a p) | {
"file_name": "lib/pulse_core/PulseCore.InstantiatedSemantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 35,
"end_line": 123,
"start_col": 0,
"start_line": 121
} | module PulseCore.InstantiatedSemantics
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module U = FStar.Universe
module F = FStar.FunctionalExtensionality
open PulseCore.Memory
let laws ()
: squash (
Sem.associative star /\
Sem.commutative star /\
Sem.is_unit emp star
)
= let equiv_eq (x y:slprop)
: Lemma (x `equiv` y <==> x == y)
[SMTPat (x `equiv` y)]
= introduce x `equiv` y ==> x == y
with _h . slprop_extensionality x y
in
let _ : squash (Sem.associative star) =
introduce
forall x y z.
((x `star` y) `star` z) ==
(x `star` (y `star` z))
with star_associative x y z
in
let _ : squash (Sem.commutative star) =
introduce
forall x y.
x `star` y == y `star` x
with star_commutative x y
in
let _ : squash (Sem.is_unit emp star) =
introduce
forall x.
(x `star` emp) == x /\
(emp `star` x) == x
with emp_unit x
in
()
let state0 (e:inames) : Sem.state = {
max_act = U.raise_t u#0 u#100 unit;
s = mem;
is_full_mem = full_mem_pred;
pred = slprop;
emp = emp;
star = star;
interp = interp;
evolves = mem_evolves;
invariant = locks_invariant e;
laws = laws ()
}
let state : Sem.state = state0 Set.empty
let slprop = slprop
let _eq : squash (slprop == state.pred) = ()
let emp = emp
let pure p = pure p
let ( ** ) p q = p `star` q
let ( exists* ) #a p = h_exists (F.on_dom a p)
let prop_squash_idem (p:prop)
: Tot (squash (p == squash p))
= FStar.PropositionalExtensionality.apply p (squash p)
let slprop_equiv p q = Mem.equiv p q
let unsquash (p:squash (slprop_equiv 'p 'q)) : slprop_equiv 'p 'q =
prop_squash_idem (slprop_equiv 'p 'q);
coerce_eq () p
let slprop_equiv_refl p = unsquash ()
let slprop_equiv_elim p q =
introduce (p `slprop_equiv` q) ==> p==q
with _ . Mem.slprop_extensionality p q
let slprop_equiv_unit p = unsquash ()
let slprop_equiv_comm p1 p2 = unsquash ()
let slprop_equiv_assoc p1 p2 p3 = unsquash ()
module T = FStar.Tactics.V2
let slprop_equiv_exists
(#a:Type)
(p q: a -> slprop)
(_:squash (forall x. slprop_equiv (p x) (q x)))
= introduce forall x. p x == q x
with slprop_equiv_elim (p x) (q x);
F.extensionality _ _ p q;
let pf : squash (eq2 #(F.arrow a (fun _ -> slprop))
(F.on_dom a p)
(F.on_dom a q)) = ()
in
let x : squash (op_exists_Star p == op_exists_Star q) = _ by (
T.norm [delta_only [`%op_exists_Star; `%F.on_dom]; unascribe];
let bindings = T.cur_vars() in
let bindings = List.Tot.rev bindings in
match bindings with
| hd::_ -> (
match T.term_as_formula hd.sort with
| T.Comp (T.Eq _) lhs rhs ->
T.grewrite lhs rhs;
T.trefl();
T.exact (T.binding_to_term hd)
| _ -> T.fail "Unexpected type of hd"
)
| _ ->
T.fail "empty bindings"
) in
unsquash x
(* The type of general-purpose computations *)
let lower (t:Type u#a) : Type0 = unit -> Dv t
let stt (a:Type u#a)
(pre:slprop)
(post:a -> slprop)
: Type0
= lower (Sem.m u#2 u#100 u#a #state a pre (F.on_dom a post)) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.InstantiatedSemantics.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x: a -> p: (_: a -> PulseCore.InstantiatedSemantics.slprop)
-> PulseCore.InstantiatedSemantics.stt a (p x) p | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"Prims.unit",
"PulseCore.Semantics.ret",
"PulseCore.InstantiatedSemantics.state",
"FStar.FunctionalExtensionality.on_dom",
"PulseCore.Semantics.__proj__Mkstate__item__pred",
"PulseCore.Semantics.m",
"FStar.FunctionalExtensionality.on_domain",
"PulseCore.InstantiatedSemantics.stt"
] | [] | false | false | false | false | false | let return (#a: Type u#a) (x: a) (p: (a -> slprop)) : stt a (p x) p =
| fun _ -> Sem.ret x (F.on_dom a p) | false |
Spec.Blake2.fst | Spec.Blake2.blake2 | val blake2:
a:alg
-> d:bytes
-> p:blake2_params a
-> kk:size_nat{kk <= max_key a /\ (if kk = 0 then length d <= max_limb a else length d + (size_block a) <= max_limb a)}
-> k:lbytes kk
-> nn:size_nat{1 <= nn /\ nn <= max_output a} ->
Tot (lbytes nn) | val blake2:
a:alg
-> d:bytes
-> p:blake2_params a
-> kk:size_nat{kk <= max_key a /\ (if kk = 0 then length d <= max_limb a else length d + (size_block a) <= max_limb a)}
-> k:lbytes kk
-> nn:size_nat{1 <= nn /\ nn <= max_output a} ->
Tot (lbytes nn) | let blake2 a d p kk k nn =
let s = blake2_init_hash a p kk nn in
let s = blake2_update a kk k d s in
blake2_finish a s nn | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 465,
"start_col": 0,
"start_line": 462
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B
inline_for_extraction
let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B
[@"opaque_to_smt"]
let list_sigma: list_sigma_t =
[@inline_let]
let l : list sigma_elt_t = [
size 0; size 1; size 2; size 3; size 4; size 5; size 6; size 7;
size 8; size 9; size 10; size 11; size 12; size 13; size 14; size 15;
size 14; size 10; size 4; size 8; size 9; size 15; size 13; size 6;
size 1; size 12; size 0; size 2; size 11; size 7; size 5; size 3;
size 11; size 8; size 12; size 0; size 5; size 2; size 15; size 13;
size 10; size 14; size 3; size 6; size 7; size 1; size 9; size 4;
size 7; size 9; size 3; size 1; size 13; size 12; size 11; size 14;
size 2; size 6; size 5; size 10; size 4; size 0; size 15; size 8;
size 9; size 0; size 5; size 7; size 2; size 4; size 10; size 15;
size 14; size 1; size 11; size 12; size 6; size 8; size 3; size 13;
size 2; size 12; size 6; size 10; size 0; size 11; size 8; size 3;
size 4; size 13; size 7; size 5; size 15; size 14; size 1; size 9;
size 12; size 5; size 1; size 15; size 14; size 13; size 4; size 10;
size 0; size 7; size 6; size 3; size 9; size 2; size 8; size 11;
size 13; size 11; size 7; size 14; size 12; size 1; size 3; size 9;
size 5; size 0; size 15; size 4; size 8; size 6; size 2; size 10;
size 6; size 15; size 14; size 9; size 11; size 3; size 0; size 8;
size 12; size 2; size 13; size 7; size 1; size 4; size 10; size 5;
size 10; size 2; size 8; size 4; size 7; size 6; size 1; size 5;
size 15; size 11; size 9; size 14; size 3; size 12; size 13; size 0
] in
assert_norm(List.Tot.length l == 160);
l
inline_for_extraction
let sigmaTable:lseq sigma_elt_t size_sigmaTable =
assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma
(* Functions *)
let g1 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (r:rotval (wt a)) : Tot (state a) =
wv.[i] <- (wv.[i] ^| wv.[j]) >>>| r
let g2 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (x:row a) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j] +| x)
let g2z (a:alg) (wv:state a) (i:row_idx) (j:row_idx) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j])
val blake2_mixing:
a:alg
-> ws:state a
-> row a
-> row a ->
Tot (state a)
let blake2_mixing al wv x y =
let a = 0 in
let b = 1 in
let c = 2 in
let d = 3 in
let rt = rTable al in
let wv = g2 al wv a b x in
let wv = g1 al wv d a rt.[0] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[1] in
let wv = g2 al wv a b y in
let wv = g1 al wv d a rt.[2] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[3] in
wv
let diag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 1 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 3 in
wv
let undiag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 3 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 1 in
wv
inline_for_extraction
let gather_row (#a:alg) (m:block_w a) (i0 i1 i2 i3:sigma_elt_t) : row a =
create_row m.[v i0] m.[v i1] m.[v i2] m.[v i3]
val gather_state: a:alg -> m:block_w a -> start:nat{start <= 144} -> state a
let gather_state a m start =
let x = gather_row m sigmaTable.[start] sigmaTable.[start+2] sigmaTable.[start+4] sigmaTable.[start+6] in
let y = gather_row m sigmaTable.[start+1] sigmaTable.[start+3] sigmaTable.[start+5] sigmaTable.[start+7] in
let z = gather_row m sigmaTable.[start+8] sigmaTable.[start+10] sigmaTable.[start+12] sigmaTable.[start+14] in
let w = gather_row m sigmaTable.[start+9] sigmaTable.[start+11] sigmaTable.[start+13] sigmaTable.[start+15] in
let l = [x;y;z;w] in
assert_norm (List.Tot.length l == 4);
createL l
val blake2_round:
a:alg
-> m:block_w a
-> i:size_nat
-> wv:state a
-> state a
let blake2_round a m i wv =
let start = (i%10) * 16 in
let m_s = gather_state a m start in
let wv = blake2_mixing a wv m_s.[0] m_s.[1] in
let wv = diag wv in
let wv = blake2_mixing a wv m_s.[2] m_s.[3] in
undiag wv
val blake2_compress0:
a:alg
-> m:block_s a
-> block_w a
let blake2_compress0 a m =
uints_from_bytes_le m
val blake2_compress1:
a:alg
-> s_iv:state a
-> offset:limb_t a
-> flag:bool ->
Tot (state a)
let blake2_compress1 a s_iv offset flag =
let wv : state a = s_iv in
let low_offset = limb_to_word a offset in
let high_offset = limb_to_word a (shift_right #(limb_inttype a) offset (size (bits (wt a)))) in
let m_12 = low_offset in
let m_13 = high_offset in
let m_14 = if flag then (ones (wt a) SEC) else zero a in
let m_15 = zero a in
let mask = create_row m_12 m_13 m_14 m_15 in
let wv = wv.[3] <- wv.[3] ^| mask in
wv
val blake2_compress2:
a:alg
-> wv:state a
-> m:block_w a ->
Tot (state a)
let blake2_compress2 a wv m = repeati (rounds a) (blake2_round a m) wv
val blake2_compress3:
a:alg
-> wv:state a
-> s_iv:state a ->
Tot (state a)
let blake2_compress3 a wv s =
let s = s.[0] <- (s.[0] ^| wv.[0]) ^| wv.[2] in
let s = s.[1] <- (s.[1] ^| wv.[1]) ^| wv.[3] in
s
val blake2_compress:
a:alg
-> s_iv:state a
-> m:block_s a
-> offset:limb_t a
-> flag:bool ->
Tot (state a)
let blake2_compress a s_iv m offset flag =
let m_w = blake2_compress0 a m in
let wv = blake2_compress1 a s_iv offset flag in
let wv = blake2_compress2 a wv m_w in
let s_iv = blake2_compress3 a wv s_iv in
s_iv
val blake2_update_block:
a:alg
-> flag:bool
-> totlen:nat{totlen <= max_limb a}
-> d:block_s a
-> s_iv:state a ->
Tot (state a)
let blake2_update_block a flag totlen d s =
let offset = nat_to_limb a totlen in
blake2_compress a s d offset flag
val blake2_update1:
a:alg
-> prev:nat
-> m:bytes
-> i:nat{i < length m / size_block a /\ prev + length m <= max_limb a}
-> s:state a ->
Tot (state a)
let get_blocki (a:alg) (m:bytes) (i:nat{i < length m / size_block a}) : block_s a =
Seq.slice m (i * size_block a) ((i+1) * size_block a)
let blake2_update1 a prev m i s =
let totlen = prev + (i+1) * size_block a in
let d = get_blocki a m i in
blake2_update_block a false totlen d s
val blake2_update_last:
a:alg
-> prev:nat
-> rem:nat
-> m:bytes{prev + length m <= max_limb a /\ rem <= length m /\ rem <= size_block a}
-> s:state a ->
Tot (state a)
let get_last_padded_block (a:alg) (m:bytes)
(rem:nat{rem <= length m /\ rem <= size_block a}) : block_s a =
let last = Seq.slice m (length m - rem) (length m) in
let last_block = create (size_block a) (u8 0) in
let last_block = update_sub last_block 0 rem last in
last_block
let blake2_update_last a prev rem m s =
let inlen = length m in
let totlen = prev + inlen in
let last_block = get_last_padded_block a m rem in
blake2_update_block a true totlen last_block s
val blake2_update_blocks:
a:alg
-> prev:nat
-> m:bytes{prev + length m <= max_limb a}
-> s:state a ->
Tot (state a)
let split (a:alg) (len:nat)
: nb_rem:(nat & nat){let (nb,rem) = nb_rem in
nb * size_block a + rem == len} =
UpdateMulti.split_at_last_lazy_nb_rem (size_block a) len
let blake2_update_blocks a prev m s =
let (nb,rem) = split a (length m) in
let s = repeati nb (blake2_update1 a prev m) s in
blake2_update_last a prev rem m s
val blake2_init_hash:
a:alg
-> p:blake2_params a
-> kk:size_nat{kk <= max_key a}
-> nn:size_nat{1 <= nn /\ nn <= max_output a} ->
Tot (state a)
let blake2_init_hash a p kk nn =
let iv0 = secret (ivTable a).[0] in
let iv1 = secret (ivTable a).[1] in
let iv2 = secret (ivTable a).[2] in
let iv3 = secret (ivTable a).[3] in
let iv4 = secret (ivTable a).[4] in
let iv5 = secret (ivTable a).[5] in
let iv6 = secret (ivTable a).[6] in
let iv7 = secret (ivTable a).[7] in
let r0 = create_row #a iv0 iv1 iv2 iv3 in
let r1 = create_row #a iv4 iv5 iv6 iv7 in
let p: blake2_params a =
set_key_length (set_digest_length p nn) kk
in
let s = serialize_blake2_params p in
let iv0' = iv0 ^. s.[0] in
let iv1' = iv1 ^. s.[1] in
let iv2' = iv2 ^. s.[2] in
let iv3' = iv3 ^. s.[3] in
let iv4' = iv4 ^. s.[4] in
let iv5' = iv5 ^. s.[5] in
let iv6' = iv6 ^. s.[6] in
let iv7' = iv7 ^. s.[7] in
let r0' = create_row #a iv0' iv1' iv2' iv3' in
let r1' = create_row #a iv4' iv5' iv6' iv7' in
let s_iv = createL [r0';r1';r0;r1] in
s_iv
val blake2_key_block:
a:alg
-> kk:size_nat{0 < kk /\ kk <= max_key a}
-> k:lbytes kk
-> block_s a
let blake2_key_block a kk k =
let key_block = create (size_block a) (u8 0) in
let key_block = update_sub key_block 0 kk k in
key_block
/// This function must be called only if the key is non empty (see the precondition)
val blake2_update_key:
a:alg
-> kk:size_nat{0 < kk /\ kk <= max_key a}
-> k:lbytes kk
-> ll:nat
-> s:state a ->
Tot (state a)
let blake2_update_key a kk k ll s =
let key_block = blake2_key_block a kk k in
if ll = 0 then
blake2_update_block a true (size_block a) key_block s
else
blake2_update_block a false (size_block a) key_block s
val blake2_update:
a:alg
-> kk:size_nat{kk <= max_key a}
-> k:lbytes kk
-> d:bytes{if kk = 0 then length d <= max_limb a else length d + (size_block a) <= max_limb a}
-> s:state a ->
Tot (state a)
let blake2_update a kk k d s =
let ll = length d in
if kk > 0 then
let s = blake2_update_key a kk k ll s in
if ll = 0 then s // Skip update_last if ll = 0 (but kk > 0)
else blake2_update_blocks a (size_block a) d s
else blake2_update_blocks a 0 d s
val blake2_finish:
a:alg
-> s:state a
-> nn:size_nat{1 <= nn /\ nn <= max_output a} ->
Tot (lbytes nn)
let blake2_finish a s nn =
let full = (uints_to_bytes_le s.[0] @| uints_to_bytes_le s.[1]) in
sub full 0 nn
val blake2:
a:alg
-> d:bytes
-> p:blake2_params a
-> kk:size_nat{kk <= max_key a /\ (if kk = 0 then length d <= max_limb a else length d + (size_block a) <= max_limb a)}
-> k:lbytes kk
-> nn:size_nat{1 <= nn /\ nn <= max_output a} ->
Tot (lbytes nn) | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Blake2.Definitions.alg ->
d: Lib.ByteSequence.bytes ->
p: Spec.Blake2.Definitions.blake2_params a ->
kk:
Lib.IntTypes.size_nat
{ kk <= Spec.Blake2.Definitions.max_key a /\
(match kk = 0 with
| true -> Lib.Sequence.length d <= Spec.Blake2.Definitions.max_limb a
| _ ->
Lib.Sequence.length d + Spec.Blake2.Definitions.size_block a <=
Spec.Blake2.Definitions.max_limb a) } ->
k: Lib.ByteSequence.lbytes kk ->
nn: Lib.IntTypes.size_nat{1 <= nn /\ nn <= Spec.Blake2.Definitions.max_output a}
-> Lib.ByteSequence.lbytes nn | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Lib.ByteSequence.bytes",
"Spec.Blake2.Definitions.blake2_params",
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Spec.Blake2.Definitions.max_key",
"Prims.op_Equality",
"Prims.int",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.Blake2.Definitions.max_limb",
"Prims.bool",
"Prims.op_Addition",
"Spec.Blake2.Definitions.size_block",
"Prims.logical",
"Lib.ByteSequence.lbytes",
"Spec.Blake2.Definitions.max_output",
"Spec.Blake2.blake2_finish",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Spec.Blake2.Definitions.wt",
"Spec.Blake2.blake2_update",
"Spec.Blake2.blake2_init_hash"
] | [] | false | false | false | false | false | let blake2 a d p kk k nn =
| let s = blake2_init_hash a p kk nn in
let s = blake2_update a kk k d s in
blake2_finish a s nn | false |
Spec.Blake2.fst | Spec.Blake2.blake2_key_block | val blake2_key_block:
a:alg
-> kk:size_nat{0 < kk /\ kk <= max_key a}
-> k:lbytes kk
-> block_s a | val blake2_key_block:
a:alg
-> kk:size_nat{0 < kk /\ kk <= max_key a}
-> k:lbytes kk
-> block_s a | let blake2_key_block a kk k =
let key_block = create (size_block a) (u8 0) in
let key_block = update_sub key_block 0 kk k in
key_block | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 411,
"start_col": 0,
"start_line": 408
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B
inline_for_extraction
let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B
[@"opaque_to_smt"]
let list_sigma: list_sigma_t =
[@inline_let]
let l : list sigma_elt_t = [
size 0; size 1; size 2; size 3; size 4; size 5; size 6; size 7;
size 8; size 9; size 10; size 11; size 12; size 13; size 14; size 15;
size 14; size 10; size 4; size 8; size 9; size 15; size 13; size 6;
size 1; size 12; size 0; size 2; size 11; size 7; size 5; size 3;
size 11; size 8; size 12; size 0; size 5; size 2; size 15; size 13;
size 10; size 14; size 3; size 6; size 7; size 1; size 9; size 4;
size 7; size 9; size 3; size 1; size 13; size 12; size 11; size 14;
size 2; size 6; size 5; size 10; size 4; size 0; size 15; size 8;
size 9; size 0; size 5; size 7; size 2; size 4; size 10; size 15;
size 14; size 1; size 11; size 12; size 6; size 8; size 3; size 13;
size 2; size 12; size 6; size 10; size 0; size 11; size 8; size 3;
size 4; size 13; size 7; size 5; size 15; size 14; size 1; size 9;
size 12; size 5; size 1; size 15; size 14; size 13; size 4; size 10;
size 0; size 7; size 6; size 3; size 9; size 2; size 8; size 11;
size 13; size 11; size 7; size 14; size 12; size 1; size 3; size 9;
size 5; size 0; size 15; size 4; size 8; size 6; size 2; size 10;
size 6; size 15; size 14; size 9; size 11; size 3; size 0; size 8;
size 12; size 2; size 13; size 7; size 1; size 4; size 10; size 5;
size 10; size 2; size 8; size 4; size 7; size 6; size 1; size 5;
size 15; size 11; size 9; size 14; size 3; size 12; size 13; size 0
] in
assert_norm(List.Tot.length l == 160);
l
inline_for_extraction
let sigmaTable:lseq sigma_elt_t size_sigmaTable =
assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma
(* Functions *)
let g1 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (r:rotval (wt a)) : Tot (state a) =
wv.[i] <- (wv.[i] ^| wv.[j]) >>>| r
let g2 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (x:row a) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j] +| x)
let g2z (a:alg) (wv:state a) (i:row_idx) (j:row_idx) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j])
val blake2_mixing:
a:alg
-> ws:state a
-> row a
-> row a ->
Tot (state a)
let blake2_mixing al wv x y =
let a = 0 in
let b = 1 in
let c = 2 in
let d = 3 in
let rt = rTable al in
let wv = g2 al wv a b x in
let wv = g1 al wv d a rt.[0] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[1] in
let wv = g2 al wv a b y in
let wv = g1 al wv d a rt.[2] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[3] in
wv
let diag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 1 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 3 in
wv
let undiag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 3 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 1 in
wv
inline_for_extraction
let gather_row (#a:alg) (m:block_w a) (i0 i1 i2 i3:sigma_elt_t) : row a =
create_row m.[v i0] m.[v i1] m.[v i2] m.[v i3]
val gather_state: a:alg -> m:block_w a -> start:nat{start <= 144} -> state a
let gather_state a m start =
let x = gather_row m sigmaTable.[start] sigmaTable.[start+2] sigmaTable.[start+4] sigmaTable.[start+6] in
let y = gather_row m sigmaTable.[start+1] sigmaTable.[start+3] sigmaTable.[start+5] sigmaTable.[start+7] in
let z = gather_row m sigmaTable.[start+8] sigmaTable.[start+10] sigmaTable.[start+12] sigmaTable.[start+14] in
let w = gather_row m sigmaTable.[start+9] sigmaTable.[start+11] sigmaTable.[start+13] sigmaTable.[start+15] in
let l = [x;y;z;w] in
assert_norm (List.Tot.length l == 4);
createL l
val blake2_round:
a:alg
-> m:block_w a
-> i:size_nat
-> wv:state a
-> state a
let blake2_round a m i wv =
let start = (i%10) * 16 in
let m_s = gather_state a m start in
let wv = blake2_mixing a wv m_s.[0] m_s.[1] in
let wv = diag wv in
let wv = blake2_mixing a wv m_s.[2] m_s.[3] in
undiag wv
val blake2_compress0:
a:alg
-> m:block_s a
-> block_w a
let blake2_compress0 a m =
uints_from_bytes_le m
val blake2_compress1:
a:alg
-> s_iv:state a
-> offset:limb_t a
-> flag:bool ->
Tot (state a)
let blake2_compress1 a s_iv offset flag =
let wv : state a = s_iv in
let low_offset = limb_to_word a offset in
let high_offset = limb_to_word a (shift_right #(limb_inttype a) offset (size (bits (wt a)))) in
let m_12 = low_offset in
let m_13 = high_offset in
let m_14 = if flag then (ones (wt a) SEC) else zero a in
let m_15 = zero a in
let mask = create_row m_12 m_13 m_14 m_15 in
let wv = wv.[3] <- wv.[3] ^| mask in
wv
val blake2_compress2:
a:alg
-> wv:state a
-> m:block_w a ->
Tot (state a)
let blake2_compress2 a wv m = repeati (rounds a) (blake2_round a m) wv
val blake2_compress3:
a:alg
-> wv:state a
-> s_iv:state a ->
Tot (state a)
let blake2_compress3 a wv s =
let s = s.[0] <- (s.[0] ^| wv.[0]) ^| wv.[2] in
let s = s.[1] <- (s.[1] ^| wv.[1]) ^| wv.[3] in
s
val blake2_compress:
a:alg
-> s_iv:state a
-> m:block_s a
-> offset:limb_t a
-> flag:bool ->
Tot (state a)
let blake2_compress a s_iv m offset flag =
let m_w = blake2_compress0 a m in
let wv = blake2_compress1 a s_iv offset flag in
let wv = blake2_compress2 a wv m_w in
let s_iv = blake2_compress3 a wv s_iv in
s_iv
val blake2_update_block:
a:alg
-> flag:bool
-> totlen:nat{totlen <= max_limb a}
-> d:block_s a
-> s_iv:state a ->
Tot (state a)
let blake2_update_block a flag totlen d s =
let offset = nat_to_limb a totlen in
blake2_compress a s d offset flag
val blake2_update1:
a:alg
-> prev:nat
-> m:bytes
-> i:nat{i < length m / size_block a /\ prev + length m <= max_limb a}
-> s:state a ->
Tot (state a)
let get_blocki (a:alg) (m:bytes) (i:nat{i < length m / size_block a}) : block_s a =
Seq.slice m (i * size_block a) ((i+1) * size_block a)
let blake2_update1 a prev m i s =
let totlen = prev + (i+1) * size_block a in
let d = get_blocki a m i in
blake2_update_block a false totlen d s
val blake2_update_last:
a:alg
-> prev:nat
-> rem:nat
-> m:bytes{prev + length m <= max_limb a /\ rem <= length m /\ rem <= size_block a}
-> s:state a ->
Tot (state a)
let get_last_padded_block (a:alg) (m:bytes)
(rem:nat{rem <= length m /\ rem <= size_block a}) : block_s a =
let last = Seq.slice m (length m - rem) (length m) in
let last_block = create (size_block a) (u8 0) in
let last_block = update_sub last_block 0 rem last in
last_block
let blake2_update_last a prev rem m s =
let inlen = length m in
let totlen = prev + inlen in
let last_block = get_last_padded_block a m rem in
blake2_update_block a true totlen last_block s
val blake2_update_blocks:
a:alg
-> prev:nat
-> m:bytes{prev + length m <= max_limb a}
-> s:state a ->
Tot (state a)
let split (a:alg) (len:nat)
: nb_rem:(nat & nat){let (nb,rem) = nb_rem in
nb * size_block a + rem == len} =
UpdateMulti.split_at_last_lazy_nb_rem (size_block a) len
let blake2_update_blocks a prev m s =
let (nb,rem) = split a (length m) in
let s = repeati nb (blake2_update1 a prev m) s in
blake2_update_last a prev rem m s
val blake2_init_hash:
a:alg
-> p:blake2_params a
-> kk:size_nat{kk <= max_key a}
-> nn:size_nat{1 <= nn /\ nn <= max_output a} ->
Tot (state a)
let blake2_init_hash a p kk nn =
let iv0 = secret (ivTable a).[0] in
let iv1 = secret (ivTable a).[1] in
let iv2 = secret (ivTable a).[2] in
let iv3 = secret (ivTable a).[3] in
let iv4 = secret (ivTable a).[4] in
let iv5 = secret (ivTable a).[5] in
let iv6 = secret (ivTable a).[6] in
let iv7 = secret (ivTable a).[7] in
let r0 = create_row #a iv0 iv1 iv2 iv3 in
let r1 = create_row #a iv4 iv5 iv6 iv7 in
let p: blake2_params a =
set_key_length (set_digest_length p nn) kk
in
let s = serialize_blake2_params p in
let iv0' = iv0 ^. s.[0] in
let iv1' = iv1 ^. s.[1] in
let iv2' = iv2 ^. s.[2] in
let iv3' = iv3 ^. s.[3] in
let iv4' = iv4 ^. s.[4] in
let iv5' = iv5 ^. s.[5] in
let iv6' = iv6 ^. s.[6] in
let iv7' = iv7 ^. s.[7] in
let r0' = create_row #a iv0' iv1' iv2' iv3' in
let r1' = create_row #a iv4' iv5' iv6' iv7' in
let s_iv = createL [r0';r1';r0;r1] in
s_iv
val blake2_key_block:
a:alg
-> kk:size_nat{0 < kk /\ kk <= max_key a}
-> k:lbytes kk | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Blake2.Definitions.alg ->
kk: Lib.IntTypes.size_nat{0 < kk /\ kk <= Spec.Blake2.Definitions.max_key a} ->
k: Lib.ByteSequence.lbytes kk
-> Spec.Blake2.Definitions.block_s a | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"Spec.Blake2.Definitions.max_key",
"Lib.ByteSequence.lbytes",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.Blake2.Definitions.size_block",
"Prims.eq2",
"Lib.Sequence.sub",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_or",
"Prims.op_Addition",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.index",
"Lib.Sequence.update_sub",
"Lib.IntTypes.uint_t",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Prims.l_imp",
"Lib.Sequence.create",
"Lib.IntTypes.u8",
"Spec.Blake2.Definitions.block_s"
] | [] | false | false | false | false | false | let blake2_key_block a kk k =
| let key_block = create (size_block a) (u8 0) in
let key_block = update_sub key_block 0 kk k in
key_block | false |
Spec.Blake2.fst | Spec.Blake2.blake2s | val blake2s:
d:bytes
-> p:blake2_params Blake2S
-> kk:size_nat{kk <= 32 /\ (if kk = 0 then length d < pow2 64 else length d + 64 < pow2 64)}
-> k:lbytes kk
-> nn:size_nat{1 <= nn /\ nn <= 32} ->
Tot (lbytes nn) | val blake2s:
d:bytes
-> p:blake2_params Blake2S
-> kk:size_nat{kk <= 32 /\ (if kk = 0 then length d < pow2 64 else length d + 64 < pow2 64)}
-> k:lbytes kk
-> nn:size_nat{1 <= nn /\ nn <= 32} ->
Tot (lbytes nn) | let blake2s d p kk k n = blake2 Blake2S d p kk k n | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 50,
"end_line": 475,
"start_col": 0,
"start_line": 475
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B
inline_for_extraction
let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B
[@"opaque_to_smt"]
let list_sigma: list_sigma_t =
[@inline_let]
let l : list sigma_elt_t = [
size 0; size 1; size 2; size 3; size 4; size 5; size 6; size 7;
size 8; size 9; size 10; size 11; size 12; size 13; size 14; size 15;
size 14; size 10; size 4; size 8; size 9; size 15; size 13; size 6;
size 1; size 12; size 0; size 2; size 11; size 7; size 5; size 3;
size 11; size 8; size 12; size 0; size 5; size 2; size 15; size 13;
size 10; size 14; size 3; size 6; size 7; size 1; size 9; size 4;
size 7; size 9; size 3; size 1; size 13; size 12; size 11; size 14;
size 2; size 6; size 5; size 10; size 4; size 0; size 15; size 8;
size 9; size 0; size 5; size 7; size 2; size 4; size 10; size 15;
size 14; size 1; size 11; size 12; size 6; size 8; size 3; size 13;
size 2; size 12; size 6; size 10; size 0; size 11; size 8; size 3;
size 4; size 13; size 7; size 5; size 15; size 14; size 1; size 9;
size 12; size 5; size 1; size 15; size 14; size 13; size 4; size 10;
size 0; size 7; size 6; size 3; size 9; size 2; size 8; size 11;
size 13; size 11; size 7; size 14; size 12; size 1; size 3; size 9;
size 5; size 0; size 15; size 4; size 8; size 6; size 2; size 10;
size 6; size 15; size 14; size 9; size 11; size 3; size 0; size 8;
size 12; size 2; size 13; size 7; size 1; size 4; size 10; size 5;
size 10; size 2; size 8; size 4; size 7; size 6; size 1; size 5;
size 15; size 11; size 9; size 14; size 3; size 12; size 13; size 0
] in
assert_norm(List.Tot.length l == 160);
l
inline_for_extraction
let sigmaTable:lseq sigma_elt_t size_sigmaTable =
assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma
(* Functions *)
let g1 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (r:rotval (wt a)) : Tot (state a) =
wv.[i] <- (wv.[i] ^| wv.[j]) >>>| r
let g2 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (x:row a) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j] +| x)
let g2z (a:alg) (wv:state a) (i:row_idx) (j:row_idx) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j])
val blake2_mixing:
a:alg
-> ws:state a
-> row a
-> row a ->
Tot (state a)
let blake2_mixing al wv x y =
let a = 0 in
let b = 1 in
let c = 2 in
let d = 3 in
let rt = rTable al in
let wv = g2 al wv a b x in
let wv = g1 al wv d a rt.[0] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[1] in
let wv = g2 al wv a b y in
let wv = g1 al wv d a rt.[2] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[3] in
wv
let diag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 1 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 3 in
wv
let undiag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 3 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 1 in
wv
inline_for_extraction
let gather_row (#a:alg) (m:block_w a) (i0 i1 i2 i3:sigma_elt_t) : row a =
create_row m.[v i0] m.[v i1] m.[v i2] m.[v i3]
val gather_state: a:alg -> m:block_w a -> start:nat{start <= 144} -> state a
let gather_state a m start =
let x = gather_row m sigmaTable.[start] sigmaTable.[start+2] sigmaTable.[start+4] sigmaTable.[start+6] in
let y = gather_row m sigmaTable.[start+1] sigmaTable.[start+3] sigmaTable.[start+5] sigmaTable.[start+7] in
let z = gather_row m sigmaTable.[start+8] sigmaTable.[start+10] sigmaTable.[start+12] sigmaTable.[start+14] in
let w = gather_row m sigmaTable.[start+9] sigmaTable.[start+11] sigmaTable.[start+13] sigmaTable.[start+15] in
let l = [x;y;z;w] in
assert_norm (List.Tot.length l == 4);
createL l
val blake2_round:
a:alg
-> m:block_w a
-> i:size_nat
-> wv:state a
-> state a
let blake2_round a m i wv =
let start = (i%10) * 16 in
let m_s = gather_state a m start in
let wv = blake2_mixing a wv m_s.[0] m_s.[1] in
let wv = diag wv in
let wv = blake2_mixing a wv m_s.[2] m_s.[3] in
undiag wv
val blake2_compress0:
a:alg
-> m:block_s a
-> block_w a
let blake2_compress0 a m =
uints_from_bytes_le m
val blake2_compress1:
a:alg
-> s_iv:state a
-> offset:limb_t a
-> flag:bool ->
Tot (state a)
let blake2_compress1 a s_iv offset flag =
let wv : state a = s_iv in
let low_offset = limb_to_word a offset in
let high_offset = limb_to_word a (shift_right #(limb_inttype a) offset (size (bits (wt a)))) in
let m_12 = low_offset in
let m_13 = high_offset in
let m_14 = if flag then (ones (wt a) SEC) else zero a in
let m_15 = zero a in
let mask = create_row m_12 m_13 m_14 m_15 in
let wv = wv.[3] <- wv.[3] ^| mask in
wv
val blake2_compress2:
a:alg
-> wv:state a
-> m:block_w a ->
Tot (state a)
let blake2_compress2 a wv m = repeati (rounds a) (blake2_round a m) wv
val blake2_compress3:
a:alg
-> wv:state a
-> s_iv:state a ->
Tot (state a)
let blake2_compress3 a wv s =
let s = s.[0] <- (s.[0] ^| wv.[0]) ^| wv.[2] in
let s = s.[1] <- (s.[1] ^| wv.[1]) ^| wv.[3] in
s
val blake2_compress:
a:alg
-> s_iv:state a
-> m:block_s a
-> offset:limb_t a
-> flag:bool ->
Tot (state a)
let blake2_compress a s_iv m offset flag =
let m_w = blake2_compress0 a m in
let wv = blake2_compress1 a s_iv offset flag in
let wv = blake2_compress2 a wv m_w in
let s_iv = blake2_compress3 a wv s_iv in
s_iv
val blake2_update_block:
a:alg
-> flag:bool
-> totlen:nat{totlen <= max_limb a}
-> d:block_s a
-> s_iv:state a ->
Tot (state a)
let blake2_update_block a flag totlen d s =
let offset = nat_to_limb a totlen in
blake2_compress a s d offset flag
val blake2_update1:
a:alg
-> prev:nat
-> m:bytes
-> i:nat{i < length m / size_block a /\ prev + length m <= max_limb a}
-> s:state a ->
Tot (state a)
let get_blocki (a:alg) (m:bytes) (i:nat{i < length m / size_block a}) : block_s a =
Seq.slice m (i * size_block a) ((i+1) * size_block a)
let blake2_update1 a prev m i s =
let totlen = prev + (i+1) * size_block a in
let d = get_blocki a m i in
blake2_update_block a false totlen d s
val blake2_update_last:
a:alg
-> prev:nat
-> rem:nat
-> m:bytes{prev + length m <= max_limb a /\ rem <= length m /\ rem <= size_block a}
-> s:state a ->
Tot (state a)
let get_last_padded_block (a:alg) (m:bytes)
(rem:nat{rem <= length m /\ rem <= size_block a}) : block_s a =
let last = Seq.slice m (length m - rem) (length m) in
let last_block = create (size_block a) (u8 0) in
let last_block = update_sub last_block 0 rem last in
last_block
let blake2_update_last a prev rem m s =
let inlen = length m in
let totlen = prev + inlen in
let last_block = get_last_padded_block a m rem in
blake2_update_block a true totlen last_block s
val blake2_update_blocks:
a:alg
-> prev:nat
-> m:bytes{prev + length m <= max_limb a}
-> s:state a ->
Tot (state a)
let split (a:alg) (len:nat)
: nb_rem:(nat & nat){let (nb,rem) = nb_rem in
nb * size_block a + rem == len} =
UpdateMulti.split_at_last_lazy_nb_rem (size_block a) len
let blake2_update_blocks a prev m s =
let (nb,rem) = split a (length m) in
let s = repeati nb (blake2_update1 a prev m) s in
blake2_update_last a prev rem m s
val blake2_init_hash:
a:alg
-> p:blake2_params a
-> kk:size_nat{kk <= max_key a}
-> nn:size_nat{1 <= nn /\ nn <= max_output a} ->
Tot (state a)
let blake2_init_hash a p kk nn =
let iv0 = secret (ivTable a).[0] in
let iv1 = secret (ivTable a).[1] in
let iv2 = secret (ivTable a).[2] in
let iv3 = secret (ivTable a).[3] in
let iv4 = secret (ivTable a).[4] in
let iv5 = secret (ivTable a).[5] in
let iv6 = secret (ivTable a).[6] in
let iv7 = secret (ivTable a).[7] in
let r0 = create_row #a iv0 iv1 iv2 iv3 in
let r1 = create_row #a iv4 iv5 iv6 iv7 in
let p: blake2_params a =
set_key_length (set_digest_length p nn) kk
in
let s = serialize_blake2_params p in
let iv0' = iv0 ^. s.[0] in
let iv1' = iv1 ^. s.[1] in
let iv2' = iv2 ^. s.[2] in
let iv3' = iv3 ^. s.[3] in
let iv4' = iv4 ^. s.[4] in
let iv5' = iv5 ^. s.[5] in
let iv6' = iv6 ^. s.[6] in
let iv7' = iv7 ^. s.[7] in
let r0' = create_row #a iv0' iv1' iv2' iv3' in
let r1' = create_row #a iv4' iv5' iv6' iv7' in
let s_iv = createL [r0';r1';r0;r1] in
s_iv
val blake2_key_block:
a:alg
-> kk:size_nat{0 < kk /\ kk <= max_key a}
-> k:lbytes kk
-> block_s a
let blake2_key_block a kk k =
let key_block = create (size_block a) (u8 0) in
let key_block = update_sub key_block 0 kk k in
key_block
/// This function must be called only if the key is non empty (see the precondition)
val blake2_update_key:
a:alg
-> kk:size_nat{0 < kk /\ kk <= max_key a}
-> k:lbytes kk
-> ll:nat
-> s:state a ->
Tot (state a)
let blake2_update_key a kk k ll s =
let key_block = blake2_key_block a kk k in
if ll = 0 then
blake2_update_block a true (size_block a) key_block s
else
blake2_update_block a false (size_block a) key_block s
val blake2_update:
a:alg
-> kk:size_nat{kk <= max_key a}
-> k:lbytes kk
-> d:bytes{if kk = 0 then length d <= max_limb a else length d + (size_block a) <= max_limb a}
-> s:state a ->
Tot (state a)
let blake2_update a kk k d s =
let ll = length d in
if kk > 0 then
let s = blake2_update_key a kk k ll s in
if ll = 0 then s // Skip update_last if ll = 0 (but kk > 0)
else blake2_update_blocks a (size_block a) d s
else blake2_update_blocks a 0 d s
val blake2_finish:
a:alg
-> s:state a
-> nn:size_nat{1 <= nn /\ nn <= max_output a} ->
Tot (lbytes nn)
let blake2_finish a s nn =
let full = (uints_to_bytes_le s.[0] @| uints_to_bytes_le s.[1]) in
sub full 0 nn
val blake2:
a:alg
-> d:bytes
-> p:blake2_params a
-> kk:size_nat{kk <= max_key a /\ (if kk = 0 then length d <= max_limb a else length d + (size_block a) <= max_limb a)}
-> k:lbytes kk
-> nn:size_nat{1 <= nn /\ nn <= max_output a} ->
Tot (lbytes nn)
let blake2 a d p kk k nn =
let s = blake2_init_hash a p kk nn in
let s = blake2_update a kk k d s in
blake2_finish a s nn
val blake2s:
d:bytes
-> p:blake2_params Blake2S
-> kk:size_nat{kk <= 32 /\ (if kk = 0 then length d < pow2 64 else length d + 64 < pow2 64)}
-> k:lbytes kk
-> nn:size_nat{1 <= nn /\ nn <= 32} ->
Tot (lbytes nn) | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
d: Lib.ByteSequence.bytes ->
p: Spec.Blake2.Definitions.blake2_params Spec.Blake2.Definitions.Blake2S ->
kk:
Lib.IntTypes.size_nat
{ kk <= 32 /\
(match kk = 0 with
| true -> Lib.Sequence.length d < Prims.pow2 64
| _ -> Lib.Sequence.length d + 64 < Prims.pow2 64) } ->
k: Lib.ByteSequence.lbytes kk ->
nn: Lib.IntTypes.size_nat{1 <= nn /\ nn <= 32}
-> Lib.ByteSequence.lbytes nn | Prims.Tot | [
"total"
] | [] | [
"Lib.ByteSequence.bytes",
"Spec.Blake2.Definitions.blake2_params",
"Spec.Blake2.Definitions.Blake2S",
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"Prims.op_LessThan",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.pow2",
"Prims.bool",
"Prims.op_Addition",
"Prims.logical",
"Lib.ByteSequence.lbytes",
"Spec.Blake2.blake2"
] | [] | false | false | false | false | false | let blake2s d p kk k n =
| blake2 Blake2S d p kk k n | false |
PulseCore.InstantiatedSemantics.fst | PulseCore.InstantiatedSemantics.stt | val stt (a:Type u#a)
(pre:slprop)
(post:a -> slprop)
: Type0 | val stt (a:Type u#a)
(pre:slprop)
(post:a -> slprop)
: Type0 | let stt (a:Type u#a)
(pre:slprop)
(post:a -> slprop)
: Type0
= lower (Sem.m u#2 u#100 u#a #state a pre (F.on_dom a post)) | {
"file_name": "lib/pulse_core/PulseCore.InstantiatedSemantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 60,
"end_line": 119,
"start_col": 0,
"start_line": 115
} | module PulseCore.InstantiatedSemantics
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module U = FStar.Universe
module F = FStar.FunctionalExtensionality
open PulseCore.Memory
let laws ()
: squash (
Sem.associative star /\
Sem.commutative star /\
Sem.is_unit emp star
)
= let equiv_eq (x y:slprop)
: Lemma (x `equiv` y <==> x == y)
[SMTPat (x `equiv` y)]
= introduce x `equiv` y ==> x == y
with _h . slprop_extensionality x y
in
let _ : squash (Sem.associative star) =
introduce
forall x y z.
((x `star` y) `star` z) ==
(x `star` (y `star` z))
with star_associative x y z
in
let _ : squash (Sem.commutative star) =
introduce
forall x y.
x `star` y == y `star` x
with star_commutative x y
in
let _ : squash (Sem.is_unit emp star) =
introduce
forall x.
(x `star` emp) == x /\
(emp `star` x) == x
with emp_unit x
in
()
let state0 (e:inames) : Sem.state = {
max_act = U.raise_t u#0 u#100 unit;
s = mem;
is_full_mem = full_mem_pred;
pred = slprop;
emp = emp;
star = star;
interp = interp;
evolves = mem_evolves;
invariant = locks_invariant e;
laws = laws ()
}
let state : Sem.state = state0 Set.empty
let slprop = slprop
let _eq : squash (slprop == state.pred) = ()
let emp = emp
let pure p = pure p
let ( ** ) p q = p `star` q
let ( exists* ) #a p = h_exists (F.on_dom a p)
let prop_squash_idem (p:prop)
: Tot (squash (p == squash p))
= FStar.PropositionalExtensionality.apply p (squash p)
let slprop_equiv p q = Mem.equiv p q
let unsquash (p:squash (slprop_equiv 'p 'q)) : slprop_equiv 'p 'q =
prop_squash_idem (slprop_equiv 'p 'q);
coerce_eq () p
let slprop_equiv_refl p = unsquash ()
let slprop_equiv_elim p q =
introduce (p `slprop_equiv` q) ==> p==q
with _ . Mem.slprop_extensionality p q
let slprop_equiv_unit p = unsquash ()
let slprop_equiv_comm p1 p2 = unsquash ()
let slprop_equiv_assoc p1 p2 p3 = unsquash ()
module T = FStar.Tactics.V2
let slprop_equiv_exists
(#a:Type)
(p q: a -> slprop)
(_:squash (forall x. slprop_equiv (p x) (q x)))
= introduce forall x. p x == q x
with slprop_equiv_elim (p x) (q x);
F.extensionality _ _ p q;
let pf : squash (eq2 #(F.arrow a (fun _ -> slprop))
(F.on_dom a p)
(F.on_dom a q)) = ()
in
let x : squash (op_exists_Star p == op_exists_Star q) = _ by (
T.norm [delta_only [`%op_exists_Star; `%F.on_dom]; unascribe];
let bindings = T.cur_vars() in
let bindings = List.Tot.rev bindings in
match bindings with
| hd::_ -> (
match T.term_as_formula hd.sort with
| T.Comp (T.Eq _) lhs rhs ->
T.grewrite lhs rhs;
T.trefl();
T.exact (T.binding_to_term hd)
| _ -> T.fail "Unexpected type of hd"
)
| _ ->
T.fail "empty bindings"
) in
unsquash x
(* The type of general-purpose computations *) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.InstantiatedSemantics.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Type ->
pre: PulseCore.InstantiatedSemantics.slprop ->
post: (_: a -> PulseCore.InstantiatedSemantics.slprop)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.InstantiatedSemantics.lower",
"PulseCore.Semantics.m",
"PulseCore.InstantiatedSemantics.state",
"FStar.FunctionalExtensionality.on_dom",
"PulseCore.Semantics.__proj__Mkstate__item__pred"
] | [] | false | false | false | true | true | let stt (a: Type u#a) (pre: slprop) (post: (a -> slprop)) : Type0 =
| lower (Sem.m u#2 u#100 u#a #state a pre (F.on_dom a post)) | false |
Spec.Blake2.fst | Spec.Blake2.blake2b | val blake2b:
d:bytes
-> p:blake2_params Blake2B
-> kk:size_nat{kk <= 64 /\ (if kk = 0 then length d < pow2 128 else length d + 128 < pow2 128)}
-> k:lbytes kk
-> nn:size_nat{1 <= nn /\ nn <= 64} ->
Tot (lbytes nn) | val blake2b:
d:bytes
-> p:blake2_params Blake2B
-> kk:size_nat{kk <= 64 /\ (if kk = 0 then length d < pow2 128 else length d + 128 < pow2 128)}
-> k:lbytes kk
-> nn:size_nat{1 <= nn /\ nn <= 64} ->
Tot (lbytes nn) | let blake2b d p kk k n = blake2 Blake2B d p kk k n | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 50,
"end_line": 485,
"start_col": 0,
"start_line": 485
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B
inline_for_extraction
let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B
[@"opaque_to_smt"]
let list_sigma: list_sigma_t =
[@inline_let]
let l : list sigma_elt_t = [
size 0; size 1; size 2; size 3; size 4; size 5; size 6; size 7;
size 8; size 9; size 10; size 11; size 12; size 13; size 14; size 15;
size 14; size 10; size 4; size 8; size 9; size 15; size 13; size 6;
size 1; size 12; size 0; size 2; size 11; size 7; size 5; size 3;
size 11; size 8; size 12; size 0; size 5; size 2; size 15; size 13;
size 10; size 14; size 3; size 6; size 7; size 1; size 9; size 4;
size 7; size 9; size 3; size 1; size 13; size 12; size 11; size 14;
size 2; size 6; size 5; size 10; size 4; size 0; size 15; size 8;
size 9; size 0; size 5; size 7; size 2; size 4; size 10; size 15;
size 14; size 1; size 11; size 12; size 6; size 8; size 3; size 13;
size 2; size 12; size 6; size 10; size 0; size 11; size 8; size 3;
size 4; size 13; size 7; size 5; size 15; size 14; size 1; size 9;
size 12; size 5; size 1; size 15; size 14; size 13; size 4; size 10;
size 0; size 7; size 6; size 3; size 9; size 2; size 8; size 11;
size 13; size 11; size 7; size 14; size 12; size 1; size 3; size 9;
size 5; size 0; size 15; size 4; size 8; size 6; size 2; size 10;
size 6; size 15; size 14; size 9; size 11; size 3; size 0; size 8;
size 12; size 2; size 13; size 7; size 1; size 4; size 10; size 5;
size 10; size 2; size 8; size 4; size 7; size 6; size 1; size 5;
size 15; size 11; size 9; size 14; size 3; size 12; size 13; size 0
] in
assert_norm(List.Tot.length l == 160);
l
inline_for_extraction
let sigmaTable:lseq sigma_elt_t size_sigmaTable =
assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma
(* Functions *)
let g1 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (r:rotval (wt a)) : Tot (state a) =
wv.[i] <- (wv.[i] ^| wv.[j]) >>>| r
let g2 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (x:row a) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j] +| x)
let g2z (a:alg) (wv:state a) (i:row_idx) (j:row_idx) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j])
val blake2_mixing:
a:alg
-> ws:state a
-> row a
-> row a ->
Tot (state a)
let blake2_mixing al wv x y =
let a = 0 in
let b = 1 in
let c = 2 in
let d = 3 in
let rt = rTable al in
let wv = g2 al wv a b x in
let wv = g1 al wv d a rt.[0] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[1] in
let wv = g2 al wv a b y in
let wv = g1 al wv d a rt.[2] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[3] in
wv
let diag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 1 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 3 in
wv
let undiag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 3 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 1 in
wv
inline_for_extraction
let gather_row (#a:alg) (m:block_w a) (i0 i1 i2 i3:sigma_elt_t) : row a =
create_row m.[v i0] m.[v i1] m.[v i2] m.[v i3]
val gather_state: a:alg -> m:block_w a -> start:nat{start <= 144} -> state a
let gather_state a m start =
let x = gather_row m sigmaTable.[start] sigmaTable.[start+2] sigmaTable.[start+4] sigmaTable.[start+6] in
let y = gather_row m sigmaTable.[start+1] sigmaTable.[start+3] sigmaTable.[start+5] sigmaTable.[start+7] in
let z = gather_row m sigmaTable.[start+8] sigmaTable.[start+10] sigmaTable.[start+12] sigmaTable.[start+14] in
let w = gather_row m sigmaTable.[start+9] sigmaTable.[start+11] sigmaTable.[start+13] sigmaTable.[start+15] in
let l = [x;y;z;w] in
assert_norm (List.Tot.length l == 4);
createL l
val blake2_round:
a:alg
-> m:block_w a
-> i:size_nat
-> wv:state a
-> state a
let blake2_round a m i wv =
let start = (i%10) * 16 in
let m_s = gather_state a m start in
let wv = blake2_mixing a wv m_s.[0] m_s.[1] in
let wv = diag wv in
let wv = blake2_mixing a wv m_s.[2] m_s.[3] in
undiag wv
val blake2_compress0:
a:alg
-> m:block_s a
-> block_w a
let blake2_compress0 a m =
uints_from_bytes_le m
val blake2_compress1:
a:alg
-> s_iv:state a
-> offset:limb_t a
-> flag:bool ->
Tot (state a)
let blake2_compress1 a s_iv offset flag =
let wv : state a = s_iv in
let low_offset = limb_to_word a offset in
let high_offset = limb_to_word a (shift_right #(limb_inttype a) offset (size (bits (wt a)))) in
let m_12 = low_offset in
let m_13 = high_offset in
let m_14 = if flag then (ones (wt a) SEC) else zero a in
let m_15 = zero a in
let mask = create_row m_12 m_13 m_14 m_15 in
let wv = wv.[3] <- wv.[3] ^| mask in
wv
val blake2_compress2:
a:alg
-> wv:state a
-> m:block_w a ->
Tot (state a)
let blake2_compress2 a wv m = repeati (rounds a) (blake2_round a m) wv
val blake2_compress3:
a:alg
-> wv:state a
-> s_iv:state a ->
Tot (state a)
let blake2_compress3 a wv s =
let s = s.[0] <- (s.[0] ^| wv.[0]) ^| wv.[2] in
let s = s.[1] <- (s.[1] ^| wv.[1]) ^| wv.[3] in
s
val blake2_compress:
a:alg
-> s_iv:state a
-> m:block_s a
-> offset:limb_t a
-> flag:bool ->
Tot (state a)
let blake2_compress a s_iv m offset flag =
let m_w = blake2_compress0 a m in
let wv = blake2_compress1 a s_iv offset flag in
let wv = blake2_compress2 a wv m_w in
let s_iv = blake2_compress3 a wv s_iv in
s_iv
val blake2_update_block:
a:alg
-> flag:bool
-> totlen:nat{totlen <= max_limb a}
-> d:block_s a
-> s_iv:state a ->
Tot (state a)
let blake2_update_block a flag totlen d s =
let offset = nat_to_limb a totlen in
blake2_compress a s d offset flag
val blake2_update1:
a:alg
-> prev:nat
-> m:bytes
-> i:nat{i < length m / size_block a /\ prev + length m <= max_limb a}
-> s:state a ->
Tot (state a)
let get_blocki (a:alg) (m:bytes) (i:nat{i < length m / size_block a}) : block_s a =
Seq.slice m (i * size_block a) ((i+1) * size_block a)
let blake2_update1 a prev m i s =
let totlen = prev + (i+1) * size_block a in
let d = get_blocki a m i in
blake2_update_block a false totlen d s
val blake2_update_last:
a:alg
-> prev:nat
-> rem:nat
-> m:bytes{prev + length m <= max_limb a /\ rem <= length m /\ rem <= size_block a}
-> s:state a ->
Tot (state a)
let get_last_padded_block (a:alg) (m:bytes)
(rem:nat{rem <= length m /\ rem <= size_block a}) : block_s a =
let last = Seq.slice m (length m - rem) (length m) in
let last_block = create (size_block a) (u8 0) in
let last_block = update_sub last_block 0 rem last in
last_block
let blake2_update_last a prev rem m s =
let inlen = length m in
let totlen = prev + inlen in
let last_block = get_last_padded_block a m rem in
blake2_update_block a true totlen last_block s
val blake2_update_blocks:
a:alg
-> prev:nat
-> m:bytes{prev + length m <= max_limb a}
-> s:state a ->
Tot (state a)
let split (a:alg) (len:nat)
: nb_rem:(nat & nat){let (nb,rem) = nb_rem in
nb * size_block a + rem == len} =
UpdateMulti.split_at_last_lazy_nb_rem (size_block a) len
let blake2_update_blocks a prev m s =
let (nb,rem) = split a (length m) in
let s = repeati nb (blake2_update1 a prev m) s in
blake2_update_last a prev rem m s
val blake2_init_hash:
a:alg
-> p:blake2_params a
-> kk:size_nat{kk <= max_key a}
-> nn:size_nat{1 <= nn /\ nn <= max_output a} ->
Tot (state a)
let blake2_init_hash a p kk nn =
let iv0 = secret (ivTable a).[0] in
let iv1 = secret (ivTable a).[1] in
let iv2 = secret (ivTable a).[2] in
let iv3 = secret (ivTable a).[3] in
let iv4 = secret (ivTable a).[4] in
let iv5 = secret (ivTable a).[5] in
let iv6 = secret (ivTable a).[6] in
let iv7 = secret (ivTable a).[7] in
let r0 = create_row #a iv0 iv1 iv2 iv3 in
let r1 = create_row #a iv4 iv5 iv6 iv7 in
let p: blake2_params a =
set_key_length (set_digest_length p nn) kk
in
let s = serialize_blake2_params p in
let iv0' = iv0 ^. s.[0] in
let iv1' = iv1 ^. s.[1] in
let iv2' = iv2 ^. s.[2] in
let iv3' = iv3 ^. s.[3] in
let iv4' = iv4 ^. s.[4] in
let iv5' = iv5 ^. s.[5] in
let iv6' = iv6 ^. s.[6] in
let iv7' = iv7 ^. s.[7] in
let r0' = create_row #a iv0' iv1' iv2' iv3' in
let r1' = create_row #a iv4' iv5' iv6' iv7' in
let s_iv = createL [r0';r1';r0;r1] in
s_iv
val blake2_key_block:
a:alg
-> kk:size_nat{0 < kk /\ kk <= max_key a}
-> k:lbytes kk
-> block_s a
let blake2_key_block a kk k =
let key_block = create (size_block a) (u8 0) in
let key_block = update_sub key_block 0 kk k in
key_block
/// This function must be called only if the key is non empty (see the precondition)
val blake2_update_key:
a:alg
-> kk:size_nat{0 < kk /\ kk <= max_key a}
-> k:lbytes kk
-> ll:nat
-> s:state a ->
Tot (state a)
let blake2_update_key a kk k ll s =
let key_block = blake2_key_block a kk k in
if ll = 0 then
blake2_update_block a true (size_block a) key_block s
else
blake2_update_block a false (size_block a) key_block s
val blake2_update:
a:alg
-> kk:size_nat{kk <= max_key a}
-> k:lbytes kk
-> d:bytes{if kk = 0 then length d <= max_limb a else length d + (size_block a) <= max_limb a}
-> s:state a ->
Tot (state a)
let blake2_update a kk k d s =
let ll = length d in
if kk > 0 then
let s = blake2_update_key a kk k ll s in
if ll = 0 then s // Skip update_last if ll = 0 (but kk > 0)
else blake2_update_blocks a (size_block a) d s
else blake2_update_blocks a 0 d s
val blake2_finish:
a:alg
-> s:state a
-> nn:size_nat{1 <= nn /\ nn <= max_output a} ->
Tot (lbytes nn)
let blake2_finish a s nn =
let full = (uints_to_bytes_le s.[0] @| uints_to_bytes_le s.[1]) in
sub full 0 nn
val blake2:
a:alg
-> d:bytes
-> p:blake2_params a
-> kk:size_nat{kk <= max_key a /\ (if kk = 0 then length d <= max_limb a else length d + (size_block a) <= max_limb a)}
-> k:lbytes kk
-> nn:size_nat{1 <= nn /\ nn <= max_output a} ->
Tot (lbytes nn)
let blake2 a d p kk k nn =
let s = blake2_init_hash a p kk nn in
let s = blake2_update a kk k d s in
blake2_finish a s nn
val blake2s:
d:bytes
-> p:blake2_params Blake2S
-> kk:size_nat{kk <= 32 /\ (if kk = 0 then length d < pow2 64 else length d + 64 < pow2 64)}
-> k:lbytes kk
-> nn:size_nat{1 <= nn /\ nn <= 32} ->
Tot (lbytes nn)
let blake2s d p kk k n = blake2 Blake2S d p kk k n
val blake2b:
d:bytes
-> p:blake2_params Blake2B
-> kk:size_nat{kk <= 64 /\ (if kk = 0 then length d < pow2 128 else length d + 128 < pow2 128)}
-> k:lbytes kk
-> nn:size_nat{1 <= nn /\ nn <= 64} ->
Tot (lbytes nn) | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
d: Lib.ByteSequence.bytes ->
p: Spec.Blake2.Definitions.blake2_params Spec.Blake2.Definitions.Blake2B ->
kk:
Lib.IntTypes.size_nat
{ kk <= 64 /\
(match kk = 0 with
| true -> Lib.Sequence.length d < Prims.pow2 128
| _ -> Lib.Sequence.length d + 128 < Prims.pow2 128) } ->
k: Lib.ByteSequence.lbytes kk ->
nn: Lib.IntTypes.size_nat{1 <= nn /\ nn <= 64}
-> Lib.ByteSequence.lbytes nn | Prims.Tot | [
"total"
] | [] | [
"Lib.ByteSequence.bytes",
"Spec.Blake2.Definitions.blake2_params",
"Spec.Blake2.Definitions.Blake2B",
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"Prims.op_LessThan",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.pow2",
"Prims.bool",
"Prims.op_Addition",
"Prims.logical",
"Lib.ByteSequence.lbytes",
"Spec.Blake2.blake2"
] | [] | false | false | false | false | false | let blake2b d p kk k n =
| blake2 Blake2B d p kk k n | false |
Spec.Blake2.fst | Spec.Blake2.blake2_finish | val blake2_finish:
a:alg
-> s:state a
-> nn:size_nat{1 <= nn /\ nn <= max_output a} ->
Tot (lbytes nn) | val blake2_finish:
a:alg
-> s:state a
-> nn:size_nat{1 <= nn /\ nn <= max_output a} ->
Tot (lbytes nn) | let blake2_finish a s nn =
let full = (uints_to_bytes_le s.[0] @| uints_to_bytes_le s.[1]) in
sub full 0 nn | {
"file_name": "specs/Spec.Blake2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 451,
"start_col": 0,
"start_line": 449
} | module Spec.Blake2
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module UpdateMulti = Lib.UpdateMulti
include Spec.Blake2.Definitions
#set-options "--z3rlimit 50"
/// Serialize blake2s parameters to be xor'ed with the state during initialization
/// As the state is represented using uint32, we need to serialize to uint32 instead
/// of the more standard bytes representation
let serialize_blake2s_params (p: blake2s_params) : lseq uint32 8 =
let s0 = (u32 (v p.digest_length)) ^.
(u32 (v p.key_length) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le p.salt in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le p.personal in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
/// Serialize blake2b parameters to be xor'ed with the state during initialization
/// As the state is represented using uint64, we need to serialize to uint64 instead
/// of the more standard bytes representation
let serialize_blake2b_params (p: blake2b_params) : lseq uint64 8 =
let s0 = (u64 (v p.digest_length)) ^.
(u64 (v p.key_length) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le p.salt in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le p.personal in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
createL l
inline_for_extraction
let serialize_blake2_params (#a: alg) (p: blake2_params a): lseq (word_t a) 8 =
match a with
| Blake2S -> serialize_blake2s_params p
| Blake2B -> serialize_blake2b_params p
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_S : List.Tot.llist (rotval U32) 4 =
[
size 16; size 12; size 8; size 7
]
[@"opaque_to_smt"]
inline_for_extraction
let rTable_list_B: List.Tot.llist (rotval U64) 4 =
[
size 32; size 24; size 16; size 63
]
inline_for_extraction
let rTable (a:alg) : rtable_t a =
match a with
| Blake2S -> (of_list rTable_list_S)
| Blake2B -> (of_list rTable_list_B)
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_S: List.Tot.llist (uint_t U32 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667ul; 0xBB67AE85ul; 0x3C6EF372ul; 0xA54FF53Aul;
0x510E527Ful; 0x9B05688Cul; 0x1F83D9ABul; 0x5BE0CD19ul] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv_B: List.Tot.llist (uint_t U64 PUB) 8 =
[@inline_let]
let l = [
0x6A09E667F3BCC908uL; 0xBB67AE8584CAA73BuL;
0x3C6EF372FE94F82BuL; 0xA54FF53A5F1D36F1uL;
0x510E527FADE682D1uL; 0x9B05688C2B3E6C1FuL;
0x1F83D9ABFB41BD6BuL; 0x5BE0CD19137E2179uL] in
assert_norm(List.Tot.length l == 8);
l
[@"opaque_to_smt"]
inline_for_extraction
let list_iv (a:alg): List.Tot.llist (pub_word_t a) 8 =
match a with
| Blake2S -> list_iv_S
| Blake2B -> list_iv_B
inline_for_extraction
let ivTable (a:alg) : lseq (pub_word_t a) 8 =
match a with
| Blake2S -> of_list list_iv_S
| Blake2B -> of_list list_iv_B
[@"opaque_to_smt"]
let list_sigma: list_sigma_t =
[@inline_let]
let l : list sigma_elt_t = [
size 0; size 1; size 2; size 3; size 4; size 5; size 6; size 7;
size 8; size 9; size 10; size 11; size 12; size 13; size 14; size 15;
size 14; size 10; size 4; size 8; size 9; size 15; size 13; size 6;
size 1; size 12; size 0; size 2; size 11; size 7; size 5; size 3;
size 11; size 8; size 12; size 0; size 5; size 2; size 15; size 13;
size 10; size 14; size 3; size 6; size 7; size 1; size 9; size 4;
size 7; size 9; size 3; size 1; size 13; size 12; size 11; size 14;
size 2; size 6; size 5; size 10; size 4; size 0; size 15; size 8;
size 9; size 0; size 5; size 7; size 2; size 4; size 10; size 15;
size 14; size 1; size 11; size 12; size 6; size 8; size 3; size 13;
size 2; size 12; size 6; size 10; size 0; size 11; size 8; size 3;
size 4; size 13; size 7; size 5; size 15; size 14; size 1; size 9;
size 12; size 5; size 1; size 15; size 14; size 13; size 4; size 10;
size 0; size 7; size 6; size 3; size 9; size 2; size 8; size 11;
size 13; size 11; size 7; size 14; size 12; size 1; size 3; size 9;
size 5; size 0; size 15; size 4; size 8; size 6; size 2; size 10;
size 6; size 15; size 14; size 9; size 11; size 3; size 0; size 8;
size 12; size 2; size 13; size 7; size 1; size 4; size 10; size 5;
size 10; size 2; size 8; size 4; size 7; size 6; size 1; size 5;
size 15; size 11; size 9; size 14; size 3; size 12; size 13; size 0
] in
assert_norm(List.Tot.length l == 160);
l
inline_for_extraction
let sigmaTable:lseq sigma_elt_t size_sigmaTable =
assert_norm (List.Tot.length list_sigma == size_sigmaTable);
of_list list_sigma
(* Functions *)
let g1 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (r:rotval (wt a)) : Tot (state a) =
wv.[i] <- (wv.[i] ^| wv.[j]) >>>| r
let g2 (a:alg) (wv:state a) (i:row_idx) (j:row_idx) (x:row a) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j] +| x)
let g2z (a:alg) (wv:state a) (i:row_idx) (j:row_idx) : Tot (state a) =
wv.[i] <- (wv.[i] +| wv.[j])
val blake2_mixing:
a:alg
-> ws:state a
-> row a
-> row a ->
Tot (state a)
let blake2_mixing al wv x y =
let a = 0 in
let b = 1 in
let c = 2 in
let d = 3 in
let rt = rTable al in
let wv = g2 al wv a b x in
let wv = g1 al wv d a rt.[0] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[1] in
let wv = g2 al wv a b y in
let wv = g1 al wv d a rt.[2] in
let wv = g2z al wv c d in
let wv = g1 al wv b c rt.[3] in
wv
let diag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 1 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 3 in
wv
let undiag (#a:alg) (wv:state a) : state a =
let wv = wv.[1] <- rotr wv.[1] 3 in
let wv = wv.[2] <- rotr wv.[2] 2 in
let wv = wv.[3] <- rotr wv.[3] 1 in
wv
inline_for_extraction
let gather_row (#a:alg) (m:block_w a) (i0 i1 i2 i3:sigma_elt_t) : row a =
create_row m.[v i0] m.[v i1] m.[v i2] m.[v i3]
val gather_state: a:alg -> m:block_w a -> start:nat{start <= 144} -> state a
let gather_state a m start =
let x = gather_row m sigmaTable.[start] sigmaTable.[start+2] sigmaTable.[start+4] sigmaTable.[start+6] in
let y = gather_row m sigmaTable.[start+1] sigmaTable.[start+3] sigmaTable.[start+5] sigmaTable.[start+7] in
let z = gather_row m sigmaTable.[start+8] sigmaTable.[start+10] sigmaTable.[start+12] sigmaTable.[start+14] in
let w = gather_row m sigmaTable.[start+9] sigmaTable.[start+11] sigmaTable.[start+13] sigmaTable.[start+15] in
let l = [x;y;z;w] in
assert_norm (List.Tot.length l == 4);
createL l
val blake2_round:
a:alg
-> m:block_w a
-> i:size_nat
-> wv:state a
-> state a
let blake2_round a m i wv =
let start = (i%10) * 16 in
let m_s = gather_state a m start in
let wv = blake2_mixing a wv m_s.[0] m_s.[1] in
let wv = diag wv in
let wv = blake2_mixing a wv m_s.[2] m_s.[3] in
undiag wv
val blake2_compress0:
a:alg
-> m:block_s a
-> block_w a
let blake2_compress0 a m =
uints_from_bytes_le m
val blake2_compress1:
a:alg
-> s_iv:state a
-> offset:limb_t a
-> flag:bool ->
Tot (state a)
let blake2_compress1 a s_iv offset flag =
let wv : state a = s_iv in
let low_offset = limb_to_word a offset in
let high_offset = limb_to_word a (shift_right #(limb_inttype a) offset (size (bits (wt a)))) in
let m_12 = low_offset in
let m_13 = high_offset in
let m_14 = if flag then (ones (wt a) SEC) else zero a in
let m_15 = zero a in
let mask = create_row m_12 m_13 m_14 m_15 in
let wv = wv.[3] <- wv.[3] ^| mask in
wv
val blake2_compress2:
a:alg
-> wv:state a
-> m:block_w a ->
Tot (state a)
let blake2_compress2 a wv m = repeati (rounds a) (blake2_round a m) wv
val blake2_compress3:
a:alg
-> wv:state a
-> s_iv:state a ->
Tot (state a)
let blake2_compress3 a wv s =
let s = s.[0] <- (s.[0] ^| wv.[0]) ^| wv.[2] in
let s = s.[1] <- (s.[1] ^| wv.[1]) ^| wv.[3] in
s
val blake2_compress:
a:alg
-> s_iv:state a
-> m:block_s a
-> offset:limb_t a
-> flag:bool ->
Tot (state a)
let blake2_compress a s_iv m offset flag =
let m_w = blake2_compress0 a m in
let wv = blake2_compress1 a s_iv offset flag in
let wv = blake2_compress2 a wv m_w in
let s_iv = blake2_compress3 a wv s_iv in
s_iv
val blake2_update_block:
a:alg
-> flag:bool
-> totlen:nat{totlen <= max_limb a}
-> d:block_s a
-> s_iv:state a ->
Tot (state a)
let blake2_update_block a flag totlen d s =
let offset = nat_to_limb a totlen in
blake2_compress a s d offset flag
val blake2_update1:
a:alg
-> prev:nat
-> m:bytes
-> i:nat{i < length m / size_block a /\ prev + length m <= max_limb a}
-> s:state a ->
Tot (state a)
let get_blocki (a:alg) (m:bytes) (i:nat{i < length m / size_block a}) : block_s a =
Seq.slice m (i * size_block a) ((i+1) * size_block a)
let blake2_update1 a prev m i s =
let totlen = prev + (i+1) * size_block a in
let d = get_blocki a m i in
blake2_update_block a false totlen d s
val blake2_update_last:
a:alg
-> prev:nat
-> rem:nat
-> m:bytes{prev + length m <= max_limb a /\ rem <= length m /\ rem <= size_block a}
-> s:state a ->
Tot (state a)
let get_last_padded_block (a:alg) (m:bytes)
(rem:nat{rem <= length m /\ rem <= size_block a}) : block_s a =
let last = Seq.slice m (length m - rem) (length m) in
let last_block = create (size_block a) (u8 0) in
let last_block = update_sub last_block 0 rem last in
last_block
let blake2_update_last a prev rem m s =
let inlen = length m in
let totlen = prev + inlen in
let last_block = get_last_padded_block a m rem in
blake2_update_block a true totlen last_block s
val blake2_update_blocks:
a:alg
-> prev:nat
-> m:bytes{prev + length m <= max_limb a}
-> s:state a ->
Tot (state a)
let split (a:alg) (len:nat)
: nb_rem:(nat & nat){let (nb,rem) = nb_rem in
nb * size_block a + rem == len} =
UpdateMulti.split_at_last_lazy_nb_rem (size_block a) len
let blake2_update_blocks a prev m s =
let (nb,rem) = split a (length m) in
let s = repeati nb (blake2_update1 a prev m) s in
blake2_update_last a prev rem m s
val blake2_init_hash:
a:alg
-> p:blake2_params a
-> kk:size_nat{kk <= max_key a}
-> nn:size_nat{1 <= nn /\ nn <= max_output a} ->
Tot (state a)
let blake2_init_hash a p kk nn =
let iv0 = secret (ivTable a).[0] in
let iv1 = secret (ivTable a).[1] in
let iv2 = secret (ivTable a).[2] in
let iv3 = secret (ivTable a).[3] in
let iv4 = secret (ivTable a).[4] in
let iv5 = secret (ivTable a).[5] in
let iv6 = secret (ivTable a).[6] in
let iv7 = secret (ivTable a).[7] in
let r0 = create_row #a iv0 iv1 iv2 iv3 in
let r1 = create_row #a iv4 iv5 iv6 iv7 in
let p: blake2_params a =
set_key_length (set_digest_length p nn) kk
in
let s = serialize_blake2_params p in
let iv0' = iv0 ^. s.[0] in
let iv1' = iv1 ^. s.[1] in
let iv2' = iv2 ^. s.[2] in
let iv3' = iv3 ^. s.[3] in
let iv4' = iv4 ^. s.[4] in
let iv5' = iv5 ^. s.[5] in
let iv6' = iv6 ^. s.[6] in
let iv7' = iv7 ^. s.[7] in
let r0' = create_row #a iv0' iv1' iv2' iv3' in
let r1' = create_row #a iv4' iv5' iv6' iv7' in
let s_iv = createL [r0';r1';r0;r1] in
s_iv
val blake2_key_block:
a:alg
-> kk:size_nat{0 < kk /\ kk <= max_key a}
-> k:lbytes kk
-> block_s a
let blake2_key_block a kk k =
let key_block = create (size_block a) (u8 0) in
let key_block = update_sub key_block 0 kk k in
key_block
/// This function must be called only if the key is non empty (see the precondition)
val blake2_update_key:
a:alg
-> kk:size_nat{0 < kk /\ kk <= max_key a}
-> k:lbytes kk
-> ll:nat
-> s:state a ->
Tot (state a)
let blake2_update_key a kk k ll s =
let key_block = blake2_key_block a kk k in
if ll = 0 then
blake2_update_block a true (size_block a) key_block s
else
blake2_update_block a false (size_block a) key_block s
val blake2_update:
a:alg
-> kk:size_nat{kk <= max_key a}
-> k:lbytes kk
-> d:bytes{if kk = 0 then length d <= max_limb a else length d + (size_block a) <= max_limb a}
-> s:state a ->
Tot (state a)
let blake2_update a kk k d s =
let ll = length d in
if kk > 0 then
let s = blake2_update_key a kk k ll s in
if ll = 0 then s // Skip update_last if ll = 0 (but kk > 0)
else blake2_update_blocks a (size_block a) d s
else blake2_update_blocks a 0 d s
val blake2_finish:
a:alg
-> s:state a
-> nn:size_nat{1 <= nn /\ nn <= max_output a} ->
Tot (lbytes nn) | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.Definitions.fst.checked",
"prims.fst.checked",
"Lib.UpdateMulti.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Blake2.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Blake2.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.UpdateMulti",
"short_module": "UpdateMulti"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Blake2.Definitions.alg ->
s: Spec.Blake2.Definitions.state a ->
nn: Lib.IntTypes.size_nat{1 <= nn /\ nn <= Spec.Blake2.Definitions.max_output a}
-> Lib.ByteSequence.lbytes nn | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Spec.Blake2.Definitions.state",
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Spec.Blake2.Definitions.max_output",
"Lib.Sequence.sub",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Spec.Blake2.Definitions.wt",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Prims.op_Multiply",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.append",
"Lib.ByteSequence.uints_to_bytes_le",
"Lib.Sequence.index",
"Lib.Sequence.op_At_Bar",
"Lib.Sequence.op_String_Access",
"Spec.Blake2.Definitions.row",
"Lib.ByteSequence.lbytes"
] | [] | false | false | false | false | false | let blake2_finish a s nn =
| let full = (uints_to_bytes_le s.[ 0 ] @| uints_to_bytes_le s.[ 1 ]) in
sub full 0 nn | false |
PulseCore.InstantiatedSemantics.fst | PulseCore.InstantiatedSemantics.bind | val bind
(#a:Type u#a) (#b:Type u#b)
(#pre1:slprop) (#post1:a -> slprop) (#post2:b -> slprop)
(e1:stt a pre1 post1)
(e2:(x:a -> stt b (post1 x) post2))
: stt b pre1 post2 | val bind
(#a:Type u#a) (#b:Type u#b)
(#pre1:slprop) (#post1:a -> slprop) (#post2:b -> slprop)
(e1:stt a pre1 post1)
(e2:(x:a -> stt b (post1 x) post2))
: stt b pre1 post2 | let bind
(#a:Type u#a) (#b:Type u#b)
(#pre1:slprop) (#post1:a -> slprop) (#post2:b -> slprop)
(e1:stt a pre1 post1)
(e2:(x:a -> stt b (post1 x) post2))
: stt b pre1 post2
= fun _ -> Sem.mbind (e1()) (fun x -> e2 x ()) | {
"file_name": "lib/pulse_core/PulseCore.InstantiatedSemantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 46,
"end_line": 131,
"start_col": 0,
"start_line": 125
} | module PulseCore.InstantiatedSemantics
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module U = FStar.Universe
module F = FStar.FunctionalExtensionality
open PulseCore.Memory
let laws ()
: squash (
Sem.associative star /\
Sem.commutative star /\
Sem.is_unit emp star
)
= let equiv_eq (x y:slprop)
: Lemma (x `equiv` y <==> x == y)
[SMTPat (x `equiv` y)]
= introduce x `equiv` y ==> x == y
with _h . slprop_extensionality x y
in
let _ : squash (Sem.associative star) =
introduce
forall x y z.
((x `star` y) `star` z) ==
(x `star` (y `star` z))
with star_associative x y z
in
let _ : squash (Sem.commutative star) =
introduce
forall x y.
x `star` y == y `star` x
with star_commutative x y
in
let _ : squash (Sem.is_unit emp star) =
introduce
forall x.
(x `star` emp) == x /\
(emp `star` x) == x
with emp_unit x
in
()
let state0 (e:inames) : Sem.state = {
max_act = U.raise_t u#0 u#100 unit;
s = mem;
is_full_mem = full_mem_pred;
pred = slprop;
emp = emp;
star = star;
interp = interp;
evolves = mem_evolves;
invariant = locks_invariant e;
laws = laws ()
}
let state : Sem.state = state0 Set.empty
let slprop = slprop
let _eq : squash (slprop == state.pred) = ()
let emp = emp
let pure p = pure p
let ( ** ) p q = p `star` q
let ( exists* ) #a p = h_exists (F.on_dom a p)
let prop_squash_idem (p:prop)
: Tot (squash (p == squash p))
= FStar.PropositionalExtensionality.apply p (squash p)
let slprop_equiv p q = Mem.equiv p q
let unsquash (p:squash (slprop_equiv 'p 'q)) : slprop_equiv 'p 'q =
prop_squash_idem (slprop_equiv 'p 'q);
coerce_eq () p
let slprop_equiv_refl p = unsquash ()
let slprop_equiv_elim p q =
introduce (p `slprop_equiv` q) ==> p==q
with _ . Mem.slprop_extensionality p q
let slprop_equiv_unit p = unsquash ()
let slprop_equiv_comm p1 p2 = unsquash ()
let slprop_equiv_assoc p1 p2 p3 = unsquash ()
module T = FStar.Tactics.V2
let slprop_equiv_exists
(#a:Type)
(p q: a -> slprop)
(_:squash (forall x. slprop_equiv (p x) (q x)))
= introduce forall x. p x == q x
with slprop_equiv_elim (p x) (q x);
F.extensionality _ _ p q;
let pf : squash (eq2 #(F.arrow a (fun _ -> slprop))
(F.on_dom a p)
(F.on_dom a q)) = ()
in
let x : squash (op_exists_Star p == op_exists_Star q) = _ by (
T.norm [delta_only [`%op_exists_Star; `%F.on_dom]; unascribe];
let bindings = T.cur_vars() in
let bindings = List.Tot.rev bindings in
match bindings with
| hd::_ -> (
match T.term_as_formula hd.sort with
| T.Comp (T.Eq _) lhs rhs ->
T.grewrite lhs rhs;
T.trefl();
T.exact (T.binding_to_term hd)
| _ -> T.fail "Unexpected type of hd"
)
| _ ->
T.fail "empty bindings"
) in
unsquash x
(* The type of general-purpose computations *)
let lower (t:Type u#a) : Type0 = unit -> Dv t
let stt (a:Type u#a)
(pre:slprop)
(post:a -> slprop)
: Type0
= lower (Sem.m u#2 u#100 u#a #state a pre (F.on_dom a post))
let return (#a:Type u#a) (x:a) (p:a -> slprop)
: stt a (p x) p
= fun _ -> Sem.ret x (F.on_dom a p) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.InstantiatedSemantics.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
e1: PulseCore.InstantiatedSemantics.stt a pre1 post1 ->
e2: (x: a -> PulseCore.InstantiatedSemantics.stt b (post1 x) post2)
-> PulseCore.InstantiatedSemantics.stt b pre1 post2 | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.InstantiatedSemantics.stt",
"Prims.unit",
"PulseCore.Semantics.mbind",
"PulseCore.InstantiatedSemantics.state",
"FStar.FunctionalExtensionality.on_dom",
"PulseCore.Semantics.__proj__Mkstate__item__pred",
"PulseCore.Semantics.m",
"FStar.FunctionalExtensionality.on_domain"
] | [] | false | false | false | false | false | let bind
(#a: Type u#a)
(#b: Type u#b)
(#pre1: slprop)
(#post1: (a -> slprop))
(#post2: (b -> slprop))
(e1: stt a pre1 post1)
(e2: (x: a -> stt b (post1 x) post2))
: stt b pre1 post2 =
| fun _ -> Sem.mbind (e1 ()) (fun x -> e2 x ()) | false |
PulseCore.InstantiatedSemantics.fst | PulseCore.InstantiatedSemantics.frame | val frame
(#a:Type u#a)
(#pre:slprop) (#post:a -> slprop)
(frame:slprop)
(e:stt a pre post)
: stt a (pre ** frame) (fun x -> post x ** frame) | val frame
(#a:Type u#a)
(#pre:slprop) (#post:a -> slprop)
(frame:slprop)
(e:stt a pre post)
: stt a (pre ** frame) (fun x -> post x ** frame) | let frame
(#a:Type u#a)
(#pre:slprop) (#post:a -> slprop)
(frame:slprop)
(e:stt a pre post)
: stt a (pre `star` frame) (fun x -> post x `star` frame)
= fun _ -> Sem.frame frame (e()) | {
"file_name": "lib/pulse_core/PulseCore.InstantiatedSemantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 32,
"end_line": 139,
"start_col": 0,
"start_line": 133
} | module PulseCore.InstantiatedSemantics
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module U = FStar.Universe
module F = FStar.FunctionalExtensionality
open PulseCore.Memory
let laws ()
: squash (
Sem.associative star /\
Sem.commutative star /\
Sem.is_unit emp star
)
= let equiv_eq (x y:slprop)
: Lemma (x `equiv` y <==> x == y)
[SMTPat (x `equiv` y)]
= introduce x `equiv` y ==> x == y
with _h . slprop_extensionality x y
in
let _ : squash (Sem.associative star) =
introduce
forall x y z.
((x `star` y) `star` z) ==
(x `star` (y `star` z))
with star_associative x y z
in
let _ : squash (Sem.commutative star) =
introduce
forall x y.
x `star` y == y `star` x
with star_commutative x y
in
let _ : squash (Sem.is_unit emp star) =
introduce
forall x.
(x `star` emp) == x /\
(emp `star` x) == x
with emp_unit x
in
()
let state0 (e:inames) : Sem.state = {
max_act = U.raise_t u#0 u#100 unit;
s = mem;
is_full_mem = full_mem_pred;
pred = slprop;
emp = emp;
star = star;
interp = interp;
evolves = mem_evolves;
invariant = locks_invariant e;
laws = laws ()
}
let state : Sem.state = state0 Set.empty
let slprop = slprop
let _eq : squash (slprop == state.pred) = ()
let emp = emp
let pure p = pure p
let ( ** ) p q = p `star` q
let ( exists* ) #a p = h_exists (F.on_dom a p)
let prop_squash_idem (p:prop)
: Tot (squash (p == squash p))
= FStar.PropositionalExtensionality.apply p (squash p)
let slprop_equiv p q = Mem.equiv p q
let unsquash (p:squash (slprop_equiv 'p 'q)) : slprop_equiv 'p 'q =
prop_squash_idem (slprop_equiv 'p 'q);
coerce_eq () p
let slprop_equiv_refl p = unsquash ()
let slprop_equiv_elim p q =
introduce (p `slprop_equiv` q) ==> p==q
with _ . Mem.slprop_extensionality p q
let slprop_equiv_unit p = unsquash ()
let slprop_equiv_comm p1 p2 = unsquash ()
let slprop_equiv_assoc p1 p2 p3 = unsquash ()
module T = FStar.Tactics.V2
let slprop_equiv_exists
(#a:Type)
(p q: a -> slprop)
(_:squash (forall x. slprop_equiv (p x) (q x)))
= introduce forall x. p x == q x
with slprop_equiv_elim (p x) (q x);
F.extensionality _ _ p q;
let pf : squash (eq2 #(F.arrow a (fun _ -> slprop))
(F.on_dom a p)
(F.on_dom a q)) = ()
in
let x : squash (op_exists_Star p == op_exists_Star q) = _ by (
T.norm [delta_only [`%op_exists_Star; `%F.on_dom]; unascribe];
let bindings = T.cur_vars() in
let bindings = List.Tot.rev bindings in
match bindings with
| hd::_ -> (
match T.term_as_formula hd.sort with
| T.Comp (T.Eq _) lhs rhs ->
T.grewrite lhs rhs;
T.trefl();
T.exact (T.binding_to_term hd)
| _ -> T.fail "Unexpected type of hd"
)
| _ ->
T.fail "empty bindings"
) in
unsquash x
(* The type of general-purpose computations *)
let lower (t:Type u#a) : Type0 = unit -> Dv t
let stt (a:Type u#a)
(pre:slprop)
(post:a -> slprop)
: Type0
= lower (Sem.m u#2 u#100 u#a #state a pre (F.on_dom a post))
let return (#a:Type u#a) (x:a) (p:a -> slprop)
: stt a (p x) p
= fun _ -> Sem.ret x (F.on_dom a p)
let bind
(#a:Type u#a) (#b:Type u#b)
(#pre1:slprop) (#post1:a -> slprop) (#post2:b -> slprop)
(e1:stt a pre1 post1)
(e2:(x:a -> stt b (post1 x) post2))
: stt b pre1 post2
= fun _ -> Sem.mbind (e1()) (fun x -> e2 x ()) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.InstantiatedSemantics.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | frame: PulseCore.InstantiatedSemantics.slprop -> e: PulseCore.InstantiatedSemantics.stt a pre post
-> PulseCore.InstantiatedSemantics.stt a (pre ** frame) (fun x -> post x ** frame) | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.InstantiatedSemantics.stt",
"Prims.unit",
"PulseCore.Semantics.frame",
"PulseCore.InstantiatedSemantics.state",
"FStar.FunctionalExtensionality.on_dom",
"PulseCore.Semantics.__proj__Mkstate__item__pred",
"PulseCore.Semantics.m",
"PulseCore.Semantics.__proj__Mkstate__item__star",
"FStar.FunctionalExtensionality.on_domain",
"PulseCore.Memory.star",
"PulseCore.InstantiatedSemantics.op_Star_Star"
] | [] | false | false | false | false | false | let frame (#a: Type u#a) (#pre: slprop) (#post: (a -> slprop)) (frame: slprop) (e: stt a pre post)
: stt a (pre `star` frame) (fun x -> (post x) `star` frame) =
| fun _ -> Sem.frame frame (e ()) | false |
PulseCore.InstantiatedSemantics.fst | PulseCore.InstantiatedSemantics.hide_div | val hide_div #a #pre #post (f:unit -> Dv (stt a pre post))
: stt a pre post | val hide_div #a #pre #post (f:unit -> Dv (stt a pre post))
: stt a pre post | let hide_div #a #pre #post (f:unit -> Dv (stt a pre post))
: stt a pre post
= fun _ -> f () () | {
"file_name": "lib/pulse_core/PulseCore.InstantiatedSemantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 18,
"end_line": 170,
"start_col": 0,
"start_line": 168
} | module PulseCore.InstantiatedSemantics
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module U = FStar.Universe
module F = FStar.FunctionalExtensionality
open PulseCore.Memory
let laws ()
: squash (
Sem.associative star /\
Sem.commutative star /\
Sem.is_unit emp star
)
= let equiv_eq (x y:slprop)
: Lemma (x `equiv` y <==> x == y)
[SMTPat (x `equiv` y)]
= introduce x `equiv` y ==> x == y
with _h . slprop_extensionality x y
in
let _ : squash (Sem.associative star) =
introduce
forall x y z.
((x `star` y) `star` z) ==
(x `star` (y `star` z))
with star_associative x y z
in
let _ : squash (Sem.commutative star) =
introduce
forall x y.
x `star` y == y `star` x
with star_commutative x y
in
let _ : squash (Sem.is_unit emp star) =
introduce
forall x.
(x `star` emp) == x /\
(emp `star` x) == x
with emp_unit x
in
()
let state0 (e:inames) : Sem.state = {
max_act = U.raise_t u#0 u#100 unit;
s = mem;
is_full_mem = full_mem_pred;
pred = slprop;
emp = emp;
star = star;
interp = interp;
evolves = mem_evolves;
invariant = locks_invariant e;
laws = laws ()
}
let state : Sem.state = state0 Set.empty
let slprop = slprop
let _eq : squash (slprop == state.pred) = ()
let emp = emp
let pure p = pure p
let ( ** ) p q = p `star` q
let ( exists* ) #a p = h_exists (F.on_dom a p)
let prop_squash_idem (p:prop)
: Tot (squash (p == squash p))
= FStar.PropositionalExtensionality.apply p (squash p)
let slprop_equiv p q = Mem.equiv p q
let unsquash (p:squash (slprop_equiv 'p 'q)) : slprop_equiv 'p 'q =
prop_squash_idem (slprop_equiv 'p 'q);
coerce_eq () p
let slprop_equiv_refl p = unsquash ()
let slprop_equiv_elim p q =
introduce (p `slprop_equiv` q) ==> p==q
with _ . Mem.slprop_extensionality p q
let slprop_equiv_unit p = unsquash ()
let slprop_equiv_comm p1 p2 = unsquash ()
let slprop_equiv_assoc p1 p2 p3 = unsquash ()
module T = FStar.Tactics.V2
let slprop_equiv_exists
(#a:Type)
(p q: a -> slprop)
(_:squash (forall x. slprop_equiv (p x) (q x)))
= introduce forall x. p x == q x
with slprop_equiv_elim (p x) (q x);
F.extensionality _ _ p q;
let pf : squash (eq2 #(F.arrow a (fun _ -> slprop))
(F.on_dom a p)
(F.on_dom a q)) = ()
in
let x : squash (op_exists_Star p == op_exists_Star q) = _ by (
T.norm [delta_only [`%op_exists_Star; `%F.on_dom]; unascribe];
let bindings = T.cur_vars() in
let bindings = List.Tot.rev bindings in
match bindings with
| hd::_ -> (
match T.term_as_formula hd.sort with
| T.Comp (T.Eq _) lhs rhs ->
T.grewrite lhs rhs;
T.trefl();
T.exact (T.binding_to_term hd)
| _ -> T.fail "Unexpected type of hd"
)
| _ ->
T.fail "empty bindings"
) in
unsquash x
(* The type of general-purpose computations *)
let lower (t:Type u#a) : Type0 = unit -> Dv t
let stt (a:Type u#a)
(pre:slprop)
(post:a -> slprop)
: Type0
= lower (Sem.m u#2 u#100 u#a #state a pre (F.on_dom a post))
let return (#a:Type u#a) (x:a) (p:a -> slprop)
: stt a (p x) p
= fun _ -> Sem.ret x (F.on_dom a p)
let bind
(#a:Type u#a) (#b:Type u#b)
(#pre1:slprop) (#post1:a -> slprop) (#post2:b -> slprop)
(e1:stt a pre1 post1)
(e2:(x:a -> stt b (post1 x) post2))
: stt b pre1 post2
= fun _ -> Sem.mbind (e1()) (fun x -> e2 x ())
let frame
(#a:Type u#a)
(#pre:slprop) (#post:a -> slprop)
(frame:slprop)
(e:stt a pre post)
: stt a (pre `star` frame) (fun x -> post x `star` frame)
= fun _ -> Sem.frame frame (e())
let conv (#a:Type u#a)
(pre1:slprop)
(pre2:slprop)
(post1:a -> slprop)
(post2:a -> slprop)
(pf1:slprop_equiv pre1 pre2)
(pf2:slprop_post_equiv post1 post2)
: Lemma (stt a pre1 post1 == stt a pre2 post2)
= slprop_equiv_elim pre1 pre2;
introduce forall x. post1 x == post2 x
with slprop_equiv_elim (post1 x) (post2 x);
Sem.conv #state a #pre1 #(F.on_dom _ post1) (F.on_dom _ post2);
()
let sub (#a:Type u#a)
(#pre1:slprop)
(pre2:slprop)
(#post1:a -> slprop)
(post2:a -> slprop)
(pf1:slprop_equiv pre1 pre2)
(pf2:slprop_post_equiv post1 post2)
(e:stt a pre1 post1)
: stt a pre2 post2
= coerce_eq (conv pre1 pre2 post1 post2 pf1 pf2) e
let par f0 f1 = fun _ -> Sem.par (f0 ()) (f1 ()) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.InstantiatedSemantics.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | f: (_: Prims.unit -> FStar.Pervasives.Dv (PulseCore.InstantiatedSemantics.stt a pre post))
-> PulseCore.InstantiatedSemantics.stt a pre post | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"Prims.unit",
"PulseCore.InstantiatedSemantics.stt",
"PulseCore.Semantics.m",
"PulseCore.InstantiatedSemantics.state",
"FStar.FunctionalExtensionality.on_dom",
"PulseCore.Semantics.__proj__Mkstate__item__pred"
] | [] | false | false | false | false | false | let hide_div #a #pre #post (f: (unit -> Dv (stt a pre post))) : stt a pre post =
| fun _ -> f () () | false |
PulseCore.InstantiatedSemantics.fst | PulseCore.InstantiatedSemantics.par | val par (#p0 #q0 #p1 #q1:_)
(f0:stt unit p0 (fun _ -> q0))
(f1:stt unit p1 (fun _ -> q1))
: stt unit (p0 ** p1) (fun _ -> q0 ** q1) | val par (#p0 #q0 #p1 #q1:_)
(f0:stt unit p0 (fun _ -> q0))
(f1:stt unit p1 (fun _ -> q1))
: stt unit (p0 ** p1) (fun _ -> q0 ** q1) | let par f0 f1 = fun _ -> Sem.par (f0 ()) (f1 ()) | {
"file_name": "lib/pulse_core/PulseCore.InstantiatedSemantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 48,
"end_line": 166,
"start_col": 0,
"start_line": 166
} | module PulseCore.InstantiatedSemantics
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module U = FStar.Universe
module F = FStar.FunctionalExtensionality
open PulseCore.Memory
let laws ()
: squash (
Sem.associative star /\
Sem.commutative star /\
Sem.is_unit emp star
)
= let equiv_eq (x y:slprop)
: Lemma (x `equiv` y <==> x == y)
[SMTPat (x `equiv` y)]
= introduce x `equiv` y ==> x == y
with _h . slprop_extensionality x y
in
let _ : squash (Sem.associative star) =
introduce
forall x y z.
((x `star` y) `star` z) ==
(x `star` (y `star` z))
with star_associative x y z
in
let _ : squash (Sem.commutative star) =
introduce
forall x y.
x `star` y == y `star` x
with star_commutative x y
in
let _ : squash (Sem.is_unit emp star) =
introduce
forall x.
(x `star` emp) == x /\
(emp `star` x) == x
with emp_unit x
in
()
let state0 (e:inames) : Sem.state = {
max_act = U.raise_t u#0 u#100 unit;
s = mem;
is_full_mem = full_mem_pred;
pred = slprop;
emp = emp;
star = star;
interp = interp;
evolves = mem_evolves;
invariant = locks_invariant e;
laws = laws ()
}
let state : Sem.state = state0 Set.empty
let slprop = slprop
let _eq : squash (slprop == state.pred) = ()
let emp = emp
let pure p = pure p
let ( ** ) p q = p `star` q
let ( exists* ) #a p = h_exists (F.on_dom a p)
let prop_squash_idem (p:prop)
: Tot (squash (p == squash p))
= FStar.PropositionalExtensionality.apply p (squash p)
let slprop_equiv p q = Mem.equiv p q
let unsquash (p:squash (slprop_equiv 'p 'q)) : slprop_equiv 'p 'q =
prop_squash_idem (slprop_equiv 'p 'q);
coerce_eq () p
let slprop_equiv_refl p = unsquash ()
let slprop_equiv_elim p q =
introduce (p `slprop_equiv` q) ==> p==q
with _ . Mem.slprop_extensionality p q
let slprop_equiv_unit p = unsquash ()
let slprop_equiv_comm p1 p2 = unsquash ()
let slprop_equiv_assoc p1 p2 p3 = unsquash ()
module T = FStar.Tactics.V2
let slprop_equiv_exists
(#a:Type)
(p q: a -> slprop)
(_:squash (forall x. slprop_equiv (p x) (q x)))
= introduce forall x. p x == q x
with slprop_equiv_elim (p x) (q x);
F.extensionality _ _ p q;
let pf : squash (eq2 #(F.arrow a (fun _ -> slprop))
(F.on_dom a p)
(F.on_dom a q)) = ()
in
let x : squash (op_exists_Star p == op_exists_Star q) = _ by (
T.norm [delta_only [`%op_exists_Star; `%F.on_dom]; unascribe];
let bindings = T.cur_vars() in
let bindings = List.Tot.rev bindings in
match bindings with
| hd::_ -> (
match T.term_as_formula hd.sort with
| T.Comp (T.Eq _) lhs rhs ->
T.grewrite lhs rhs;
T.trefl();
T.exact (T.binding_to_term hd)
| _ -> T.fail "Unexpected type of hd"
)
| _ ->
T.fail "empty bindings"
) in
unsquash x
(* The type of general-purpose computations *)
let lower (t:Type u#a) : Type0 = unit -> Dv t
let stt (a:Type u#a)
(pre:slprop)
(post:a -> slprop)
: Type0
= lower (Sem.m u#2 u#100 u#a #state a pre (F.on_dom a post))
let return (#a:Type u#a) (x:a) (p:a -> slprop)
: stt a (p x) p
= fun _ -> Sem.ret x (F.on_dom a p)
let bind
(#a:Type u#a) (#b:Type u#b)
(#pre1:slprop) (#post1:a -> slprop) (#post2:b -> slprop)
(e1:stt a pre1 post1)
(e2:(x:a -> stt b (post1 x) post2))
: stt b pre1 post2
= fun _ -> Sem.mbind (e1()) (fun x -> e2 x ())
let frame
(#a:Type u#a)
(#pre:slprop) (#post:a -> slprop)
(frame:slprop)
(e:stt a pre post)
: stt a (pre `star` frame) (fun x -> post x `star` frame)
= fun _ -> Sem.frame frame (e())
let conv (#a:Type u#a)
(pre1:slprop)
(pre2:slprop)
(post1:a -> slprop)
(post2:a -> slprop)
(pf1:slprop_equiv pre1 pre2)
(pf2:slprop_post_equiv post1 post2)
: Lemma (stt a pre1 post1 == stt a pre2 post2)
= slprop_equiv_elim pre1 pre2;
introduce forall x. post1 x == post2 x
with slprop_equiv_elim (post1 x) (post2 x);
Sem.conv #state a #pre1 #(F.on_dom _ post1) (F.on_dom _ post2);
()
let sub (#a:Type u#a)
(#pre1:slprop)
(pre2:slprop)
(#post1:a -> slprop)
(post2:a -> slprop)
(pf1:slprop_equiv pre1 pre2)
(pf2:slprop_post_equiv post1 post2)
(e:stt a pre1 post1)
: stt a pre2 post2
= coerce_eq (conv pre1 pre2 post1 post2 pf1 pf2) e | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.InstantiatedSemantics.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
f0: PulseCore.InstantiatedSemantics.stt Prims.unit p0 (fun _ -> q0) ->
f1: PulseCore.InstantiatedSemantics.stt Prims.unit p1 (fun _ -> q1)
-> PulseCore.InstantiatedSemantics.stt Prims.unit (p0 ** p1) (fun _ -> q0 ** q1) | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.InstantiatedSemantics.stt",
"Prims.unit",
"PulseCore.Semantics.par",
"PulseCore.InstantiatedSemantics.state",
"PulseCore.Semantics.m",
"PulseCore.Semantics.__proj__Mkstate__item__star",
"PulseCore.Semantics.as_post",
"FStar.FunctionalExtensionality.on_dom",
"PulseCore.Semantics.__proj__Mkstate__item__pred",
"PulseCore.InstantiatedSemantics.op_Star_Star"
] | [] | false | false | false | false | false | let par f0 f1 =
| fun _ -> Sem.par (f0 ()) (f1 ()) | false |
PulseCore.InstantiatedSemantics.fst | PulseCore.InstantiatedSemantics.sub | val sub (#a:Type u#a)
(#pre1:slprop)
(pre2:slprop)
(#post1:a -> slprop)
(post2:a -> slprop)
(pf1:slprop_equiv pre1 pre2)
(pf2:slprop_post_equiv post1 post2)
(e:stt a pre1 post1)
: stt a pre2 post2 | val sub (#a:Type u#a)
(#pre1:slprop)
(pre2:slprop)
(#post1:a -> slprop)
(post2:a -> slprop)
(pf1:slprop_equiv pre1 pre2)
(pf2:slprop_post_equiv post1 post2)
(e:stt a pre1 post1)
: stt a pre2 post2 | let sub (#a:Type u#a)
(#pre1:slprop)
(pre2:slprop)
(#post1:a -> slprop)
(post2:a -> slprop)
(pf1:slprop_equiv pre1 pre2)
(pf2:slprop_post_equiv post1 post2)
(e:stt a pre1 post1)
: stt a pre2 post2
= coerce_eq (conv pre1 pre2 post1 post2 pf1 pf2) e | {
"file_name": "lib/pulse_core/PulseCore.InstantiatedSemantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 50,
"end_line": 164,
"start_col": 0,
"start_line": 155
} | module PulseCore.InstantiatedSemantics
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module U = FStar.Universe
module F = FStar.FunctionalExtensionality
open PulseCore.Memory
let laws ()
: squash (
Sem.associative star /\
Sem.commutative star /\
Sem.is_unit emp star
)
= let equiv_eq (x y:slprop)
: Lemma (x `equiv` y <==> x == y)
[SMTPat (x `equiv` y)]
= introduce x `equiv` y ==> x == y
with _h . slprop_extensionality x y
in
let _ : squash (Sem.associative star) =
introduce
forall x y z.
((x `star` y) `star` z) ==
(x `star` (y `star` z))
with star_associative x y z
in
let _ : squash (Sem.commutative star) =
introduce
forall x y.
x `star` y == y `star` x
with star_commutative x y
in
let _ : squash (Sem.is_unit emp star) =
introduce
forall x.
(x `star` emp) == x /\
(emp `star` x) == x
with emp_unit x
in
()
let state0 (e:inames) : Sem.state = {
max_act = U.raise_t u#0 u#100 unit;
s = mem;
is_full_mem = full_mem_pred;
pred = slprop;
emp = emp;
star = star;
interp = interp;
evolves = mem_evolves;
invariant = locks_invariant e;
laws = laws ()
}
let state : Sem.state = state0 Set.empty
let slprop = slprop
let _eq : squash (slprop == state.pred) = ()
let emp = emp
let pure p = pure p
let ( ** ) p q = p `star` q
let ( exists* ) #a p = h_exists (F.on_dom a p)
let prop_squash_idem (p:prop)
: Tot (squash (p == squash p))
= FStar.PropositionalExtensionality.apply p (squash p)
let slprop_equiv p q = Mem.equiv p q
let unsquash (p:squash (slprop_equiv 'p 'q)) : slprop_equiv 'p 'q =
prop_squash_idem (slprop_equiv 'p 'q);
coerce_eq () p
let slprop_equiv_refl p = unsquash ()
let slprop_equiv_elim p q =
introduce (p `slprop_equiv` q) ==> p==q
with _ . Mem.slprop_extensionality p q
let slprop_equiv_unit p = unsquash ()
let slprop_equiv_comm p1 p2 = unsquash ()
let slprop_equiv_assoc p1 p2 p3 = unsquash ()
module T = FStar.Tactics.V2
let slprop_equiv_exists
(#a:Type)
(p q: a -> slprop)
(_:squash (forall x. slprop_equiv (p x) (q x)))
= introduce forall x. p x == q x
with slprop_equiv_elim (p x) (q x);
F.extensionality _ _ p q;
let pf : squash (eq2 #(F.arrow a (fun _ -> slprop))
(F.on_dom a p)
(F.on_dom a q)) = ()
in
let x : squash (op_exists_Star p == op_exists_Star q) = _ by (
T.norm [delta_only [`%op_exists_Star; `%F.on_dom]; unascribe];
let bindings = T.cur_vars() in
let bindings = List.Tot.rev bindings in
match bindings with
| hd::_ -> (
match T.term_as_formula hd.sort with
| T.Comp (T.Eq _) lhs rhs ->
T.grewrite lhs rhs;
T.trefl();
T.exact (T.binding_to_term hd)
| _ -> T.fail "Unexpected type of hd"
)
| _ ->
T.fail "empty bindings"
) in
unsquash x
(* The type of general-purpose computations *)
let lower (t:Type u#a) : Type0 = unit -> Dv t
let stt (a:Type u#a)
(pre:slprop)
(post:a -> slprop)
: Type0
= lower (Sem.m u#2 u#100 u#a #state a pre (F.on_dom a post))
let return (#a:Type u#a) (x:a) (p:a -> slprop)
: stt a (p x) p
= fun _ -> Sem.ret x (F.on_dom a p)
let bind
(#a:Type u#a) (#b:Type u#b)
(#pre1:slprop) (#post1:a -> slprop) (#post2:b -> slprop)
(e1:stt a pre1 post1)
(e2:(x:a -> stt b (post1 x) post2))
: stt b pre1 post2
= fun _ -> Sem.mbind (e1()) (fun x -> e2 x ())
let frame
(#a:Type u#a)
(#pre:slprop) (#post:a -> slprop)
(frame:slprop)
(e:stt a pre post)
: stt a (pre `star` frame) (fun x -> post x `star` frame)
= fun _ -> Sem.frame frame (e())
let conv (#a:Type u#a)
(pre1:slprop)
(pre2:slprop)
(post1:a -> slprop)
(post2:a -> slprop)
(pf1:slprop_equiv pre1 pre2)
(pf2:slprop_post_equiv post1 post2)
: Lemma (stt a pre1 post1 == stt a pre2 post2)
= slprop_equiv_elim pre1 pre2;
introduce forall x. post1 x == post2 x
with slprop_equiv_elim (post1 x) (post2 x);
Sem.conv #state a #pre1 #(F.on_dom _ post1) (F.on_dom _ post2);
() | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.InstantiatedSemantics.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
pre2: PulseCore.InstantiatedSemantics.slprop ->
post2: (_: a -> PulseCore.InstantiatedSemantics.slprop) ->
pf1: PulseCore.InstantiatedSemantics.slprop_equiv pre1 pre2 ->
pf2: PulseCore.InstantiatedSemantics.slprop_post_equiv post1 post2 ->
e: PulseCore.InstantiatedSemantics.stt a pre1 post1
-> PulseCore.InstantiatedSemantics.stt a pre2 post2 | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.InstantiatedSemantics.slprop_equiv",
"PulseCore.InstantiatedSemantics.slprop_post_equiv",
"PulseCore.InstantiatedSemantics.stt",
"FStar.Pervasives.coerce_eq",
"PulseCore.InstantiatedSemantics.conv"
] | [] | false | false | false | false | false | let sub
(#a: Type u#a)
(#pre1 pre2: slprop)
(#post1 post2: (a -> slprop))
(pf1: slprop_equiv pre1 pre2)
(pf2: slprop_post_equiv post1 post2)
(e: stt a pre1 post1)
: stt a pre2 post2 =
| coerce_eq (conv pre1 pre2 post1 post2 pf1 pf2) e | false |
PulseCore.InstantiatedSemantics.fst | PulseCore.InstantiatedSemantics.laws | val laws: Prims.unit
-> squash (Sem.associative star /\ Sem.commutative star /\ Sem.is_unit emp star) | val laws: Prims.unit
-> squash (Sem.associative star /\ Sem.commutative star /\ Sem.is_unit emp star) | let laws ()
: squash (
Sem.associative star /\
Sem.commutative star /\
Sem.is_unit emp star
)
= let equiv_eq (x y:slprop)
: Lemma (x `equiv` y <==> x == y)
[SMTPat (x `equiv` y)]
= introduce x `equiv` y ==> x == y
with _h . slprop_extensionality x y
in
let _ : squash (Sem.associative star) =
introduce
forall x y z.
((x `star` y) `star` z) ==
(x `star` (y `star` z))
with star_associative x y z
in
let _ : squash (Sem.commutative star) =
introduce
forall x y.
x `star` y == y `star` x
with star_commutative x y
in
let _ : squash (Sem.is_unit emp star) =
introduce
forall x.
(x `star` emp) == x /\
(emp `star` x) == x
with emp_unit x
in
() | {
"file_name": "lib/pulse_core/PulseCore.InstantiatedSemantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 4,
"end_line": 40,
"start_col": 0,
"start_line": 8
} | module PulseCore.InstantiatedSemantics
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module U = FStar.Universe
module F = FStar.FunctionalExtensionality
open PulseCore.Memory | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.InstantiatedSemantics.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit
-> Prims.squash (PulseCore.Semantics.associative PulseCore.Memory.star /\
PulseCore.Semantics.commutative PulseCore.Memory.star /\
PulseCore.Semantics.is_unit PulseCore.Memory.emp PulseCore.Memory.star) | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"Prims.squash",
"PulseCore.Semantics.is_unit",
"PulseCore.Memory.slprop",
"PulseCore.Memory.emp",
"PulseCore.Memory.star",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_and",
"Prims.eq2",
"PulseCore.Memory.emp_unit",
"PulseCore.Semantics.commutative",
"Prims.l_Forall",
"PulseCore.Memory.star_commutative",
"PulseCore.Semantics.associative",
"PulseCore.Memory.star_associative",
"Prims.l_True",
"Prims.l_iff",
"PulseCore.Memory.equiv",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.prop",
"Prims.Nil",
"FStar.Classical.Sugar.implies_intro",
"PulseCore.Memory.slprop_extensionality"
] | [] | false | false | true | true | false | let laws () : squash (Sem.associative star /\ Sem.commutative star /\ Sem.is_unit emp star) =
| let equiv_eq (x y: slprop) : Lemma (x `equiv` y <==> x == y) [SMTPat (x `equiv` y)] =
introduce x `equiv` y ==> x == y
with _h. slprop_extensionality x y
in
let _:squash (Sem.associative star) =
introduce forall x y z . ((x `star` y) `star` z) == (x `star` (y `star` z))
with star_associative x y z
in
let _:squash (Sem.commutative star) =
introduce forall x y . x `star` y == y `star` x
with star_commutative x y
in
let _:squash (Sem.is_unit emp star) =
introduce forall x . (x `star` emp) == x /\ (emp `star` x) == x
with emp_unit x
in
() | false |
PulseCore.InstantiatedSemantics.fst | PulseCore.InstantiatedSemantics.slprop_equiv_unit | val slprop_equiv_unit (x:slprop)
: slprop_equiv (emp ** x) x | val slprop_equiv_unit (x:slprop)
: slprop_equiv (emp ** x) x | let slprop_equiv_unit p = unsquash () | {
"file_name": "lib/pulse_core/PulseCore.InstantiatedSemantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 37,
"end_line": 80,
"start_col": 0,
"start_line": 80
} | module PulseCore.InstantiatedSemantics
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module U = FStar.Universe
module F = FStar.FunctionalExtensionality
open PulseCore.Memory
let laws ()
: squash (
Sem.associative star /\
Sem.commutative star /\
Sem.is_unit emp star
)
= let equiv_eq (x y:slprop)
: Lemma (x `equiv` y <==> x == y)
[SMTPat (x `equiv` y)]
= introduce x `equiv` y ==> x == y
with _h . slprop_extensionality x y
in
let _ : squash (Sem.associative star) =
introduce
forall x y z.
((x `star` y) `star` z) ==
(x `star` (y `star` z))
with star_associative x y z
in
let _ : squash (Sem.commutative star) =
introduce
forall x y.
x `star` y == y `star` x
with star_commutative x y
in
let _ : squash (Sem.is_unit emp star) =
introduce
forall x.
(x `star` emp) == x /\
(emp `star` x) == x
with emp_unit x
in
()
let state0 (e:inames) : Sem.state = {
max_act = U.raise_t u#0 u#100 unit;
s = mem;
is_full_mem = full_mem_pred;
pred = slprop;
emp = emp;
star = star;
interp = interp;
evolves = mem_evolves;
invariant = locks_invariant e;
laws = laws ()
}
let state : Sem.state = state0 Set.empty
let slprop = slprop
let _eq : squash (slprop == state.pred) = ()
let emp = emp
let pure p = pure p
let ( ** ) p q = p `star` q
let ( exists* ) #a p = h_exists (F.on_dom a p)
let prop_squash_idem (p:prop)
: Tot (squash (p == squash p))
= FStar.PropositionalExtensionality.apply p (squash p)
let slprop_equiv p q = Mem.equiv p q
let unsquash (p:squash (slprop_equiv 'p 'q)) : slprop_equiv 'p 'q =
prop_squash_idem (slprop_equiv 'p 'q);
coerce_eq () p
let slprop_equiv_refl p = unsquash ()
let slprop_equiv_elim p q =
introduce (p `slprop_equiv` q) ==> p==q
with _ . Mem.slprop_extensionality p q | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.InstantiatedSemantics.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x: PulseCore.InstantiatedSemantics.slprop
-> PulseCore.InstantiatedSemantics.slprop_equiv (PulseCore.InstantiatedSemantics.emp ** x) x | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.InstantiatedSemantics.unsquash",
"PulseCore.InstantiatedSemantics.op_Star_Star",
"PulseCore.InstantiatedSemantics.emp",
"PulseCore.InstantiatedSemantics.slprop_equiv"
] | [] | false | false | false | false | false | let slprop_equiv_unit p =
| unsquash () | false |
PulseCore.InstantiatedSemantics.fst | PulseCore.InstantiatedSemantics.slprop_equiv_refl | val slprop_equiv_refl (p:slprop)
: slprop_equiv p p | val slprop_equiv_refl (p:slprop)
: slprop_equiv p p | let slprop_equiv_refl p = unsquash () | {
"file_name": "lib/pulse_core/PulseCore.InstantiatedSemantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 37,
"end_line": 74,
"start_col": 0,
"start_line": 74
} | module PulseCore.InstantiatedSemantics
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module U = FStar.Universe
module F = FStar.FunctionalExtensionality
open PulseCore.Memory
let laws ()
: squash (
Sem.associative star /\
Sem.commutative star /\
Sem.is_unit emp star
)
= let equiv_eq (x y:slprop)
: Lemma (x `equiv` y <==> x == y)
[SMTPat (x `equiv` y)]
= introduce x `equiv` y ==> x == y
with _h . slprop_extensionality x y
in
let _ : squash (Sem.associative star) =
introduce
forall x y z.
((x `star` y) `star` z) ==
(x `star` (y `star` z))
with star_associative x y z
in
let _ : squash (Sem.commutative star) =
introduce
forall x y.
x `star` y == y `star` x
with star_commutative x y
in
let _ : squash (Sem.is_unit emp star) =
introduce
forall x.
(x `star` emp) == x /\
(emp `star` x) == x
with emp_unit x
in
()
let state0 (e:inames) : Sem.state = {
max_act = U.raise_t u#0 u#100 unit;
s = mem;
is_full_mem = full_mem_pred;
pred = slprop;
emp = emp;
star = star;
interp = interp;
evolves = mem_evolves;
invariant = locks_invariant e;
laws = laws ()
}
let state : Sem.state = state0 Set.empty
let slprop = slprop
let _eq : squash (slprop == state.pred) = ()
let emp = emp
let pure p = pure p
let ( ** ) p q = p `star` q
let ( exists* ) #a p = h_exists (F.on_dom a p)
let prop_squash_idem (p:prop)
: Tot (squash (p == squash p))
= FStar.PropositionalExtensionality.apply p (squash p)
let slprop_equiv p q = Mem.equiv p q
let unsquash (p:squash (slprop_equiv 'p 'q)) : slprop_equiv 'p 'q =
prop_squash_idem (slprop_equiv 'p 'q);
coerce_eq () p | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.InstantiatedSemantics.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p: PulseCore.InstantiatedSemantics.slprop -> PulseCore.InstantiatedSemantics.slprop_equiv p p | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.InstantiatedSemantics.unsquash",
"PulseCore.InstantiatedSemantics.slprop_equiv"
] | [] | false | false | false | false | false | let slprop_equiv_refl p =
| unsquash () | false |
PulseCore.InstantiatedSemantics.fst | PulseCore.InstantiatedSemantics.prop_squash_idem | val prop_squash_idem (p: prop) : Tot (squash (p == squash p)) | val prop_squash_idem (p: prop) : Tot (squash (p == squash p)) | let prop_squash_idem (p:prop)
: Tot (squash (p == squash p))
= FStar.PropositionalExtensionality.apply p (squash p) | {
"file_name": "lib/pulse_core/PulseCore.InstantiatedSemantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 56,
"end_line": 66,
"start_col": 0,
"start_line": 64
} | module PulseCore.InstantiatedSemantics
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module U = FStar.Universe
module F = FStar.FunctionalExtensionality
open PulseCore.Memory
let laws ()
: squash (
Sem.associative star /\
Sem.commutative star /\
Sem.is_unit emp star
)
= let equiv_eq (x y:slprop)
: Lemma (x `equiv` y <==> x == y)
[SMTPat (x `equiv` y)]
= introduce x `equiv` y ==> x == y
with _h . slprop_extensionality x y
in
let _ : squash (Sem.associative star) =
introduce
forall x y z.
((x `star` y) `star` z) ==
(x `star` (y `star` z))
with star_associative x y z
in
let _ : squash (Sem.commutative star) =
introduce
forall x y.
x `star` y == y `star` x
with star_commutative x y
in
let _ : squash (Sem.is_unit emp star) =
introduce
forall x.
(x `star` emp) == x /\
(emp `star` x) == x
with emp_unit x
in
()
let state0 (e:inames) : Sem.state = {
max_act = U.raise_t u#0 u#100 unit;
s = mem;
is_full_mem = full_mem_pred;
pred = slprop;
emp = emp;
star = star;
interp = interp;
evolves = mem_evolves;
invariant = locks_invariant e;
laws = laws ()
}
let state : Sem.state = state0 Set.empty
let slprop = slprop
let _eq : squash (slprop == state.pred) = ()
let emp = emp
let pure p = pure p
let ( ** ) p q = p `star` q
let ( exists* ) #a p = h_exists (F.on_dom a p) | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.InstantiatedSemantics.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p: Prims.prop -> Prims.squash (p == Prims.squash p) | Prims.Tot | [
"total"
] | [] | [
"Prims.prop",
"FStar.PropositionalExtensionality.apply",
"Prims.squash",
"Prims.eq2"
] | [] | false | false | true | false | false | let prop_squash_idem (p: prop) : Tot (squash (p == squash p)) =
| FStar.PropositionalExtensionality.apply p (squash p) | false |
PulseCore.InstantiatedSemantics.fst | PulseCore.InstantiatedSemantics.slprop_equiv_elim | val slprop_equiv_elim (p q:slprop)
: Lemma (p `slprop_equiv` q <==> p==q) | val slprop_equiv_elim (p q:slprop)
: Lemma (p `slprop_equiv` q <==> p==q) | let slprop_equiv_elim p q =
introduce (p `slprop_equiv` q) ==> p==q
with _ . Mem.slprop_extensionality p q | {
"file_name": "lib/pulse_core/PulseCore.InstantiatedSemantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 42,
"end_line": 78,
"start_col": 0,
"start_line": 76
} | module PulseCore.InstantiatedSemantics
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module U = FStar.Universe
module F = FStar.FunctionalExtensionality
open PulseCore.Memory
let laws ()
: squash (
Sem.associative star /\
Sem.commutative star /\
Sem.is_unit emp star
)
= let equiv_eq (x y:slprop)
: Lemma (x `equiv` y <==> x == y)
[SMTPat (x `equiv` y)]
= introduce x `equiv` y ==> x == y
with _h . slprop_extensionality x y
in
let _ : squash (Sem.associative star) =
introduce
forall x y z.
((x `star` y) `star` z) ==
(x `star` (y `star` z))
with star_associative x y z
in
let _ : squash (Sem.commutative star) =
introduce
forall x y.
x `star` y == y `star` x
with star_commutative x y
in
let _ : squash (Sem.is_unit emp star) =
introduce
forall x.
(x `star` emp) == x /\
(emp `star` x) == x
with emp_unit x
in
()
let state0 (e:inames) : Sem.state = {
max_act = U.raise_t u#0 u#100 unit;
s = mem;
is_full_mem = full_mem_pred;
pred = slprop;
emp = emp;
star = star;
interp = interp;
evolves = mem_evolves;
invariant = locks_invariant e;
laws = laws ()
}
let state : Sem.state = state0 Set.empty
let slprop = slprop
let _eq : squash (slprop == state.pred) = ()
let emp = emp
let pure p = pure p
let ( ** ) p q = p `star` q
let ( exists* ) #a p = h_exists (F.on_dom a p)
let prop_squash_idem (p:prop)
: Tot (squash (p == squash p))
= FStar.PropositionalExtensionality.apply p (squash p)
let slprop_equiv p q = Mem.equiv p q
let unsquash (p:squash (slprop_equiv 'p 'q)) : slprop_equiv 'p 'q =
prop_squash_idem (slprop_equiv 'p 'q);
coerce_eq () p
let slprop_equiv_refl p = unsquash () | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.InstantiatedSemantics.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p: PulseCore.InstantiatedSemantics.slprop -> q: PulseCore.InstantiatedSemantics.slprop
-> FStar.Pervasives.Lemma (ensures PulseCore.InstantiatedSemantics.slprop_equiv p q <==> p == q) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"FStar.Classical.Sugar.implies_intro",
"PulseCore.InstantiatedSemantics.slprop_equiv",
"Prims.squash",
"Prims.eq2",
"PulseCore.Memory.slprop_extensionality",
"Prims.unit"
] | [] | false | false | true | false | false | let slprop_equiv_elim p q =
| introduce (p `slprop_equiv` q) ==> p == q
with _. Mem.slprop_extensionality p q | false |
PulseCore.InstantiatedSemantics.fst | PulseCore.InstantiatedSemantics.slprop_equiv_comm | val slprop_equiv_comm (p1 p2:slprop)
: slprop_equiv (p1 ** p2) (p2 ** p1) | val slprop_equiv_comm (p1 p2:slprop)
: slprop_equiv (p1 ** p2) (p2 ** p1) | let slprop_equiv_comm p1 p2 = unsquash () | {
"file_name": "lib/pulse_core/PulseCore.InstantiatedSemantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 41,
"end_line": 81,
"start_col": 0,
"start_line": 81
} | module PulseCore.InstantiatedSemantics
module Sem = PulseCore.Semantics
module Mem = PulseCore.Memory
module U = FStar.Universe
module F = FStar.FunctionalExtensionality
open PulseCore.Memory
let laws ()
: squash (
Sem.associative star /\
Sem.commutative star /\
Sem.is_unit emp star
)
= let equiv_eq (x y:slprop)
: Lemma (x `equiv` y <==> x == y)
[SMTPat (x `equiv` y)]
= introduce x `equiv` y ==> x == y
with _h . slprop_extensionality x y
in
let _ : squash (Sem.associative star) =
introduce
forall x y z.
((x `star` y) `star` z) ==
(x `star` (y `star` z))
with star_associative x y z
in
let _ : squash (Sem.commutative star) =
introduce
forall x y.
x `star` y == y `star` x
with star_commutative x y
in
let _ : squash (Sem.is_unit emp star) =
introduce
forall x.
(x `star` emp) == x /\
(emp `star` x) == x
with emp_unit x
in
()
let state0 (e:inames) : Sem.state = {
max_act = U.raise_t u#0 u#100 unit;
s = mem;
is_full_mem = full_mem_pred;
pred = slprop;
emp = emp;
star = star;
interp = interp;
evolves = mem_evolves;
invariant = locks_invariant e;
laws = laws ()
}
let state : Sem.state = state0 Set.empty
let slprop = slprop
let _eq : squash (slprop == state.pred) = ()
let emp = emp
let pure p = pure p
let ( ** ) p q = p `star` q
let ( exists* ) #a p = h_exists (F.on_dom a p)
let prop_squash_idem (p:prop)
: Tot (squash (p == squash p))
= FStar.PropositionalExtensionality.apply p (squash p)
let slprop_equiv p q = Mem.equiv p q
let unsquash (p:squash (slprop_equiv 'p 'q)) : slprop_equiv 'p 'q =
prop_squash_idem (slprop_equiv 'p 'q);
coerce_eq () p
let slprop_equiv_refl p = unsquash ()
let slprop_equiv_elim p q =
introduce (p `slprop_equiv` q) ==> p==q
with _ . Mem.slprop_extensionality p q | {
"checked_file": "/",
"dependencies": [
"PulseCore.Semantics.fst.checked",
"PulseCore.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "PulseCore.InstantiatedSemantics.fst"
} | [
{
"abbrev": false,
"full_module": "PulseCore.Memory",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "PulseCore.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "PulseCore.Semantics",
"short_module": "Sem"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p1: PulseCore.InstantiatedSemantics.slprop -> p2: PulseCore.InstantiatedSemantics.slprop
-> PulseCore.InstantiatedSemantics.slprop_equiv (p1 ** p2) (p2 ** p1) | Prims.Tot | [
"total"
] | [] | [
"PulseCore.InstantiatedSemantics.slprop",
"PulseCore.InstantiatedSemantics.unsquash",
"PulseCore.InstantiatedSemantics.op_Star_Star",
"PulseCore.InstantiatedSemantics.slprop_equiv"
] | [] | false | false | false | false | false | let slprop_equiv_comm p1 p2 =
| unsquash () | false |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.