effect
stringclasses 48
values | original_source_type
stringlengths 0
23k
| opens_and_abbrevs
listlengths 2
92
| isa_cross_project_example
bool 1
class | source_definition
stringlengths 9
57.9k
| partial_definition
stringlengths 7
23.3k
| is_div
bool 2
classes | is_type
null | is_proof
bool 2
classes | completed_definiton
stringlengths 1
250k
| dependencies
dict | effect_flags
listlengths 0
2
| ideal_premises
listlengths 0
236
| mutual_with
listlengths 0
11
| file_context
stringlengths 0
407k
| interleaved
bool 1
class | is_simply_typed
bool 2
classes | file_name
stringlengths 5
48
| vconfig
dict | is_simple_lemma
null | source_type
stringlengths 10
23k
| proof_features
listlengths 0
1
| name
stringlengths 8
95
| source
dict | verbose_type
stringlengths 1
7.42k
| source_range
dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Prims.Tot
|
[
{
"abbrev": true,
"full_module": "Spec.Agile.HKDF",
"short_module": "HKDF"
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"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.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let labeled_expand_max_length_info (a:hash_algorithm) (size_suite_id:size_nat) (size_local_label:size_nat) =
match a with
| Hash.SHA3_256 -> None
| _ -> Some (Some?.v (Hash.max_input_length a) - Spec.Hash.Definitions.hash_length a - 2 - size_label_version - size_suite_id - size_local_label - 1 - Spec.Hash.Definitions.block_length a)
|
let labeled_expand_max_length_info (a: hash_algorithm) (size_suite_id size_local_label: size_nat) =
| false | null | false |
match a with
| Hash.SHA3_256 -> None
| _ ->
Some
(Some?.v (Hash.max_input_length a) - Spec.Hash.Definitions.hash_length a - 2 - size_label_version -
size_suite_id -
size_local_label -
1 -
Spec.Hash.Definitions.block_length a)
|
{
"checked_file": "Spec.Agile.HPKE.fsti.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HKDF.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"Spec.Agile.DH.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Agile.HPKE.fsti"
}
|
[
"total"
] |
[
"Spec.Agile.HPKE.hash_algorithm",
"Lib.IntTypes.size_nat",
"FStar.Pervasives.Native.None",
"Prims.int",
"Spec.Hash.Definitions.hash_alg",
"FStar.Pervasives.Native.Some",
"Prims.op_Subtraction",
"FStar.Pervasives.Native.__proj__Some__item__v",
"Prims.pos",
"Spec.Hash.Definitions.max_input_length",
"Spec.Hash.Definitions.hash_length",
"Spec.Agile.HPKE.size_label_version",
"Spec.Hash.Definitions.block_length",
"FStar.Pervasives.Native.option"
] |
[] |
module Spec.Agile.HPKE
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module DH = Spec.Agile.DH
module AEAD = Spec.Agile.AEAD
module Hash = Spec.Agile.Hash
module HKDF = Spec.Agile.HKDF
#set-options "--z3rlimit 20 --fuel 0 --ifuel 1"
type mode =
| Base
| PSK
| Auth
| AuthPSK
let is_valid_kem = function
| DH.DH_Curve25519, Hash.SHA2_256
| DH.DH_P256, Hash.SHA2_256 -> true
| _,_ -> false
noeq type aead =
| Seal: alg:AEAD.alg -> aead
| ExportOnly
let is_valid_aead = function
| Seal AEAD.AES128_GCM
| Seal AEAD.AES256_GCM
| Seal AEAD.CHACHA20_POLY1305
| ExportOnly -> true
| _ -> false
let is_valid_hash = function
| Hash.SHA2_256
| Hash.SHA2_384
| Hash.SHA2_512 -> true
| _ -> false
let hash_algorithm = a:Hash.hash_alg{is_valid_hash a}
let is_valid_ciphersuite (cs:DH.algorithm & hash_algorithm & aead & Hash.hash_alg) : bool =
let kem_dh, kem_hash, aead, hash = cs in
(is_valid_kem (kem_dh, kem_hash)) && (is_valid_aead aead) && (is_valid_hash hash)
let ciphersuite = cs:(DH.algorithm & hash_algorithm & aead & Hash.hash_alg){is_valid_ciphersuite cs}
inline_for_extraction
let kem_dh_of_cs (cs:ciphersuite) : DH.algorithm =
let (c,_,_,_) = cs in c
inline_for_extraction
let kem_hash_of_cs (cs:ciphersuite) : hash_algorithm =
let (_,h,_,_) = cs in h
inline_for_extraction
let aead_of_cs (cs:ciphersuite) : aead =
let (_,_,a,_) = cs in a
inline_for_extraction
let hash_of_cs (cs:ciphersuite) : hash_algorithm =
let (_,_,_,h) = cs in h
let is_valid_not_export_only_ciphersuite (cs:ciphersuite) : bool =
match aead_of_cs cs with
| ExportOnly -> false
| Seal _ -> true
let ciphersuite_not_export_only = cs:ciphersuite{is_valid_not_export_only_ciphersuite cs}
inline_for_extraction
let aead_alg_of (cs:ciphersuite_not_export_only) = match aead_of_cs cs with
| Seal alg -> alg
/// Constants for HPKE labels
///
/// The code for the following constants was generated
/// with the script make_hpke_constants.py. Ultimately,
/// this should be rewritten in Meta-F*. The idea is to
/// write a tactic `mk_label` that inspects a string
/// character by character, and generates the proper
/// definition. It could be used as follows:
/// %splice [label_version] (mk_label "HPKE-v1")
/// Inspiration can be taken from Test.Lowstarize.fst.
// generated: "HPKE-v1"
inline_for_extraction
let size_label_version: size_nat = 7
let label_version_list : l:list uint8{List.Tot.length l == size_label_version} =
[@inline_let]
let l = [u8 0x48; u8 0x50; u8 0x4b; u8 0x45; u8 0x2d; u8 0x76; u8 0x31] in
assert_norm(List.Tot.length l == size_label_version);
l
let label_version : lbytes size_label_version = createL label_version_list
// generated: "eae_prk"
inline_for_extraction
let size_label_eae_prk: size_nat = 7
let label_eae_prk_list : l:list uint8{List.Tot.length l == size_label_eae_prk} =
[@inline_let]
let l = [u8 0x65; u8 0x61; u8 0x65; u8 0x5f; u8 0x70; u8 0x72; u8 0x6b] in
assert_norm(List.Tot.length l == size_label_eae_prk);
l
let label_eae_prk : lbytes size_label_eae_prk = createL label_eae_prk_list
// generated: "KEM"
inline_for_extraction
let size_label_KEM: size_nat = 3
let label_KEM_list : l:list uint8{List.Tot.length l == size_label_KEM} =
[@inline_let]
let l = [u8 0x4b; u8 0x45; u8 0x4d] in
assert_norm(List.Tot.length l == size_label_KEM);
l
let label_KEM : lbytes size_label_KEM = createL label_KEM_list
// generated: "HPKE"
inline_for_extraction
let size_label_HPKE: size_nat = 4
let label_HPKE_list : l:list uint8{List.Tot.length l == size_label_HPKE} =
[@inline_let]
let l = [u8 0x48; u8 0x50; u8 0x4b; u8 0x45] in
assert_norm(List.Tot.length l == size_label_HPKE);
l
let label_HPKE : lbytes size_label_HPKE = createL label_HPKE_list
// generated: "shared_secret"
inline_for_extraction
let size_label_shared_secret: size_nat = 13
let label_shared_secret_list : l:list uint8{List.Tot.length l == size_label_shared_secret} =
[@inline_let]
let l = [u8 0x73; u8 0x68; u8 0x61; u8 0x72; u8 0x65; u8 0x64; u8 0x5f; u8 0x73; u8 0x65; u8 0x63; u8 0x72; u8 0x65; u8 0x74] in
assert_norm(List.Tot.length l == size_label_shared_secret);
l
let label_shared_secret : lbytes size_label_shared_secret = createL label_shared_secret_list
// generated: "psk_id_hash"
inline_for_extraction
let size_label_psk_id_hash: size_nat = 11
let label_psk_id_hash_list : l:list uint8{List.Tot.length l == size_label_psk_id_hash} =
[@inline_let]
let l = [u8 0x70; u8 0x73; u8 0x6b; u8 0x5f; u8 0x69; u8 0x64; u8 0x5f; u8 0x68; u8 0x61; u8 0x73; u8 0x68] in
assert_norm(List.Tot.length l == size_label_psk_id_hash);
l
let label_psk_id_hash : lbytes size_label_psk_id_hash = createL label_psk_id_hash_list
// generated: "info_hash"
inline_for_extraction
let size_label_info_hash: size_nat = 9
let label_info_hash_list : l:list uint8{List.Tot.length l == size_label_info_hash} =
[@inline_let]
let l = [u8 0x69; u8 0x6e; u8 0x66; u8 0x6f; u8 0x5f; u8 0x68; u8 0x61; u8 0x73; u8 0x68] in
assert_norm(List.Tot.length l == size_label_info_hash);
l
let label_info_hash : lbytes size_label_info_hash = createL label_info_hash_list
// generated: "secret"
inline_for_extraction
let size_label_secret: size_nat = 6
let label_secret_list : l:list uint8{List.Tot.length l == size_label_secret} =
[@inline_let]
let l = [u8 0x73; u8 0x65; u8 0x63; u8 0x72; u8 0x65; u8 0x74] in
assert_norm(List.Tot.length l == size_label_secret);
l
let label_secret : lbytes size_label_secret = createL label_secret_list
// generated: "key"
inline_for_extraction
let size_label_key: size_nat = 3
let label_key_list : l:list uint8{List.Tot.length l == size_label_key} =
[@inline_let]
let l = [u8 0x6b; u8 0x65; u8 0x79] in
assert_norm(List.Tot.length l == size_label_key);
l
let label_key : lbytes size_label_key = createL label_key_list
// generated: "base_nonce"
inline_for_extraction
let size_label_base_nonce: size_nat = 10
let label_base_nonce_list : l:list uint8{List.Tot.length l == size_label_base_nonce} =
[@inline_let]
let l = [u8 0x62; u8 0x61; u8 0x73; u8 0x65; u8 0x5f; u8 0x6e; u8 0x6f; u8 0x6e; u8 0x63; u8 0x65] in
assert_norm(List.Tot.length l == size_label_base_nonce);
l
let label_base_nonce : lbytes size_label_base_nonce = createL label_base_nonce_list
// generated: "exp"
inline_for_extraction
let size_label_exp: size_nat = 3
let label_exp_list : l:list uint8{List.Tot.length l == size_label_exp} =
[@inline_let]
let l = [u8 0x65; u8 0x78; u8 0x70] in
assert_norm(List.Tot.length l == size_label_exp);
l
let label_exp : lbytes size_label_exp = createL label_exp_list
// generated: "sec"
inline_for_extraction
let size_label_sec: size_nat = 3
let label_sec_list : l:list uint8{List.Tot.length l == size_label_sec} =
[@inline_let]
let l = [u8 0x73; u8 0x65; u8 0x63] in
assert_norm(List.Tot.length l == size_label_sec);
l
let label_sec : lbytes size_label_sec = createL label_sec_list
// generated: "dkp_prk"
inline_for_extraction
let size_label_dkp_prk: size_nat = 7
let label_dkp_prk_list : l:list uint8{List.Tot.length l == size_label_dkp_prk} =
[@inline_let]
let l = [u8 0x64; u8 0x6b; u8 0x70; u8 0x5f; u8 0x70; u8 0x72; u8 0x6b] in
assert_norm(List.Tot.length l == size_label_dkp_prk);
l
let label_dkp_prk : lbytes size_label_dkp_prk = createL label_dkp_prk_list
// generated: "candidate"
inline_for_extraction
let size_label_candidate: size_nat = 9
let label_candidate_list : l:list uint8{List.Tot.length l == size_label_candidate} =
[@inline_let]
let l = [u8 0x63; u8 0x61; u8 0x6e; u8 0x64; u8 0x69; u8 0x64; u8 0x61; u8 0x74; u8 0x65] in
assert_norm(List.Tot.length l == size_label_candidate);
l
let label_candidate : lbytes size_label_candidate = createL label_candidate_list
// generated: "sk"
inline_for_extraction
let size_label_sk: size_nat = 2
let label_sk_list : l:list uint8{List.Tot.length l == size_label_sk} =
[@inline_let]
let l = [u8 0x73; u8 0x6b] in
assert_norm(List.Tot.length l == size_label_sk);
l
let label_sk : lbytes size_label_sk = createL label_sk_list
///
/// Constants sizes
///
inline_for_extraction
let size_aead_nonce (cs:ciphersuite): size_nat =
assert_norm (8 * 12 <= pow2 64 - 1);
match aead_of_cs cs with
| ExportOnly -> 0
| Seal _ -> 12
inline_for_extraction
let size_aead_key (cs:ciphersuite): size_nat =
match aead_of_cs cs with
| ExportOnly -> 0
| Seal _ -> AEAD.key_length (aead_alg_of cs)
inline_for_extraction
let size_aead_tag (cs:ciphersuite): size_nat =
match aead_of_cs cs with
| ExportOnly -> 0
| Seal _ -> AEAD.tag_length (aead_alg_of cs)
inline_for_extraction
let size_dh_key (cs:ciphersuite): size_nat = DH.size_key (kem_dh_of_cs cs)
inline_for_extraction
let size_dh_public (cs:ciphersuite): size_nat = match kem_dh_of_cs cs with
| DH.DH_Curve25519 -> DH.size_public DH.DH_Curve25519
| DH.DH_P256 -> DH.size_public DH.DH_P256 + 1 // Need the additional byte for representation
inline_for_extraction
let size_dh_serialized (cs:ciphersuite): size_nat = match kem_dh_of_cs cs with
| DH.DH_Curve25519 -> DH.size_public DH.DH_Curve25519
| DH.DH_P256 -> DH.size_public DH.DH_P256
inline_for_extraction
let size_kem_kdf (cs:ciphersuite): size_nat = Hash.hash_length (kem_hash_of_cs cs)
inline_for_extraction
let size_kem_key (cs:ciphersuite): size_nat = Hash.hash_length (kem_hash_of_cs cs)
inline_for_extraction
let size_kdf (cs:ciphersuite): size_nat = Hash.hash_length (hash_of_cs cs)
let max_seq (cs:ciphersuite): nat =
match aead_of_cs cs with
| ExportOnly -> 0
| Seal _ -> pow2 (8*(size_aead_nonce cs)) - 1
inline_for_extraction
let size_suite_id_kem: size_nat = size_label_KEM + 2
inline_for_extraction
let size_suite_id_hpke: size_nat = size_label_HPKE + 6
inline_for_extraction
let size_mode_identifier: size_nat = 1
let size_ks_ctx (cs:ciphersuite): size_nat = size_mode_identifier + 2*(size_kdf cs)
let labeled_extract_ikm_length_pred (a:hash_algorithm) (ikm_length:nat) =
HKDF.extract_ikm_length_pred a (size_label_version + ikm_length)
let labeled_expand_info_length_pred (a:hash_algorithm) (info_length:nat) =
HKDF.expand_info_length_pred a (2 + size_label_version + info_length)
let pow2_61_1 : _:unit{pow2 61 - 1 == 2305843009213693951} = assert_norm(pow2 61 - 1 == 2305843009213693951)
let pow2_125_1 : _:unit{pow2 125 - 1 == 42535295865117307932921825928971026431} = assert_norm(pow2 125 - 1 == 42535295865117307932921825928971026431)
let labeled_extract_max_length_ikm (a:hash_algorithm) (size_suite_id:size_nat) (size_local_label:size_nat) =
match a with
| Hash.SHA3_256 -> None
| _ -> Some (Some?.v(Hash.max_input_length a) - size_label_version - size_suite_id - size_local_label - Spec.Hash.Definitions.block_length a)
| false | true |
Spec.Agile.HPKE.fsti
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val labeled_expand_max_length_info : a: Spec.Agile.HPKE.hash_algorithm ->
size_suite_id: Lib.IntTypes.size_nat ->
size_local_label: Lib.IntTypes.size_nat
-> FStar.Pervasives.Native.option Prims.int
|
[] |
Spec.Agile.HPKE.labeled_expand_max_length_info
|
{
"file_name": "specs/Spec.Agile.HPKE.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
a: Spec.Agile.HPKE.hash_algorithm ->
size_suite_id: Lib.IntTypes.size_nat ->
size_local_label: Lib.IntTypes.size_nat
-> FStar.Pervasives.Native.option Prims.int
|
{
"end_col": 190,
"end_line": 333,
"start_col": 2,
"start_line": 331
}
|
|
Prims.Tot
|
val size_label_sk:size_nat
|
[
{
"abbrev": true,
"full_module": "Spec.Agile.HKDF",
"short_module": "HKDF"
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"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.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let size_label_sk: size_nat = 2
|
val size_label_sk:size_nat
let size_label_sk:size_nat =
| false | null | false |
2
|
{
"checked_file": "Spec.Agile.HPKE.fsti.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HKDF.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"Spec.Agile.DH.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Agile.HPKE.fsti"
}
|
[
"total"
] |
[] |
[] |
module Spec.Agile.HPKE
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module DH = Spec.Agile.DH
module AEAD = Spec.Agile.AEAD
module Hash = Spec.Agile.Hash
module HKDF = Spec.Agile.HKDF
#set-options "--z3rlimit 20 --fuel 0 --ifuel 1"
type mode =
| Base
| PSK
| Auth
| AuthPSK
let is_valid_kem = function
| DH.DH_Curve25519, Hash.SHA2_256
| DH.DH_P256, Hash.SHA2_256 -> true
| _,_ -> false
noeq type aead =
| Seal: alg:AEAD.alg -> aead
| ExportOnly
let is_valid_aead = function
| Seal AEAD.AES128_GCM
| Seal AEAD.AES256_GCM
| Seal AEAD.CHACHA20_POLY1305
| ExportOnly -> true
| _ -> false
let is_valid_hash = function
| Hash.SHA2_256
| Hash.SHA2_384
| Hash.SHA2_512 -> true
| _ -> false
let hash_algorithm = a:Hash.hash_alg{is_valid_hash a}
let is_valid_ciphersuite (cs:DH.algorithm & hash_algorithm & aead & Hash.hash_alg) : bool =
let kem_dh, kem_hash, aead, hash = cs in
(is_valid_kem (kem_dh, kem_hash)) && (is_valid_aead aead) && (is_valid_hash hash)
let ciphersuite = cs:(DH.algorithm & hash_algorithm & aead & Hash.hash_alg){is_valid_ciphersuite cs}
inline_for_extraction
let kem_dh_of_cs (cs:ciphersuite) : DH.algorithm =
let (c,_,_,_) = cs in c
inline_for_extraction
let kem_hash_of_cs (cs:ciphersuite) : hash_algorithm =
let (_,h,_,_) = cs in h
inline_for_extraction
let aead_of_cs (cs:ciphersuite) : aead =
let (_,_,a,_) = cs in a
inline_for_extraction
let hash_of_cs (cs:ciphersuite) : hash_algorithm =
let (_,_,_,h) = cs in h
let is_valid_not_export_only_ciphersuite (cs:ciphersuite) : bool =
match aead_of_cs cs with
| ExportOnly -> false
| Seal _ -> true
let ciphersuite_not_export_only = cs:ciphersuite{is_valid_not_export_only_ciphersuite cs}
inline_for_extraction
let aead_alg_of (cs:ciphersuite_not_export_only) = match aead_of_cs cs with
| Seal alg -> alg
/// Constants for HPKE labels
///
/// The code for the following constants was generated
/// with the script make_hpke_constants.py. Ultimately,
/// this should be rewritten in Meta-F*. The idea is to
/// write a tactic `mk_label` that inspects a string
/// character by character, and generates the proper
/// definition. It could be used as follows:
/// %splice [label_version] (mk_label "HPKE-v1")
/// Inspiration can be taken from Test.Lowstarize.fst.
// generated: "HPKE-v1"
inline_for_extraction
let size_label_version: size_nat = 7
let label_version_list : l:list uint8{List.Tot.length l == size_label_version} =
[@inline_let]
let l = [u8 0x48; u8 0x50; u8 0x4b; u8 0x45; u8 0x2d; u8 0x76; u8 0x31] in
assert_norm(List.Tot.length l == size_label_version);
l
let label_version : lbytes size_label_version = createL label_version_list
// generated: "eae_prk"
inline_for_extraction
let size_label_eae_prk: size_nat = 7
let label_eae_prk_list : l:list uint8{List.Tot.length l == size_label_eae_prk} =
[@inline_let]
let l = [u8 0x65; u8 0x61; u8 0x65; u8 0x5f; u8 0x70; u8 0x72; u8 0x6b] in
assert_norm(List.Tot.length l == size_label_eae_prk);
l
let label_eae_prk : lbytes size_label_eae_prk = createL label_eae_prk_list
// generated: "KEM"
inline_for_extraction
let size_label_KEM: size_nat = 3
let label_KEM_list : l:list uint8{List.Tot.length l == size_label_KEM} =
[@inline_let]
let l = [u8 0x4b; u8 0x45; u8 0x4d] in
assert_norm(List.Tot.length l == size_label_KEM);
l
let label_KEM : lbytes size_label_KEM = createL label_KEM_list
// generated: "HPKE"
inline_for_extraction
let size_label_HPKE: size_nat = 4
let label_HPKE_list : l:list uint8{List.Tot.length l == size_label_HPKE} =
[@inline_let]
let l = [u8 0x48; u8 0x50; u8 0x4b; u8 0x45] in
assert_norm(List.Tot.length l == size_label_HPKE);
l
let label_HPKE : lbytes size_label_HPKE = createL label_HPKE_list
// generated: "shared_secret"
inline_for_extraction
let size_label_shared_secret: size_nat = 13
let label_shared_secret_list : l:list uint8{List.Tot.length l == size_label_shared_secret} =
[@inline_let]
let l = [u8 0x73; u8 0x68; u8 0x61; u8 0x72; u8 0x65; u8 0x64; u8 0x5f; u8 0x73; u8 0x65; u8 0x63; u8 0x72; u8 0x65; u8 0x74] in
assert_norm(List.Tot.length l == size_label_shared_secret);
l
let label_shared_secret : lbytes size_label_shared_secret = createL label_shared_secret_list
// generated: "psk_id_hash"
inline_for_extraction
let size_label_psk_id_hash: size_nat = 11
let label_psk_id_hash_list : l:list uint8{List.Tot.length l == size_label_psk_id_hash} =
[@inline_let]
let l = [u8 0x70; u8 0x73; u8 0x6b; u8 0x5f; u8 0x69; u8 0x64; u8 0x5f; u8 0x68; u8 0x61; u8 0x73; u8 0x68] in
assert_norm(List.Tot.length l == size_label_psk_id_hash);
l
let label_psk_id_hash : lbytes size_label_psk_id_hash = createL label_psk_id_hash_list
// generated: "info_hash"
inline_for_extraction
let size_label_info_hash: size_nat = 9
let label_info_hash_list : l:list uint8{List.Tot.length l == size_label_info_hash} =
[@inline_let]
let l = [u8 0x69; u8 0x6e; u8 0x66; u8 0x6f; u8 0x5f; u8 0x68; u8 0x61; u8 0x73; u8 0x68] in
assert_norm(List.Tot.length l == size_label_info_hash);
l
let label_info_hash : lbytes size_label_info_hash = createL label_info_hash_list
// generated: "secret"
inline_for_extraction
let size_label_secret: size_nat = 6
let label_secret_list : l:list uint8{List.Tot.length l == size_label_secret} =
[@inline_let]
let l = [u8 0x73; u8 0x65; u8 0x63; u8 0x72; u8 0x65; u8 0x74] in
assert_norm(List.Tot.length l == size_label_secret);
l
let label_secret : lbytes size_label_secret = createL label_secret_list
// generated: "key"
inline_for_extraction
let size_label_key: size_nat = 3
let label_key_list : l:list uint8{List.Tot.length l == size_label_key} =
[@inline_let]
let l = [u8 0x6b; u8 0x65; u8 0x79] in
assert_norm(List.Tot.length l == size_label_key);
l
let label_key : lbytes size_label_key = createL label_key_list
// generated: "base_nonce"
inline_for_extraction
let size_label_base_nonce: size_nat = 10
let label_base_nonce_list : l:list uint8{List.Tot.length l == size_label_base_nonce} =
[@inline_let]
let l = [u8 0x62; u8 0x61; u8 0x73; u8 0x65; u8 0x5f; u8 0x6e; u8 0x6f; u8 0x6e; u8 0x63; u8 0x65] in
assert_norm(List.Tot.length l == size_label_base_nonce);
l
let label_base_nonce : lbytes size_label_base_nonce = createL label_base_nonce_list
// generated: "exp"
inline_for_extraction
let size_label_exp: size_nat = 3
let label_exp_list : l:list uint8{List.Tot.length l == size_label_exp} =
[@inline_let]
let l = [u8 0x65; u8 0x78; u8 0x70] in
assert_norm(List.Tot.length l == size_label_exp);
l
let label_exp : lbytes size_label_exp = createL label_exp_list
// generated: "sec"
inline_for_extraction
let size_label_sec: size_nat = 3
let label_sec_list : l:list uint8{List.Tot.length l == size_label_sec} =
[@inline_let]
let l = [u8 0x73; u8 0x65; u8 0x63] in
assert_norm(List.Tot.length l == size_label_sec);
l
let label_sec : lbytes size_label_sec = createL label_sec_list
// generated: "dkp_prk"
inline_for_extraction
let size_label_dkp_prk: size_nat = 7
let label_dkp_prk_list : l:list uint8{List.Tot.length l == size_label_dkp_prk} =
[@inline_let]
let l = [u8 0x64; u8 0x6b; u8 0x70; u8 0x5f; u8 0x70; u8 0x72; u8 0x6b] in
assert_norm(List.Tot.length l == size_label_dkp_prk);
l
let label_dkp_prk : lbytes size_label_dkp_prk = createL label_dkp_prk_list
// generated: "candidate"
inline_for_extraction
let size_label_candidate: size_nat = 9
let label_candidate_list : l:list uint8{List.Tot.length l == size_label_candidate} =
[@inline_let]
let l = [u8 0x63; u8 0x61; u8 0x6e; u8 0x64; u8 0x69; u8 0x64; u8 0x61; u8 0x74; u8 0x65] in
assert_norm(List.Tot.length l == size_label_candidate);
l
let label_candidate : lbytes size_label_candidate = createL label_candidate_list
// generated: "sk"
| false | false |
Spec.Agile.HPKE.fsti
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val size_label_sk:size_nat
|
[] |
Spec.Agile.HPKE.size_label_sk
|
{
"file_name": "specs/Spec.Agile.HPKE.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
n: Prims.nat{n <= Prims.pow2 32 - 1}
|
{
"end_col": 31,
"end_line": 247,
"start_col": 30,
"start_line": 247
}
|
Prims.Tot
|
val label_candidate_list:l: list uint8 {List.Tot.length l == size_label_candidate}
|
[
{
"abbrev": true,
"full_module": "Spec.Agile.HKDF",
"short_module": "HKDF"
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"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.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let label_candidate_list : l:list uint8{List.Tot.length l == size_label_candidate} =
[@inline_let]
let l = [u8 0x63; u8 0x61; u8 0x6e; u8 0x64; u8 0x69; u8 0x64; u8 0x61; u8 0x74; u8 0x65] in
assert_norm(List.Tot.length l == size_label_candidate);
l
|
val label_candidate_list:l: list uint8 {List.Tot.length l == size_label_candidate}
let label_candidate_list:l: list uint8 {List.Tot.length l == size_label_candidate} =
| false | null | false |
[@@ inline_let ]let l =
[u8 0x63; u8 0x61; u8 0x6e; u8 0x64; u8 0x69; u8 0x64; u8 0x61; u8 0x74; u8 0x65]
in
assert_norm (List.Tot.length l == size_label_candidate);
l
|
{
"checked_file": "Spec.Agile.HPKE.fsti.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HKDF.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"Spec.Agile.DH.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Agile.HPKE.fsti"
}
|
[
"total"
] |
[
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.nat",
"FStar.List.Tot.Base.length",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.Agile.HPKE.size_label_candidate",
"Prims.list",
"Prims.Cons",
"Lib.IntTypes.u8",
"Prims.Nil"
] |
[] |
module Spec.Agile.HPKE
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module DH = Spec.Agile.DH
module AEAD = Spec.Agile.AEAD
module Hash = Spec.Agile.Hash
module HKDF = Spec.Agile.HKDF
#set-options "--z3rlimit 20 --fuel 0 --ifuel 1"
type mode =
| Base
| PSK
| Auth
| AuthPSK
let is_valid_kem = function
| DH.DH_Curve25519, Hash.SHA2_256
| DH.DH_P256, Hash.SHA2_256 -> true
| _,_ -> false
noeq type aead =
| Seal: alg:AEAD.alg -> aead
| ExportOnly
let is_valid_aead = function
| Seal AEAD.AES128_GCM
| Seal AEAD.AES256_GCM
| Seal AEAD.CHACHA20_POLY1305
| ExportOnly -> true
| _ -> false
let is_valid_hash = function
| Hash.SHA2_256
| Hash.SHA2_384
| Hash.SHA2_512 -> true
| _ -> false
let hash_algorithm = a:Hash.hash_alg{is_valid_hash a}
let is_valid_ciphersuite (cs:DH.algorithm & hash_algorithm & aead & Hash.hash_alg) : bool =
let kem_dh, kem_hash, aead, hash = cs in
(is_valid_kem (kem_dh, kem_hash)) && (is_valid_aead aead) && (is_valid_hash hash)
let ciphersuite = cs:(DH.algorithm & hash_algorithm & aead & Hash.hash_alg){is_valid_ciphersuite cs}
inline_for_extraction
let kem_dh_of_cs (cs:ciphersuite) : DH.algorithm =
let (c,_,_,_) = cs in c
inline_for_extraction
let kem_hash_of_cs (cs:ciphersuite) : hash_algorithm =
let (_,h,_,_) = cs in h
inline_for_extraction
let aead_of_cs (cs:ciphersuite) : aead =
let (_,_,a,_) = cs in a
inline_for_extraction
let hash_of_cs (cs:ciphersuite) : hash_algorithm =
let (_,_,_,h) = cs in h
let is_valid_not_export_only_ciphersuite (cs:ciphersuite) : bool =
match aead_of_cs cs with
| ExportOnly -> false
| Seal _ -> true
let ciphersuite_not_export_only = cs:ciphersuite{is_valid_not_export_only_ciphersuite cs}
inline_for_extraction
let aead_alg_of (cs:ciphersuite_not_export_only) = match aead_of_cs cs with
| Seal alg -> alg
/// Constants for HPKE labels
///
/// The code for the following constants was generated
/// with the script make_hpke_constants.py. Ultimately,
/// this should be rewritten in Meta-F*. The idea is to
/// write a tactic `mk_label` that inspects a string
/// character by character, and generates the proper
/// definition. It could be used as follows:
/// %splice [label_version] (mk_label "HPKE-v1")
/// Inspiration can be taken from Test.Lowstarize.fst.
// generated: "HPKE-v1"
inline_for_extraction
let size_label_version: size_nat = 7
let label_version_list : l:list uint8{List.Tot.length l == size_label_version} =
[@inline_let]
let l = [u8 0x48; u8 0x50; u8 0x4b; u8 0x45; u8 0x2d; u8 0x76; u8 0x31] in
assert_norm(List.Tot.length l == size_label_version);
l
let label_version : lbytes size_label_version = createL label_version_list
// generated: "eae_prk"
inline_for_extraction
let size_label_eae_prk: size_nat = 7
let label_eae_prk_list : l:list uint8{List.Tot.length l == size_label_eae_prk} =
[@inline_let]
let l = [u8 0x65; u8 0x61; u8 0x65; u8 0x5f; u8 0x70; u8 0x72; u8 0x6b] in
assert_norm(List.Tot.length l == size_label_eae_prk);
l
let label_eae_prk : lbytes size_label_eae_prk = createL label_eae_prk_list
// generated: "KEM"
inline_for_extraction
let size_label_KEM: size_nat = 3
let label_KEM_list : l:list uint8{List.Tot.length l == size_label_KEM} =
[@inline_let]
let l = [u8 0x4b; u8 0x45; u8 0x4d] in
assert_norm(List.Tot.length l == size_label_KEM);
l
let label_KEM : lbytes size_label_KEM = createL label_KEM_list
// generated: "HPKE"
inline_for_extraction
let size_label_HPKE: size_nat = 4
let label_HPKE_list : l:list uint8{List.Tot.length l == size_label_HPKE} =
[@inline_let]
let l = [u8 0x48; u8 0x50; u8 0x4b; u8 0x45] in
assert_norm(List.Tot.length l == size_label_HPKE);
l
let label_HPKE : lbytes size_label_HPKE = createL label_HPKE_list
// generated: "shared_secret"
inline_for_extraction
let size_label_shared_secret: size_nat = 13
let label_shared_secret_list : l:list uint8{List.Tot.length l == size_label_shared_secret} =
[@inline_let]
let l = [u8 0x73; u8 0x68; u8 0x61; u8 0x72; u8 0x65; u8 0x64; u8 0x5f; u8 0x73; u8 0x65; u8 0x63; u8 0x72; u8 0x65; u8 0x74] in
assert_norm(List.Tot.length l == size_label_shared_secret);
l
let label_shared_secret : lbytes size_label_shared_secret = createL label_shared_secret_list
// generated: "psk_id_hash"
inline_for_extraction
let size_label_psk_id_hash: size_nat = 11
let label_psk_id_hash_list : l:list uint8{List.Tot.length l == size_label_psk_id_hash} =
[@inline_let]
let l = [u8 0x70; u8 0x73; u8 0x6b; u8 0x5f; u8 0x69; u8 0x64; u8 0x5f; u8 0x68; u8 0x61; u8 0x73; u8 0x68] in
assert_norm(List.Tot.length l == size_label_psk_id_hash);
l
let label_psk_id_hash : lbytes size_label_psk_id_hash = createL label_psk_id_hash_list
// generated: "info_hash"
inline_for_extraction
let size_label_info_hash: size_nat = 9
let label_info_hash_list : l:list uint8{List.Tot.length l == size_label_info_hash} =
[@inline_let]
let l = [u8 0x69; u8 0x6e; u8 0x66; u8 0x6f; u8 0x5f; u8 0x68; u8 0x61; u8 0x73; u8 0x68] in
assert_norm(List.Tot.length l == size_label_info_hash);
l
let label_info_hash : lbytes size_label_info_hash = createL label_info_hash_list
// generated: "secret"
inline_for_extraction
let size_label_secret: size_nat = 6
let label_secret_list : l:list uint8{List.Tot.length l == size_label_secret} =
[@inline_let]
let l = [u8 0x73; u8 0x65; u8 0x63; u8 0x72; u8 0x65; u8 0x74] in
assert_norm(List.Tot.length l == size_label_secret);
l
let label_secret : lbytes size_label_secret = createL label_secret_list
// generated: "key"
inline_for_extraction
let size_label_key: size_nat = 3
let label_key_list : l:list uint8{List.Tot.length l == size_label_key} =
[@inline_let]
let l = [u8 0x6b; u8 0x65; u8 0x79] in
assert_norm(List.Tot.length l == size_label_key);
l
let label_key : lbytes size_label_key = createL label_key_list
// generated: "base_nonce"
inline_for_extraction
let size_label_base_nonce: size_nat = 10
let label_base_nonce_list : l:list uint8{List.Tot.length l == size_label_base_nonce} =
[@inline_let]
let l = [u8 0x62; u8 0x61; u8 0x73; u8 0x65; u8 0x5f; u8 0x6e; u8 0x6f; u8 0x6e; u8 0x63; u8 0x65] in
assert_norm(List.Tot.length l == size_label_base_nonce);
l
let label_base_nonce : lbytes size_label_base_nonce = createL label_base_nonce_list
// generated: "exp"
inline_for_extraction
let size_label_exp: size_nat = 3
let label_exp_list : l:list uint8{List.Tot.length l == size_label_exp} =
[@inline_let]
let l = [u8 0x65; u8 0x78; u8 0x70] in
assert_norm(List.Tot.length l == size_label_exp);
l
let label_exp : lbytes size_label_exp = createL label_exp_list
// generated: "sec"
inline_for_extraction
let size_label_sec: size_nat = 3
let label_sec_list : l:list uint8{List.Tot.length l == size_label_sec} =
[@inline_let]
let l = [u8 0x73; u8 0x65; u8 0x63] in
assert_norm(List.Tot.length l == size_label_sec);
l
let label_sec : lbytes size_label_sec = createL label_sec_list
// generated: "dkp_prk"
inline_for_extraction
let size_label_dkp_prk: size_nat = 7
let label_dkp_prk_list : l:list uint8{List.Tot.length l == size_label_dkp_prk} =
[@inline_let]
let l = [u8 0x64; u8 0x6b; u8 0x70; u8 0x5f; u8 0x70; u8 0x72; u8 0x6b] in
assert_norm(List.Tot.length l == size_label_dkp_prk);
l
let label_dkp_prk : lbytes size_label_dkp_prk = createL label_dkp_prk_list
// generated: "candidate"
inline_for_extraction
let size_label_candidate: size_nat = 9
| false | false |
Spec.Agile.HPKE.fsti
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val label_candidate_list:l: list uint8 {List.Tot.length l == size_label_candidate}
|
[] |
Spec.Agile.HPKE.label_candidate_list
|
{
"file_name": "specs/Spec.Agile.HPKE.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
l:
Prims.list (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.SEC)
{FStar.List.Tot.Base.length l == Spec.Agile.HPKE.size_label_candidate}
|
{
"end_col": 3,
"end_line": 241,
"start_col": 2,
"start_line": 238
}
|
Prims.Tot
|
val size_mode_identifier:size_nat
|
[
{
"abbrev": true,
"full_module": "Spec.Agile.HKDF",
"short_module": "HKDF"
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"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.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let size_mode_identifier: size_nat = 1
|
val size_mode_identifier:size_nat
let size_mode_identifier:size_nat =
| false | null | false |
1
|
{
"checked_file": "Spec.Agile.HPKE.fsti.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HKDF.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"Spec.Agile.DH.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Agile.HPKE.fsti"
}
|
[
"total"
] |
[] |
[] |
module Spec.Agile.HPKE
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module DH = Spec.Agile.DH
module AEAD = Spec.Agile.AEAD
module Hash = Spec.Agile.Hash
module HKDF = Spec.Agile.HKDF
#set-options "--z3rlimit 20 --fuel 0 --ifuel 1"
type mode =
| Base
| PSK
| Auth
| AuthPSK
let is_valid_kem = function
| DH.DH_Curve25519, Hash.SHA2_256
| DH.DH_P256, Hash.SHA2_256 -> true
| _,_ -> false
noeq type aead =
| Seal: alg:AEAD.alg -> aead
| ExportOnly
let is_valid_aead = function
| Seal AEAD.AES128_GCM
| Seal AEAD.AES256_GCM
| Seal AEAD.CHACHA20_POLY1305
| ExportOnly -> true
| _ -> false
let is_valid_hash = function
| Hash.SHA2_256
| Hash.SHA2_384
| Hash.SHA2_512 -> true
| _ -> false
let hash_algorithm = a:Hash.hash_alg{is_valid_hash a}
let is_valid_ciphersuite (cs:DH.algorithm & hash_algorithm & aead & Hash.hash_alg) : bool =
let kem_dh, kem_hash, aead, hash = cs in
(is_valid_kem (kem_dh, kem_hash)) && (is_valid_aead aead) && (is_valid_hash hash)
let ciphersuite = cs:(DH.algorithm & hash_algorithm & aead & Hash.hash_alg){is_valid_ciphersuite cs}
inline_for_extraction
let kem_dh_of_cs (cs:ciphersuite) : DH.algorithm =
let (c,_,_,_) = cs in c
inline_for_extraction
let kem_hash_of_cs (cs:ciphersuite) : hash_algorithm =
let (_,h,_,_) = cs in h
inline_for_extraction
let aead_of_cs (cs:ciphersuite) : aead =
let (_,_,a,_) = cs in a
inline_for_extraction
let hash_of_cs (cs:ciphersuite) : hash_algorithm =
let (_,_,_,h) = cs in h
let is_valid_not_export_only_ciphersuite (cs:ciphersuite) : bool =
match aead_of_cs cs with
| ExportOnly -> false
| Seal _ -> true
let ciphersuite_not_export_only = cs:ciphersuite{is_valid_not_export_only_ciphersuite cs}
inline_for_extraction
let aead_alg_of (cs:ciphersuite_not_export_only) = match aead_of_cs cs with
| Seal alg -> alg
/// Constants for HPKE labels
///
/// The code for the following constants was generated
/// with the script make_hpke_constants.py. Ultimately,
/// this should be rewritten in Meta-F*. The idea is to
/// write a tactic `mk_label` that inspects a string
/// character by character, and generates the proper
/// definition. It could be used as follows:
/// %splice [label_version] (mk_label "HPKE-v1")
/// Inspiration can be taken from Test.Lowstarize.fst.
// generated: "HPKE-v1"
inline_for_extraction
let size_label_version: size_nat = 7
let label_version_list : l:list uint8{List.Tot.length l == size_label_version} =
[@inline_let]
let l = [u8 0x48; u8 0x50; u8 0x4b; u8 0x45; u8 0x2d; u8 0x76; u8 0x31] in
assert_norm(List.Tot.length l == size_label_version);
l
let label_version : lbytes size_label_version = createL label_version_list
// generated: "eae_prk"
inline_for_extraction
let size_label_eae_prk: size_nat = 7
let label_eae_prk_list : l:list uint8{List.Tot.length l == size_label_eae_prk} =
[@inline_let]
let l = [u8 0x65; u8 0x61; u8 0x65; u8 0x5f; u8 0x70; u8 0x72; u8 0x6b] in
assert_norm(List.Tot.length l == size_label_eae_prk);
l
let label_eae_prk : lbytes size_label_eae_prk = createL label_eae_prk_list
// generated: "KEM"
inline_for_extraction
let size_label_KEM: size_nat = 3
let label_KEM_list : l:list uint8{List.Tot.length l == size_label_KEM} =
[@inline_let]
let l = [u8 0x4b; u8 0x45; u8 0x4d] in
assert_norm(List.Tot.length l == size_label_KEM);
l
let label_KEM : lbytes size_label_KEM = createL label_KEM_list
// generated: "HPKE"
inline_for_extraction
let size_label_HPKE: size_nat = 4
let label_HPKE_list : l:list uint8{List.Tot.length l == size_label_HPKE} =
[@inline_let]
let l = [u8 0x48; u8 0x50; u8 0x4b; u8 0x45] in
assert_norm(List.Tot.length l == size_label_HPKE);
l
let label_HPKE : lbytes size_label_HPKE = createL label_HPKE_list
// generated: "shared_secret"
inline_for_extraction
let size_label_shared_secret: size_nat = 13
let label_shared_secret_list : l:list uint8{List.Tot.length l == size_label_shared_secret} =
[@inline_let]
let l = [u8 0x73; u8 0x68; u8 0x61; u8 0x72; u8 0x65; u8 0x64; u8 0x5f; u8 0x73; u8 0x65; u8 0x63; u8 0x72; u8 0x65; u8 0x74] in
assert_norm(List.Tot.length l == size_label_shared_secret);
l
let label_shared_secret : lbytes size_label_shared_secret = createL label_shared_secret_list
// generated: "psk_id_hash"
inline_for_extraction
let size_label_psk_id_hash: size_nat = 11
let label_psk_id_hash_list : l:list uint8{List.Tot.length l == size_label_psk_id_hash} =
[@inline_let]
let l = [u8 0x70; u8 0x73; u8 0x6b; u8 0x5f; u8 0x69; u8 0x64; u8 0x5f; u8 0x68; u8 0x61; u8 0x73; u8 0x68] in
assert_norm(List.Tot.length l == size_label_psk_id_hash);
l
let label_psk_id_hash : lbytes size_label_psk_id_hash = createL label_psk_id_hash_list
// generated: "info_hash"
inline_for_extraction
let size_label_info_hash: size_nat = 9
let label_info_hash_list : l:list uint8{List.Tot.length l == size_label_info_hash} =
[@inline_let]
let l = [u8 0x69; u8 0x6e; u8 0x66; u8 0x6f; u8 0x5f; u8 0x68; u8 0x61; u8 0x73; u8 0x68] in
assert_norm(List.Tot.length l == size_label_info_hash);
l
let label_info_hash : lbytes size_label_info_hash = createL label_info_hash_list
// generated: "secret"
inline_for_extraction
let size_label_secret: size_nat = 6
let label_secret_list : l:list uint8{List.Tot.length l == size_label_secret} =
[@inline_let]
let l = [u8 0x73; u8 0x65; u8 0x63; u8 0x72; u8 0x65; u8 0x74] in
assert_norm(List.Tot.length l == size_label_secret);
l
let label_secret : lbytes size_label_secret = createL label_secret_list
// generated: "key"
inline_for_extraction
let size_label_key: size_nat = 3
let label_key_list : l:list uint8{List.Tot.length l == size_label_key} =
[@inline_let]
let l = [u8 0x6b; u8 0x65; u8 0x79] in
assert_norm(List.Tot.length l == size_label_key);
l
let label_key : lbytes size_label_key = createL label_key_list
// generated: "base_nonce"
inline_for_extraction
let size_label_base_nonce: size_nat = 10
let label_base_nonce_list : l:list uint8{List.Tot.length l == size_label_base_nonce} =
[@inline_let]
let l = [u8 0x62; u8 0x61; u8 0x73; u8 0x65; u8 0x5f; u8 0x6e; u8 0x6f; u8 0x6e; u8 0x63; u8 0x65] in
assert_norm(List.Tot.length l == size_label_base_nonce);
l
let label_base_nonce : lbytes size_label_base_nonce = createL label_base_nonce_list
// generated: "exp"
inline_for_extraction
let size_label_exp: size_nat = 3
let label_exp_list : l:list uint8{List.Tot.length l == size_label_exp} =
[@inline_let]
let l = [u8 0x65; u8 0x78; u8 0x70] in
assert_norm(List.Tot.length l == size_label_exp);
l
let label_exp : lbytes size_label_exp = createL label_exp_list
// generated: "sec"
inline_for_extraction
let size_label_sec: size_nat = 3
let label_sec_list : l:list uint8{List.Tot.length l == size_label_sec} =
[@inline_let]
let l = [u8 0x73; u8 0x65; u8 0x63] in
assert_norm(List.Tot.length l == size_label_sec);
l
let label_sec : lbytes size_label_sec = createL label_sec_list
// generated: "dkp_prk"
inline_for_extraction
let size_label_dkp_prk: size_nat = 7
let label_dkp_prk_list : l:list uint8{List.Tot.length l == size_label_dkp_prk} =
[@inline_let]
let l = [u8 0x64; u8 0x6b; u8 0x70; u8 0x5f; u8 0x70; u8 0x72; u8 0x6b] in
assert_norm(List.Tot.length l == size_label_dkp_prk);
l
let label_dkp_prk : lbytes size_label_dkp_prk = createL label_dkp_prk_list
// generated: "candidate"
inline_for_extraction
let size_label_candidate: size_nat = 9
let label_candidate_list : l:list uint8{List.Tot.length l == size_label_candidate} =
[@inline_let]
let l = [u8 0x63; u8 0x61; u8 0x6e; u8 0x64; u8 0x69; u8 0x64; u8 0x61; u8 0x74; u8 0x65] in
assert_norm(List.Tot.length l == size_label_candidate);
l
let label_candidate : lbytes size_label_candidate = createL label_candidate_list
// generated: "sk"
inline_for_extraction
let size_label_sk: size_nat = 2
let label_sk_list : l:list uint8{List.Tot.length l == size_label_sk} =
[@inline_let]
let l = [u8 0x73; u8 0x6b] in
assert_norm(List.Tot.length l == size_label_sk);
l
let label_sk : lbytes size_label_sk = createL label_sk_list
///
/// Constants sizes
///
inline_for_extraction
let size_aead_nonce (cs:ciphersuite): size_nat =
assert_norm (8 * 12 <= pow2 64 - 1);
match aead_of_cs cs with
| ExportOnly -> 0
| Seal _ -> 12
inline_for_extraction
let size_aead_key (cs:ciphersuite): size_nat =
match aead_of_cs cs with
| ExportOnly -> 0
| Seal _ -> AEAD.key_length (aead_alg_of cs)
inline_for_extraction
let size_aead_tag (cs:ciphersuite): size_nat =
match aead_of_cs cs with
| ExportOnly -> 0
| Seal _ -> AEAD.tag_length (aead_alg_of cs)
inline_for_extraction
let size_dh_key (cs:ciphersuite): size_nat = DH.size_key (kem_dh_of_cs cs)
inline_for_extraction
let size_dh_public (cs:ciphersuite): size_nat = match kem_dh_of_cs cs with
| DH.DH_Curve25519 -> DH.size_public DH.DH_Curve25519
| DH.DH_P256 -> DH.size_public DH.DH_P256 + 1 // Need the additional byte for representation
inline_for_extraction
let size_dh_serialized (cs:ciphersuite): size_nat = match kem_dh_of_cs cs with
| DH.DH_Curve25519 -> DH.size_public DH.DH_Curve25519
| DH.DH_P256 -> DH.size_public DH.DH_P256
inline_for_extraction
let size_kem_kdf (cs:ciphersuite): size_nat = Hash.hash_length (kem_hash_of_cs cs)
inline_for_extraction
let size_kem_key (cs:ciphersuite): size_nat = Hash.hash_length (kem_hash_of_cs cs)
inline_for_extraction
let size_kdf (cs:ciphersuite): size_nat = Hash.hash_length (hash_of_cs cs)
let max_seq (cs:ciphersuite): nat =
match aead_of_cs cs with
| ExportOnly -> 0
| Seal _ -> pow2 (8*(size_aead_nonce cs)) - 1
inline_for_extraction
let size_suite_id_kem: size_nat = size_label_KEM + 2
inline_for_extraction
let size_suite_id_hpke: size_nat = size_label_HPKE + 6
| false | false |
Spec.Agile.HPKE.fsti
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val size_mode_identifier:size_nat
|
[] |
Spec.Agile.HPKE.size_mode_identifier
|
{
"file_name": "specs/Spec.Agile.HPKE.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
n: Prims.nat{n <= Prims.pow2 32 - 1}
|
{
"end_col": 38,
"end_line": 312,
"start_col": 37,
"start_line": 312
}
|
Prims.Tot
|
val size_aead_tag (cs: ciphersuite) : size_nat
|
[
{
"abbrev": true,
"full_module": "Spec.Agile.HKDF",
"short_module": "HKDF"
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"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.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let size_aead_tag (cs:ciphersuite): size_nat =
match aead_of_cs cs with
| ExportOnly -> 0
| Seal _ -> AEAD.tag_length (aead_alg_of cs)
|
val size_aead_tag (cs: ciphersuite) : size_nat
let size_aead_tag (cs: ciphersuite) : size_nat =
| false | null | false |
match aead_of_cs cs with
| ExportOnly -> 0
| Seal _ -> AEAD.tag_length (aead_alg_of cs)
|
{
"checked_file": "Spec.Agile.HPKE.fsti.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HKDF.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"Spec.Agile.DH.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Agile.HPKE.fsti"
}
|
[
"total"
] |
[
"Spec.Agile.HPKE.ciphersuite",
"Spec.Agile.HPKE.aead_of_cs",
"Spec.Agile.AEAD.alg",
"Spec.Agile.AEAD.tag_length",
"Spec.Agile.HPKE.aead_alg_of",
"Lib.IntTypes.size_nat"
] |
[] |
module Spec.Agile.HPKE
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module DH = Spec.Agile.DH
module AEAD = Spec.Agile.AEAD
module Hash = Spec.Agile.Hash
module HKDF = Spec.Agile.HKDF
#set-options "--z3rlimit 20 --fuel 0 --ifuel 1"
type mode =
| Base
| PSK
| Auth
| AuthPSK
let is_valid_kem = function
| DH.DH_Curve25519, Hash.SHA2_256
| DH.DH_P256, Hash.SHA2_256 -> true
| _,_ -> false
noeq type aead =
| Seal: alg:AEAD.alg -> aead
| ExportOnly
let is_valid_aead = function
| Seal AEAD.AES128_GCM
| Seal AEAD.AES256_GCM
| Seal AEAD.CHACHA20_POLY1305
| ExportOnly -> true
| _ -> false
let is_valid_hash = function
| Hash.SHA2_256
| Hash.SHA2_384
| Hash.SHA2_512 -> true
| _ -> false
let hash_algorithm = a:Hash.hash_alg{is_valid_hash a}
let is_valid_ciphersuite (cs:DH.algorithm & hash_algorithm & aead & Hash.hash_alg) : bool =
let kem_dh, kem_hash, aead, hash = cs in
(is_valid_kem (kem_dh, kem_hash)) && (is_valid_aead aead) && (is_valid_hash hash)
let ciphersuite = cs:(DH.algorithm & hash_algorithm & aead & Hash.hash_alg){is_valid_ciphersuite cs}
inline_for_extraction
let kem_dh_of_cs (cs:ciphersuite) : DH.algorithm =
let (c,_,_,_) = cs in c
inline_for_extraction
let kem_hash_of_cs (cs:ciphersuite) : hash_algorithm =
let (_,h,_,_) = cs in h
inline_for_extraction
let aead_of_cs (cs:ciphersuite) : aead =
let (_,_,a,_) = cs in a
inline_for_extraction
let hash_of_cs (cs:ciphersuite) : hash_algorithm =
let (_,_,_,h) = cs in h
let is_valid_not_export_only_ciphersuite (cs:ciphersuite) : bool =
match aead_of_cs cs with
| ExportOnly -> false
| Seal _ -> true
let ciphersuite_not_export_only = cs:ciphersuite{is_valid_not_export_only_ciphersuite cs}
inline_for_extraction
let aead_alg_of (cs:ciphersuite_not_export_only) = match aead_of_cs cs with
| Seal alg -> alg
/// Constants for HPKE labels
///
/// The code for the following constants was generated
/// with the script make_hpke_constants.py. Ultimately,
/// this should be rewritten in Meta-F*. The idea is to
/// write a tactic `mk_label` that inspects a string
/// character by character, and generates the proper
/// definition. It could be used as follows:
/// %splice [label_version] (mk_label "HPKE-v1")
/// Inspiration can be taken from Test.Lowstarize.fst.
// generated: "HPKE-v1"
inline_for_extraction
let size_label_version: size_nat = 7
let label_version_list : l:list uint8{List.Tot.length l == size_label_version} =
[@inline_let]
let l = [u8 0x48; u8 0x50; u8 0x4b; u8 0x45; u8 0x2d; u8 0x76; u8 0x31] in
assert_norm(List.Tot.length l == size_label_version);
l
let label_version : lbytes size_label_version = createL label_version_list
// generated: "eae_prk"
inline_for_extraction
let size_label_eae_prk: size_nat = 7
let label_eae_prk_list : l:list uint8{List.Tot.length l == size_label_eae_prk} =
[@inline_let]
let l = [u8 0x65; u8 0x61; u8 0x65; u8 0x5f; u8 0x70; u8 0x72; u8 0x6b] in
assert_norm(List.Tot.length l == size_label_eae_prk);
l
let label_eae_prk : lbytes size_label_eae_prk = createL label_eae_prk_list
// generated: "KEM"
inline_for_extraction
let size_label_KEM: size_nat = 3
let label_KEM_list : l:list uint8{List.Tot.length l == size_label_KEM} =
[@inline_let]
let l = [u8 0x4b; u8 0x45; u8 0x4d] in
assert_norm(List.Tot.length l == size_label_KEM);
l
let label_KEM : lbytes size_label_KEM = createL label_KEM_list
// generated: "HPKE"
inline_for_extraction
let size_label_HPKE: size_nat = 4
let label_HPKE_list : l:list uint8{List.Tot.length l == size_label_HPKE} =
[@inline_let]
let l = [u8 0x48; u8 0x50; u8 0x4b; u8 0x45] in
assert_norm(List.Tot.length l == size_label_HPKE);
l
let label_HPKE : lbytes size_label_HPKE = createL label_HPKE_list
// generated: "shared_secret"
inline_for_extraction
let size_label_shared_secret: size_nat = 13
let label_shared_secret_list : l:list uint8{List.Tot.length l == size_label_shared_secret} =
[@inline_let]
let l = [u8 0x73; u8 0x68; u8 0x61; u8 0x72; u8 0x65; u8 0x64; u8 0x5f; u8 0x73; u8 0x65; u8 0x63; u8 0x72; u8 0x65; u8 0x74] in
assert_norm(List.Tot.length l == size_label_shared_secret);
l
let label_shared_secret : lbytes size_label_shared_secret = createL label_shared_secret_list
// generated: "psk_id_hash"
inline_for_extraction
let size_label_psk_id_hash: size_nat = 11
let label_psk_id_hash_list : l:list uint8{List.Tot.length l == size_label_psk_id_hash} =
[@inline_let]
let l = [u8 0x70; u8 0x73; u8 0x6b; u8 0x5f; u8 0x69; u8 0x64; u8 0x5f; u8 0x68; u8 0x61; u8 0x73; u8 0x68] in
assert_norm(List.Tot.length l == size_label_psk_id_hash);
l
let label_psk_id_hash : lbytes size_label_psk_id_hash = createL label_psk_id_hash_list
// generated: "info_hash"
inline_for_extraction
let size_label_info_hash: size_nat = 9
let label_info_hash_list : l:list uint8{List.Tot.length l == size_label_info_hash} =
[@inline_let]
let l = [u8 0x69; u8 0x6e; u8 0x66; u8 0x6f; u8 0x5f; u8 0x68; u8 0x61; u8 0x73; u8 0x68] in
assert_norm(List.Tot.length l == size_label_info_hash);
l
let label_info_hash : lbytes size_label_info_hash = createL label_info_hash_list
// generated: "secret"
inline_for_extraction
let size_label_secret: size_nat = 6
let label_secret_list : l:list uint8{List.Tot.length l == size_label_secret} =
[@inline_let]
let l = [u8 0x73; u8 0x65; u8 0x63; u8 0x72; u8 0x65; u8 0x74] in
assert_norm(List.Tot.length l == size_label_secret);
l
let label_secret : lbytes size_label_secret = createL label_secret_list
// generated: "key"
inline_for_extraction
let size_label_key: size_nat = 3
let label_key_list : l:list uint8{List.Tot.length l == size_label_key} =
[@inline_let]
let l = [u8 0x6b; u8 0x65; u8 0x79] in
assert_norm(List.Tot.length l == size_label_key);
l
let label_key : lbytes size_label_key = createL label_key_list
// generated: "base_nonce"
inline_for_extraction
let size_label_base_nonce: size_nat = 10
let label_base_nonce_list : l:list uint8{List.Tot.length l == size_label_base_nonce} =
[@inline_let]
let l = [u8 0x62; u8 0x61; u8 0x73; u8 0x65; u8 0x5f; u8 0x6e; u8 0x6f; u8 0x6e; u8 0x63; u8 0x65] in
assert_norm(List.Tot.length l == size_label_base_nonce);
l
let label_base_nonce : lbytes size_label_base_nonce = createL label_base_nonce_list
// generated: "exp"
inline_for_extraction
let size_label_exp: size_nat = 3
let label_exp_list : l:list uint8{List.Tot.length l == size_label_exp} =
[@inline_let]
let l = [u8 0x65; u8 0x78; u8 0x70] in
assert_norm(List.Tot.length l == size_label_exp);
l
let label_exp : lbytes size_label_exp = createL label_exp_list
// generated: "sec"
inline_for_extraction
let size_label_sec: size_nat = 3
let label_sec_list : l:list uint8{List.Tot.length l == size_label_sec} =
[@inline_let]
let l = [u8 0x73; u8 0x65; u8 0x63] in
assert_norm(List.Tot.length l == size_label_sec);
l
let label_sec : lbytes size_label_sec = createL label_sec_list
// generated: "dkp_prk"
inline_for_extraction
let size_label_dkp_prk: size_nat = 7
let label_dkp_prk_list : l:list uint8{List.Tot.length l == size_label_dkp_prk} =
[@inline_let]
let l = [u8 0x64; u8 0x6b; u8 0x70; u8 0x5f; u8 0x70; u8 0x72; u8 0x6b] in
assert_norm(List.Tot.length l == size_label_dkp_prk);
l
let label_dkp_prk : lbytes size_label_dkp_prk = createL label_dkp_prk_list
// generated: "candidate"
inline_for_extraction
let size_label_candidate: size_nat = 9
let label_candidate_list : l:list uint8{List.Tot.length l == size_label_candidate} =
[@inline_let]
let l = [u8 0x63; u8 0x61; u8 0x6e; u8 0x64; u8 0x69; u8 0x64; u8 0x61; u8 0x74; u8 0x65] in
assert_norm(List.Tot.length l == size_label_candidate);
l
let label_candidate : lbytes size_label_candidate = createL label_candidate_list
// generated: "sk"
inline_for_extraction
let size_label_sk: size_nat = 2
let label_sk_list : l:list uint8{List.Tot.length l == size_label_sk} =
[@inline_let]
let l = [u8 0x73; u8 0x6b] in
assert_norm(List.Tot.length l == size_label_sk);
l
let label_sk : lbytes size_label_sk = createL label_sk_list
///
/// Constants sizes
///
inline_for_extraction
let size_aead_nonce (cs:ciphersuite): size_nat =
assert_norm (8 * 12 <= pow2 64 - 1);
match aead_of_cs cs with
| ExportOnly -> 0
| Seal _ -> 12
inline_for_extraction
let size_aead_key (cs:ciphersuite): size_nat =
match aead_of_cs cs with
| ExportOnly -> 0
| Seal _ -> AEAD.key_length (aead_alg_of cs)
inline_for_extraction
| false | true |
Spec.Agile.HPKE.fsti
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val size_aead_tag (cs: ciphersuite) : size_nat
|
[] |
Spec.Agile.HPKE.size_aead_tag
|
{
"file_name": "specs/Spec.Agile.HPKE.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
cs: Spec.Agile.HPKE.ciphersuite -> Lib.IntTypes.size_nat
|
{
"end_col": 46,
"end_line": 276,
"start_col": 2,
"start_line": 274
}
|
Prims.Tot
|
val size_dh_public (cs: ciphersuite) : size_nat
|
[
{
"abbrev": true,
"full_module": "Spec.Agile.HKDF",
"short_module": "HKDF"
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"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.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let size_dh_public (cs:ciphersuite): size_nat = match kem_dh_of_cs cs with
| DH.DH_Curve25519 -> DH.size_public DH.DH_Curve25519
| DH.DH_P256 -> DH.size_public DH.DH_P256 + 1
|
val size_dh_public (cs: ciphersuite) : size_nat
let size_dh_public (cs: ciphersuite) : size_nat =
| false | null | false |
match kem_dh_of_cs cs with
| DH.DH_Curve25519 -> DH.size_public DH.DH_Curve25519
| DH.DH_P256 -> DH.size_public DH.DH_P256 + 1
|
{
"checked_file": "Spec.Agile.HPKE.fsti.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HKDF.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"Spec.Agile.DH.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Agile.HPKE.fsti"
}
|
[
"total"
] |
[
"Spec.Agile.HPKE.ciphersuite",
"Spec.Agile.HPKE.kem_dh_of_cs",
"Spec.Agile.DH.size_public",
"Spec.Agile.DH.DH_Curve25519",
"Prims.op_Addition",
"Spec.Agile.DH.DH_P256",
"Lib.IntTypes.size_nat"
] |
[] |
module Spec.Agile.HPKE
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module DH = Spec.Agile.DH
module AEAD = Spec.Agile.AEAD
module Hash = Spec.Agile.Hash
module HKDF = Spec.Agile.HKDF
#set-options "--z3rlimit 20 --fuel 0 --ifuel 1"
type mode =
| Base
| PSK
| Auth
| AuthPSK
let is_valid_kem = function
| DH.DH_Curve25519, Hash.SHA2_256
| DH.DH_P256, Hash.SHA2_256 -> true
| _,_ -> false
noeq type aead =
| Seal: alg:AEAD.alg -> aead
| ExportOnly
let is_valid_aead = function
| Seal AEAD.AES128_GCM
| Seal AEAD.AES256_GCM
| Seal AEAD.CHACHA20_POLY1305
| ExportOnly -> true
| _ -> false
let is_valid_hash = function
| Hash.SHA2_256
| Hash.SHA2_384
| Hash.SHA2_512 -> true
| _ -> false
let hash_algorithm = a:Hash.hash_alg{is_valid_hash a}
let is_valid_ciphersuite (cs:DH.algorithm & hash_algorithm & aead & Hash.hash_alg) : bool =
let kem_dh, kem_hash, aead, hash = cs in
(is_valid_kem (kem_dh, kem_hash)) && (is_valid_aead aead) && (is_valid_hash hash)
let ciphersuite = cs:(DH.algorithm & hash_algorithm & aead & Hash.hash_alg){is_valid_ciphersuite cs}
inline_for_extraction
let kem_dh_of_cs (cs:ciphersuite) : DH.algorithm =
let (c,_,_,_) = cs in c
inline_for_extraction
let kem_hash_of_cs (cs:ciphersuite) : hash_algorithm =
let (_,h,_,_) = cs in h
inline_for_extraction
let aead_of_cs (cs:ciphersuite) : aead =
let (_,_,a,_) = cs in a
inline_for_extraction
let hash_of_cs (cs:ciphersuite) : hash_algorithm =
let (_,_,_,h) = cs in h
let is_valid_not_export_only_ciphersuite (cs:ciphersuite) : bool =
match aead_of_cs cs with
| ExportOnly -> false
| Seal _ -> true
let ciphersuite_not_export_only = cs:ciphersuite{is_valid_not_export_only_ciphersuite cs}
inline_for_extraction
let aead_alg_of (cs:ciphersuite_not_export_only) = match aead_of_cs cs with
| Seal alg -> alg
/// Constants for HPKE labels
///
/// The code for the following constants was generated
/// with the script make_hpke_constants.py. Ultimately,
/// this should be rewritten in Meta-F*. The idea is to
/// write a tactic `mk_label` that inspects a string
/// character by character, and generates the proper
/// definition. It could be used as follows:
/// %splice [label_version] (mk_label "HPKE-v1")
/// Inspiration can be taken from Test.Lowstarize.fst.
// generated: "HPKE-v1"
inline_for_extraction
let size_label_version: size_nat = 7
let label_version_list : l:list uint8{List.Tot.length l == size_label_version} =
[@inline_let]
let l = [u8 0x48; u8 0x50; u8 0x4b; u8 0x45; u8 0x2d; u8 0x76; u8 0x31] in
assert_norm(List.Tot.length l == size_label_version);
l
let label_version : lbytes size_label_version = createL label_version_list
// generated: "eae_prk"
inline_for_extraction
let size_label_eae_prk: size_nat = 7
let label_eae_prk_list : l:list uint8{List.Tot.length l == size_label_eae_prk} =
[@inline_let]
let l = [u8 0x65; u8 0x61; u8 0x65; u8 0x5f; u8 0x70; u8 0x72; u8 0x6b] in
assert_norm(List.Tot.length l == size_label_eae_prk);
l
let label_eae_prk : lbytes size_label_eae_prk = createL label_eae_prk_list
// generated: "KEM"
inline_for_extraction
let size_label_KEM: size_nat = 3
let label_KEM_list : l:list uint8{List.Tot.length l == size_label_KEM} =
[@inline_let]
let l = [u8 0x4b; u8 0x45; u8 0x4d] in
assert_norm(List.Tot.length l == size_label_KEM);
l
let label_KEM : lbytes size_label_KEM = createL label_KEM_list
// generated: "HPKE"
inline_for_extraction
let size_label_HPKE: size_nat = 4
let label_HPKE_list : l:list uint8{List.Tot.length l == size_label_HPKE} =
[@inline_let]
let l = [u8 0x48; u8 0x50; u8 0x4b; u8 0x45] in
assert_norm(List.Tot.length l == size_label_HPKE);
l
let label_HPKE : lbytes size_label_HPKE = createL label_HPKE_list
// generated: "shared_secret"
inline_for_extraction
let size_label_shared_secret: size_nat = 13
let label_shared_secret_list : l:list uint8{List.Tot.length l == size_label_shared_secret} =
[@inline_let]
let l = [u8 0x73; u8 0x68; u8 0x61; u8 0x72; u8 0x65; u8 0x64; u8 0x5f; u8 0x73; u8 0x65; u8 0x63; u8 0x72; u8 0x65; u8 0x74] in
assert_norm(List.Tot.length l == size_label_shared_secret);
l
let label_shared_secret : lbytes size_label_shared_secret = createL label_shared_secret_list
// generated: "psk_id_hash"
inline_for_extraction
let size_label_psk_id_hash: size_nat = 11
let label_psk_id_hash_list : l:list uint8{List.Tot.length l == size_label_psk_id_hash} =
[@inline_let]
let l = [u8 0x70; u8 0x73; u8 0x6b; u8 0x5f; u8 0x69; u8 0x64; u8 0x5f; u8 0x68; u8 0x61; u8 0x73; u8 0x68] in
assert_norm(List.Tot.length l == size_label_psk_id_hash);
l
let label_psk_id_hash : lbytes size_label_psk_id_hash = createL label_psk_id_hash_list
// generated: "info_hash"
inline_for_extraction
let size_label_info_hash: size_nat = 9
let label_info_hash_list : l:list uint8{List.Tot.length l == size_label_info_hash} =
[@inline_let]
let l = [u8 0x69; u8 0x6e; u8 0x66; u8 0x6f; u8 0x5f; u8 0x68; u8 0x61; u8 0x73; u8 0x68] in
assert_norm(List.Tot.length l == size_label_info_hash);
l
let label_info_hash : lbytes size_label_info_hash = createL label_info_hash_list
// generated: "secret"
inline_for_extraction
let size_label_secret: size_nat = 6
let label_secret_list : l:list uint8{List.Tot.length l == size_label_secret} =
[@inline_let]
let l = [u8 0x73; u8 0x65; u8 0x63; u8 0x72; u8 0x65; u8 0x74] in
assert_norm(List.Tot.length l == size_label_secret);
l
let label_secret : lbytes size_label_secret = createL label_secret_list
// generated: "key"
inline_for_extraction
let size_label_key: size_nat = 3
let label_key_list : l:list uint8{List.Tot.length l == size_label_key} =
[@inline_let]
let l = [u8 0x6b; u8 0x65; u8 0x79] in
assert_norm(List.Tot.length l == size_label_key);
l
let label_key : lbytes size_label_key = createL label_key_list
// generated: "base_nonce"
inline_for_extraction
let size_label_base_nonce: size_nat = 10
let label_base_nonce_list : l:list uint8{List.Tot.length l == size_label_base_nonce} =
[@inline_let]
let l = [u8 0x62; u8 0x61; u8 0x73; u8 0x65; u8 0x5f; u8 0x6e; u8 0x6f; u8 0x6e; u8 0x63; u8 0x65] in
assert_norm(List.Tot.length l == size_label_base_nonce);
l
let label_base_nonce : lbytes size_label_base_nonce = createL label_base_nonce_list
// generated: "exp"
inline_for_extraction
let size_label_exp: size_nat = 3
let label_exp_list : l:list uint8{List.Tot.length l == size_label_exp} =
[@inline_let]
let l = [u8 0x65; u8 0x78; u8 0x70] in
assert_norm(List.Tot.length l == size_label_exp);
l
let label_exp : lbytes size_label_exp = createL label_exp_list
// generated: "sec"
inline_for_extraction
let size_label_sec: size_nat = 3
let label_sec_list : l:list uint8{List.Tot.length l == size_label_sec} =
[@inline_let]
let l = [u8 0x73; u8 0x65; u8 0x63] in
assert_norm(List.Tot.length l == size_label_sec);
l
let label_sec : lbytes size_label_sec = createL label_sec_list
// generated: "dkp_prk"
inline_for_extraction
let size_label_dkp_prk: size_nat = 7
let label_dkp_prk_list : l:list uint8{List.Tot.length l == size_label_dkp_prk} =
[@inline_let]
let l = [u8 0x64; u8 0x6b; u8 0x70; u8 0x5f; u8 0x70; u8 0x72; u8 0x6b] in
assert_norm(List.Tot.length l == size_label_dkp_prk);
l
let label_dkp_prk : lbytes size_label_dkp_prk = createL label_dkp_prk_list
// generated: "candidate"
inline_for_extraction
let size_label_candidate: size_nat = 9
let label_candidate_list : l:list uint8{List.Tot.length l == size_label_candidate} =
[@inline_let]
let l = [u8 0x63; u8 0x61; u8 0x6e; u8 0x64; u8 0x69; u8 0x64; u8 0x61; u8 0x74; u8 0x65] in
assert_norm(List.Tot.length l == size_label_candidate);
l
let label_candidate : lbytes size_label_candidate = createL label_candidate_list
// generated: "sk"
inline_for_extraction
let size_label_sk: size_nat = 2
let label_sk_list : l:list uint8{List.Tot.length l == size_label_sk} =
[@inline_let]
let l = [u8 0x73; u8 0x6b] in
assert_norm(List.Tot.length l == size_label_sk);
l
let label_sk : lbytes size_label_sk = createL label_sk_list
///
/// Constants sizes
///
inline_for_extraction
let size_aead_nonce (cs:ciphersuite): size_nat =
assert_norm (8 * 12 <= pow2 64 - 1);
match aead_of_cs cs with
| ExportOnly -> 0
| Seal _ -> 12
inline_for_extraction
let size_aead_key (cs:ciphersuite): size_nat =
match aead_of_cs cs with
| ExportOnly -> 0
| Seal _ -> AEAD.key_length (aead_alg_of cs)
inline_for_extraction
let size_aead_tag (cs:ciphersuite): size_nat =
match aead_of_cs cs with
| ExportOnly -> 0
| Seal _ -> AEAD.tag_length (aead_alg_of cs)
inline_for_extraction
let size_dh_key (cs:ciphersuite): size_nat = DH.size_key (kem_dh_of_cs cs)
| false | true |
Spec.Agile.HPKE.fsti
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val size_dh_public (cs: ciphersuite) : size_nat
|
[] |
Spec.Agile.HPKE.size_dh_public
|
{
"file_name": "specs/Spec.Agile.HPKE.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
cs: Spec.Agile.HPKE.ciphersuite -> Lib.IntTypes.size_nat
|
{
"end_col": 47,
"end_line": 284,
"start_col": 48,
"start_line": 282
}
|
Prims.Tot
|
val size_ks_ctx (cs: ciphersuite) : size_nat
|
[
{
"abbrev": true,
"full_module": "Spec.Agile.HKDF",
"short_module": "HKDF"
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"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.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let size_ks_ctx (cs:ciphersuite): size_nat = size_mode_identifier + 2*(size_kdf cs)
|
val size_ks_ctx (cs: ciphersuite) : size_nat
let size_ks_ctx (cs: ciphersuite) : size_nat =
| false | null | false |
size_mode_identifier + 2 * (size_kdf cs)
|
{
"checked_file": "Spec.Agile.HPKE.fsti.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HKDF.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"Spec.Agile.DH.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Agile.HPKE.fsti"
}
|
[
"total"
] |
[
"Spec.Agile.HPKE.ciphersuite",
"Prims.op_Addition",
"Spec.Agile.HPKE.size_mode_identifier",
"FStar.Mul.op_Star",
"Spec.Agile.HPKE.size_kdf",
"Lib.IntTypes.size_nat"
] |
[] |
module Spec.Agile.HPKE
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module DH = Spec.Agile.DH
module AEAD = Spec.Agile.AEAD
module Hash = Spec.Agile.Hash
module HKDF = Spec.Agile.HKDF
#set-options "--z3rlimit 20 --fuel 0 --ifuel 1"
type mode =
| Base
| PSK
| Auth
| AuthPSK
let is_valid_kem = function
| DH.DH_Curve25519, Hash.SHA2_256
| DH.DH_P256, Hash.SHA2_256 -> true
| _,_ -> false
noeq type aead =
| Seal: alg:AEAD.alg -> aead
| ExportOnly
let is_valid_aead = function
| Seal AEAD.AES128_GCM
| Seal AEAD.AES256_GCM
| Seal AEAD.CHACHA20_POLY1305
| ExportOnly -> true
| _ -> false
let is_valid_hash = function
| Hash.SHA2_256
| Hash.SHA2_384
| Hash.SHA2_512 -> true
| _ -> false
let hash_algorithm = a:Hash.hash_alg{is_valid_hash a}
let is_valid_ciphersuite (cs:DH.algorithm & hash_algorithm & aead & Hash.hash_alg) : bool =
let kem_dh, kem_hash, aead, hash = cs in
(is_valid_kem (kem_dh, kem_hash)) && (is_valid_aead aead) && (is_valid_hash hash)
let ciphersuite = cs:(DH.algorithm & hash_algorithm & aead & Hash.hash_alg){is_valid_ciphersuite cs}
inline_for_extraction
let kem_dh_of_cs (cs:ciphersuite) : DH.algorithm =
let (c,_,_,_) = cs in c
inline_for_extraction
let kem_hash_of_cs (cs:ciphersuite) : hash_algorithm =
let (_,h,_,_) = cs in h
inline_for_extraction
let aead_of_cs (cs:ciphersuite) : aead =
let (_,_,a,_) = cs in a
inline_for_extraction
let hash_of_cs (cs:ciphersuite) : hash_algorithm =
let (_,_,_,h) = cs in h
let is_valid_not_export_only_ciphersuite (cs:ciphersuite) : bool =
match aead_of_cs cs with
| ExportOnly -> false
| Seal _ -> true
let ciphersuite_not_export_only = cs:ciphersuite{is_valid_not_export_only_ciphersuite cs}
inline_for_extraction
let aead_alg_of (cs:ciphersuite_not_export_only) = match aead_of_cs cs with
| Seal alg -> alg
/// Constants for HPKE labels
///
/// The code for the following constants was generated
/// with the script make_hpke_constants.py. Ultimately,
/// this should be rewritten in Meta-F*. The idea is to
/// write a tactic `mk_label` that inspects a string
/// character by character, and generates the proper
/// definition. It could be used as follows:
/// %splice [label_version] (mk_label "HPKE-v1")
/// Inspiration can be taken from Test.Lowstarize.fst.
// generated: "HPKE-v1"
inline_for_extraction
let size_label_version: size_nat = 7
let label_version_list : l:list uint8{List.Tot.length l == size_label_version} =
[@inline_let]
let l = [u8 0x48; u8 0x50; u8 0x4b; u8 0x45; u8 0x2d; u8 0x76; u8 0x31] in
assert_norm(List.Tot.length l == size_label_version);
l
let label_version : lbytes size_label_version = createL label_version_list
// generated: "eae_prk"
inline_for_extraction
let size_label_eae_prk: size_nat = 7
let label_eae_prk_list : l:list uint8{List.Tot.length l == size_label_eae_prk} =
[@inline_let]
let l = [u8 0x65; u8 0x61; u8 0x65; u8 0x5f; u8 0x70; u8 0x72; u8 0x6b] in
assert_norm(List.Tot.length l == size_label_eae_prk);
l
let label_eae_prk : lbytes size_label_eae_prk = createL label_eae_prk_list
// generated: "KEM"
inline_for_extraction
let size_label_KEM: size_nat = 3
let label_KEM_list : l:list uint8{List.Tot.length l == size_label_KEM} =
[@inline_let]
let l = [u8 0x4b; u8 0x45; u8 0x4d] in
assert_norm(List.Tot.length l == size_label_KEM);
l
let label_KEM : lbytes size_label_KEM = createL label_KEM_list
// generated: "HPKE"
inline_for_extraction
let size_label_HPKE: size_nat = 4
let label_HPKE_list : l:list uint8{List.Tot.length l == size_label_HPKE} =
[@inline_let]
let l = [u8 0x48; u8 0x50; u8 0x4b; u8 0x45] in
assert_norm(List.Tot.length l == size_label_HPKE);
l
let label_HPKE : lbytes size_label_HPKE = createL label_HPKE_list
// generated: "shared_secret"
inline_for_extraction
let size_label_shared_secret: size_nat = 13
let label_shared_secret_list : l:list uint8{List.Tot.length l == size_label_shared_secret} =
[@inline_let]
let l = [u8 0x73; u8 0x68; u8 0x61; u8 0x72; u8 0x65; u8 0x64; u8 0x5f; u8 0x73; u8 0x65; u8 0x63; u8 0x72; u8 0x65; u8 0x74] in
assert_norm(List.Tot.length l == size_label_shared_secret);
l
let label_shared_secret : lbytes size_label_shared_secret = createL label_shared_secret_list
// generated: "psk_id_hash"
inline_for_extraction
let size_label_psk_id_hash: size_nat = 11
let label_psk_id_hash_list : l:list uint8{List.Tot.length l == size_label_psk_id_hash} =
[@inline_let]
let l = [u8 0x70; u8 0x73; u8 0x6b; u8 0x5f; u8 0x69; u8 0x64; u8 0x5f; u8 0x68; u8 0x61; u8 0x73; u8 0x68] in
assert_norm(List.Tot.length l == size_label_psk_id_hash);
l
let label_psk_id_hash : lbytes size_label_psk_id_hash = createL label_psk_id_hash_list
// generated: "info_hash"
inline_for_extraction
let size_label_info_hash: size_nat = 9
let label_info_hash_list : l:list uint8{List.Tot.length l == size_label_info_hash} =
[@inline_let]
let l = [u8 0x69; u8 0x6e; u8 0x66; u8 0x6f; u8 0x5f; u8 0x68; u8 0x61; u8 0x73; u8 0x68] in
assert_norm(List.Tot.length l == size_label_info_hash);
l
let label_info_hash : lbytes size_label_info_hash = createL label_info_hash_list
// generated: "secret"
inline_for_extraction
let size_label_secret: size_nat = 6
let label_secret_list : l:list uint8{List.Tot.length l == size_label_secret} =
[@inline_let]
let l = [u8 0x73; u8 0x65; u8 0x63; u8 0x72; u8 0x65; u8 0x74] in
assert_norm(List.Tot.length l == size_label_secret);
l
let label_secret : lbytes size_label_secret = createL label_secret_list
// generated: "key"
inline_for_extraction
let size_label_key: size_nat = 3
let label_key_list : l:list uint8{List.Tot.length l == size_label_key} =
[@inline_let]
let l = [u8 0x6b; u8 0x65; u8 0x79] in
assert_norm(List.Tot.length l == size_label_key);
l
let label_key : lbytes size_label_key = createL label_key_list
// generated: "base_nonce"
inline_for_extraction
let size_label_base_nonce: size_nat = 10
let label_base_nonce_list : l:list uint8{List.Tot.length l == size_label_base_nonce} =
[@inline_let]
let l = [u8 0x62; u8 0x61; u8 0x73; u8 0x65; u8 0x5f; u8 0x6e; u8 0x6f; u8 0x6e; u8 0x63; u8 0x65] in
assert_norm(List.Tot.length l == size_label_base_nonce);
l
let label_base_nonce : lbytes size_label_base_nonce = createL label_base_nonce_list
// generated: "exp"
inline_for_extraction
let size_label_exp: size_nat = 3
let label_exp_list : l:list uint8{List.Tot.length l == size_label_exp} =
[@inline_let]
let l = [u8 0x65; u8 0x78; u8 0x70] in
assert_norm(List.Tot.length l == size_label_exp);
l
let label_exp : lbytes size_label_exp = createL label_exp_list
// generated: "sec"
inline_for_extraction
let size_label_sec: size_nat = 3
let label_sec_list : l:list uint8{List.Tot.length l == size_label_sec} =
[@inline_let]
let l = [u8 0x73; u8 0x65; u8 0x63] in
assert_norm(List.Tot.length l == size_label_sec);
l
let label_sec : lbytes size_label_sec = createL label_sec_list
// generated: "dkp_prk"
inline_for_extraction
let size_label_dkp_prk: size_nat = 7
let label_dkp_prk_list : l:list uint8{List.Tot.length l == size_label_dkp_prk} =
[@inline_let]
let l = [u8 0x64; u8 0x6b; u8 0x70; u8 0x5f; u8 0x70; u8 0x72; u8 0x6b] in
assert_norm(List.Tot.length l == size_label_dkp_prk);
l
let label_dkp_prk : lbytes size_label_dkp_prk = createL label_dkp_prk_list
// generated: "candidate"
inline_for_extraction
let size_label_candidate: size_nat = 9
let label_candidate_list : l:list uint8{List.Tot.length l == size_label_candidate} =
[@inline_let]
let l = [u8 0x63; u8 0x61; u8 0x6e; u8 0x64; u8 0x69; u8 0x64; u8 0x61; u8 0x74; u8 0x65] in
assert_norm(List.Tot.length l == size_label_candidate);
l
let label_candidate : lbytes size_label_candidate = createL label_candidate_list
// generated: "sk"
inline_for_extraction
let size_label_sk: size_nat = 2
let label_sk_list : l:list uint8{List.Tot.length l == size_label_sk} =
[@inline_let]
let l = [u8 0x73; u8 0x6b] in
assert_norm(List.Tot.length l == size_label_sk);
l
let label_sk : lbytes size_label_sk = createL label_sk_list
///
/// Constants sizes
///
inline_for_extraction
let size_aead_nonce (cs:ciphersuite): size_nat =
assert_norm (8 * 12 <= pow2 64 - 1);
match aead_of_cs cs with
| ExportOnly -> 0
| Seal _ -> 12
inline_for_extraction
let size_aead_key (cs:ciphersuite): size_nat =
match aead_of_cs cs with
| ExportOnly -> 0
| Seal _ -> AEAD.key_length (aead_alg_of cs)
inline_for_extraction
let size_aead_tag (cs:ciphersuite): size_nat =
match aead_of_cs cs with
| ExportOnly -> 0
| Seal _ -> AEAD.tag_length (aead_alg_of cs)
inline_for_extraction
let size_dh_key (cs:ciphersuite): size_nat = DH.size_key (kem_dh_of_cs cs)
inline_for_extraction
let size_dh_public (cs:ciphersuite): size_nat = match kem_dh_of_cs cs with
| DH.DH_Curve25519 -> DH.size_public DH.DH_Curve25519
| DH.DH_P256 -> DH.size_public DH.DH_P256 + 1 // Need the additional byte for representation
inline_for_extraction
let size_dh_serialized (cs:ciphersuite): size_nat = match kem_dh_of_cs cs with
| DH.DH_Curve25519 -> DH.size_public DH.DH_Curve25519
| DH.DH_P256 -> DH.size_public DH.DH_P256
inline_for_extraction
let size_kem_kdf (cs:ciphersuite): size_nat = Hash.hash_length (kem_hash_of_cs cs)
inline_for_extraction
let size_kem_key (cs:ciphersuite): size_nat = Hash.hash_length (kem_hash_of_cs cs)
inline_for_extraction
let size_kdf (cs:ciphersuite): size_nat = Hash.hash_length (hash_of_cs cs)
let max_seq (cs:ciphersuite): nat =
match aead_of_cs cs with
| ExportOnly -> 0
| Seal _ -> pow2 (8*(size_aead_nonce cs)) - 1
inline_for_extraction
let size_suite_id_kem: size_nat = size_label_KEM + 2
inline_for_extraction
let size_suite_id_hpke: size_nat = size_label_HPKE + 6
inline_for_extraction
let size_mode_identifier: size_nat = 1
| false | true |
Spec.Agile.HPKE.fsti
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val size_ks_ctx (cs: ciphersuite) : size_nat
|
[] |
Spec.Agile.HPKE.size_ks_ctx
|
{
"file_name": "specs/Spec.Agile.HPKE.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
cs: Spec.Agile.HPKE.ciphersuite -> Lib.IntTypes.size_nat
|
{
"end_col": 83,
"end_line": 314,
"start_col": 45,
"start_line": 314
}
|
Prims.Tot
|
[
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519.Group",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Ed25519.PrecompTable",
"short_module": "SPTE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "LM"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"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.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519.Group",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation.Definition",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"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.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let pow_point (k:nat) (p:S.aff_point_c) =
LE.pow S.mk_ed25519_comm_monoid p k
|
let pow_point (k: nat) (p: S.aff_point_c) =
| false | null | false |
LE.pow S.mk_ed25519_comm_monoid p k
|
{
"checked_file": "Hacl.Ed25519.PrecompTable.fsti.checked",
"dependencies": [
"Spec.Exponentiation.fsti.checked",
"Spec.Ed25519.Lemmas.fsti.checked",
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.Definition.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"Hacl.Impl.Ed25519.Group.fst.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Bignum25519.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Ed25519.PrecompTable.fsti"
}
|
[
"total"
] |
[
"Prims.nat",
"Spec.Ed25519.aff_point_c",
"Lib.Exponentiation.Definition.pow",
"Spec.Ed25519.mk_ed25519_comm_monoid"
] |
[] |
module Hacl.Ed25519.PrecompTable
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module LSeq = Lib.Sequence
module LE = Lib.Exponentiation.Definition
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module SPT = Hacl.Spec.PrecompBaseTable
module S = Spec.Ed25519
include Hacl.Impl.Ed25519.Group
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val ext_point_to_list: p:S.ext_point_c
-> x:list uint64{FStar.List.Tot.length x = 20 /\
mk_to_ed25519_comm_monoid.BE.linv (Seq.seq_of_list x)}
val lemma_refl: x:S.ext_point_c ->
Lemma (S.mk_ed25519_concrete_ops.SE.to.SE.refl x ==
mk_to_ed25519_comm_monoid.BE.refl (Seq.seq_of_list (ext_point_to_list x)))
inline_for_extraction noextract
let mk_ed25519_precomp_base_table: SPT.mk_precomp_base_table S.ext_point_c U64 20ul 0ul = {
SPT.concr_ops = S.mk_ed25519_concrete_ops;
SPT.to_cm = mk_to_ed25519_comm_monoid;
SPT.to_list = ext_point_to_list;
SPT.lemma_refl = lemma_refl;
}
inline_for_extraction noextract
let g_c : S.ext_point_c =
Spec.Ed25519.Lemmas.g_is_on_curve ();
S.g
inline_for_extraction noextract
| false | true |
Hacl.Ed25519.PrecompTable.fsti
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val pow_point : k: Prims.nat -> p: Spec.Ed25519.aff_point_c -> Spec.Ed25519.aff_point_c
|
[] |
Hacl.Ed25519.PrecompTable.pow_point
|
{
"file_name": "code/ed25519/Hacl.Ed25519.PrecompTable.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
k: Prims.nat -> p: Spec.Ed25519.aff_point_c -> Spec.Ed25519.aff_point_c
|
{
"end_col": 37,
"end_line": 52,
"start_col": 2,
"start_line": 52
}
|
|
Prims.Tot
|
val g_pow2_64:S.aff_point
|
[
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519.Group",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Ed25519.PrecompTable",
"short_module": "SPTE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "LM"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"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.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519.Group",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation.Definition",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"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.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let g_pow2_64 : S.aff_point = pow_point (pow2 64) g_aff
|
val g_pow2_64:S.aff_point
let g_pow2_64:S.aff_point =
| false | null | false |
pow_point (pow2 64) g_aff
|
{
"checked_file": "Hacl.Ed25519.PrecompTable.fsti.checked",
"dependencies": [
"Spec.Exponentiation.fsti.checked",
"Spec.Ed25519.Lemmas.fsti.checked",
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.Definition.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"Hacl.Impl.Ed25519.Group.fst.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Bignum25519.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Ed25519.PrecompTable.fsti"
}
|
[
"total"
] |
[
"Hacl.Ed25519.PrecompTable.pow_point",
"Prims.pow2",
"Hacl.Ed25519.PrecompTable.g_aff"
] |
[] |
module Hacl.Ed25519.PrecompTable
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module LSeq = Lib.Sequence
module LE = Lib.Exponentiation.Definition
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module SPT = Hacl.Spec.PrecompBaseTable
module S = Spec.Ed25519
include Hacl.Impl.Ed25519.Group
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val ext_point_to_list: p:S.ext_point_c
-> x:list uint64{FStar.List.Tot.length x = 20 /\
mk_to_ed25519_comm_monoid.BE.linv (Seq.seq_of_list x)}
val lemma_refl: x:S.ext_point_c ->
Lemma (S.mk_ed25519_concrete_ops.SE.to.SE.refl x ==
mk_to_ed25519_comm_monoid.BE.refl (Seq.seq_of_list (ext_point_to_list x)))
inline_for_extraction noextract
let mk_ed25519_precomp_base_table: SPT.mk_precomp_base_table S.ext_point_c U64 20ul 0ul = {
SPT.concr_ops = S.mk_ed25519_concrete_ops;
SPT.to_cm = mk_to_ed25519_comm_monoid;
SPT.to_list = ext_point_to_list;
SPT.lemma_refl = lemma_refl;
}
inline_for_extraction noextract
let g_c : S.ext_point_c =
Spec.Ed25519.Lemmas.g_is_on_curve ();
S.g
inline_for_extraction noextract
let pow_point (k:nat) (p:S.aff_point_c) =
LE.pow S.mk_ed25519_comm_monoid p k
//----------------
noextract
let g_aff : S.aff_point_c =
Spec.Ed25519.Lemmas.g_is_on_curve ();
S.to_aff_point S.g
// [pow2 64]G
| false | true |
Hacl.Ed25519.PrecompTable.fsti
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val g_pow2_64:S.aff_point
|
[] |
Hacl.Ed25519.PrecompTable.g_pow2_64
|
{
"file_name": "code/ed25519/Hacl.Ed25519.PrecompTable.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
Spec.Ed25519.PointOps.aff_point
|
{
"end_col": 55,
"end_line": 63,
"start_col": 30,
"start_line": 63
}
|
Prims.Tot
|
val g_c:S.ext_point_c
|
[
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519.Group",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Ed25519.PrecompTable",
"short_module": "SPTE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "LM"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"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.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519.Group",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation.Definition",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"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.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let g_c : S.ext_point_c =
Spec.Ed25519.Lemmas.g_is_on_curve ();
S.g
|
val g_c:S.ext_point_c
let g_c:S.ext_point_c =
| false | null | false |
Spec.Ed25519.Lemmas.g_is_on_curve ();
S.g
|
{
"checked_file": "Hacl.Ed25519.PrecompTable.fsti.checked",
"dependencies": [
"Spec.Exponentiation.fsti.checked",
"Spec.Ed25519.Lemmas.fsti.checked",
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.Definition.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"Hacl.Impl.Ed25519.Group.fst.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Bignum25519.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Ed25519.PrecompTable.fsti"
}
|
[
"total"
] |
[
"Spec.Ed25519.PointOps.g",
"Prims.unit",
"Spec.Ed25519.Lemmas.g_is_on_curve"
] |
[] |
module Hacl.Ed25519.PrecompTable
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module LSeq = Lib.Sequence
module LE = Lib.Exponentiation.Definition
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module SPT = Hacl.Spec.PrecompBaseTable
module S = Spec.Ed25519
include Hacl.Impl.Ed25519.Group
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val ext_point_to_list: p:S.ext_point_c
-> x:list uint64{FStar.List.Tot.length x = 20 /\
mk_to_ed25519_comm_monoid.BE.linv (Seq.seq_of_list x)}
val lemma_refl: x:S.ext_point_c ->
Lemma (S.mk_ed25519_concrete_ops.SE.to.SE.refl x ==
mk_to_ed25519_comm_monoid.BE.refl (Seq.seq_of_list (ext_point_to_list x)))
inline_for_extraction noextract
let mk_ed25519_precomp_base_table: SPT.mk_precomp_base_table S.ext_point_c U64 20ul 0ul = {
SPT.concr_ops = S.mk_ed25519_concrete_ops;
SPT.to_cm = mk_to_ed25519_comm_monoid;
SPT.to_list = ext_point_to_list;
SPT.lemma_refl = lemma_refl;
}
inline_for_extraction noextract
| false | true |
Hacl.Ed25519.PrecompTable.fsti
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val g_c:S.ext_point_c
|
[] |
Hacl.Ed25519.PrecompTable.g_c
|
{
"file_name": "code/ed25519/Hacl.Ed25519.PrecompTable.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
Spec.Ed25519.ext_point_c
|
{
"end_col": 5,
"end_line": 47,
"start_col": 2,
"start_line": 46
}
|
Prims.Tot
|
val g_pow2_192:S.aff_point
|
[
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519.Group",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Ed25519.PrecompTable",
"short_module": "SPTE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "LM"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"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.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519.Group",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation.Definition",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"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.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let g_pow2_192 : S.aff_point = pow_point (pow2 192) g_aff
|
val g_pow2_192:S.aff_point
let g_pow2_192:S.aff_point =
| false | null | false |
pow_point (pow2 192) g_aff
|
{
"checked_file": "Hacl.Ed25519.PrecompTable.fsti.checked",
"dependencies": [
"Spec.Exponentiation.fsti.checked",
"Spec.Ed25519.Lemmas.fsti.checked",
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.Definition.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"Hacl.Impl.Ed25519.Group.fst.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Bignum25519.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Ed25519.PrecompTable.fsti"
}
|
[
"total"
] |
[
"Hacl.Ed25519.PrecompTable.pow_point",
"Prims.pow2",
"Hacl.Ed25519.PrecompTable.g_aff"
] |
[] |
module Hacl.Ed25519.PrecompTable
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module LSeq = Lib.Sequence
module LE = Lib.Exponentiation.Definition
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module SPT = Hacl.Spec.PrecompBaseTable
module S = Spec.Ed25519
include Hacl.Impl.Ed25519.Group
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val ext_point_to_list: p:S.ext_point_c
-> x:list uint64{FStar.List.Tot.length x = 20 /\
mk_to_ed25519_comm_monoid.BE.linv (Seq.seq_of_list x)}
val lemma_refl: x:S.ext_point_c ->
Lemma (S.mk_ed25519_concrete_ops.SE.to.SE.refl x ==
mk_to_ed25519_comm_monoid.BE.refl (Seq.seq_of_list (ext_point_to_list x)))
inline_for_extraction noextract
let mk_ed25519_precomp_base_table: SPT.mk_precomp_base_table S.ext_point_c U64 20ul 0ul = {
SPT.concr_ops = S.mk_ed25519_concrete_ops;
SPT.to_cm = mk_to_ed25519_comm_monoid;
SPT.to_list = ext_point_to_list;
SPT.lemma_refl = lemma_refl;
}
inline_for_extraction noextract
let g_c : S.ext_point_c =
Spec.Ed25519.Lemmas.g_is_on_curve ();
S.g
inline_for_extraction noextract
let pow_point (k:nat) (p:S.aff_point_c) =
LE.pow S.mk_ed25519_comm_monoid p k
//----------------
noextract
let g_aff : S.aff_point_c =
Spec.Ed25519.Lemmas.g_is_on_curve ();
S.to_aff_point S.g
// [pow2 64]G
noextract
let g_pow2_64 : S.aff_point = pow_point (pow2 64) g_aff
// [pow2 128]G
noextract
let g_pow2_128 : S.aff_point = pow_point (pow2 128) g_aff
// [pow2 192]G
| false | true |
Hacl.Ed25519.PrecompTable.fsti
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val g_pow2_192:S.aff_point
|
[] |
Hacl.Ed25519.PrecompTable.g_pow2_192
|
{
"file_name": "code/ed25519/Hacl.Ed25519.PrecompTable.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
Spec.Ed25519.PointOps.aff_point
|
{
"end_col": 57,
"end_line": 71,
"start_col": 31,
"start_line": 71
}
|
Prims.Tot
|
val g_pow2_128:S.aff_point
|
[
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519.Group",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Ed25519.PrecompTable",
"short_module": "SPTE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "LM"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"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.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519.Group",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation.Definition",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"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.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let g_pow2_128 : S.aff_point = pow_point (pow2 128) g_aff
|
val g_pow2_128:S.aff_point
let g_pow2_128:S.aff_point =
| false | null | false |
pow_point (pow2 128) g_aff
|
{
"checked_file": "Hacl.Ed25519.PrecompTable.fsti.checked",
"dependencies": [
"Spec.Exponentiation.fsti.checked",
"Spec.Ed25519.Lemmas.fsti.checked",
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.Definition.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"Hacl.Impl.Ed25519.Group.fst.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Bignum25519.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Ed25519.PrecompTable.fsti"
}
|
[
"total"
] |
[
"Hacl.Ed25519.PrecompTable.pow_point",
"Prims.pow2",
"Hacl.Ed25519.PrecompTable.g_aff"
] |
[] |
module Hacl.Ed25519.PrecompTable
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module LSeq = Lib.Sequence
module LE = Lib.Exponentiation.Definition
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module SPT = Hacl.Spec.PrecompBaseTable
module S = Spec.Ed25519
include Hacl.Impl.Ed25519.Group
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val ext_point_to_list: p:S.ext_point_c
-> x:list uint64{FStar.List.Tot.length x = 20 /\
mk_to_ed25519_comm_monoid.BE.linv (Seq.seq_of_list x)}
val lemma_refl: x:S.ext_point_c ->
Lemma (S.mk_ed25519_concrete_ops.SE.to.SE.refl x ==
mk_to_ed25519_comm_monoid.BE.refl (Seq.seq_of_list (ext_point_to_list x)))
inline_for_extraction noextract
let mk_ed25519_precomp_base_table: SPT.mk_precomp_base_table S.ext_point_c U64 20ul 0ul = {
SPT.concr_ops = S.mk_ed25519_concrete_ops;
SPT.to_cm = mk_to_ed25519_comm_monoid;
SPT.to_list = ext_point_to_list;
SPT.lemma_refl = lemma_refl;
}
inline_for_extraction noextract
let g_c : S.ext_point_c =
Spec.Ed25519.Lemmas.g_is_on_curve ();
S.g
inline_for_extraction noextract
let pow_point (k:nat) (p:S.aff_point_c) =
LE.pow S.mk_ed25519_comm_monoid p k
//----------------
noextract
let g_aff : S.aff_point_c =
Spec.Ed25519.Lemmas.g_is_on_curve ();
S.to_aff_point S.g
// [pow2 64]G
noextract
let g_pow2_64 : S.aff_point = pow_point (pow2 64) g_aff
// [pow2 128]G
| false | true |
Hacl.Ed25519.PrecompTable.fsti
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val g_pow2_128:S.aff_point
|
[] |
Hacl.Ed25519.PrecompTable.g_pow2_128
|
{
"file_name": "code/ed25519/Hacl.Ed25519.PrecompTable.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
Spec.Ed25519.PointOps.aff_point
|
{
"end_col": 57,
"end_line": 67,
"start_col": 31,
"start_line": 67
}
|
Prims.Tot
|
val g_aff:S.aff_point_c
|
[
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519.Group",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Ed25519.PrecompTable",
"short_module": "SPTE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "LM"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"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.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519.Group",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation.Definition",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"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.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let g_aff : S.aff_point_c =
Spec.Ed25519.Lemmas.g_is_on_curve ();
S.to_aff_point S.g
|
val g_aff:S.aff_point_c
let g_aff:S.aff_point_c =
| false | null | false |
Spec.Ed25519.Lemmas.g_is_on_curve ();
S.to_aff_point S.g
|
{
"checked_file": "Hacl.Ed25519.PrecompTable.fsti.checked",
"dependencies": [
"Spec.Exponentiation.fsti.checked",
"Spec.Ed25519.Lemmas.fsti.checked",
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.Definition.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"Hacl.Impl.Ed25519.Group.fst.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Bignum25519.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Ed25519.PrecompTable.fsti"
}
|
[
"total"
] |
[
"Spec.Ed25519.PointOps.to_aff_point",
"Spec.Ed25519.PointOps.g",
"Prims.unit",
"Spec.Ed25519.Lemmas.g_is_on_curve"
] |
[] |
module Hacl.Ed25519.PrecompTable
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module LSeq = Lib.Sequence
module LE = Lib.Exponentiation.Definition
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module SPT = Hacl.Spec.PrecompBaseTable
module S = Spec.Ed25519
include Hacl.Impl.Ed25519.Group
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val ext_point_to_list: p:S.ext_point_c
-> x:list uint64{FStar.List.Tot.length x = 20 /\
mk_to_ed25519_comm_monoid.BE.linv (Seq.seq_of_list x)}
val lemma_refl: x:S.ext_point_c ->
Lemma (S.mk_ed25519_concrete_ops.SE.to.SE.refl x ==
mk_to_ed25519_comm_monoid.BE.refl (Seq.seq_of_list (ext_point_to_list x)))
inline_for_extraction noextract
let mk_ed25519_precomp_base_table: SPT.mk_precomp_base_table S.ext_point_c U64 20ul 0ul = {
SPT.concr_ops = S.mk_ed25519_concrete_ops;
SPT.to_cm = mk_to_ed25519_comm_monoid;
SPT.to_list = ext_point_to_list;
SPT.lemma_refl = lemma_refl;
}
inline_for_extraction noextract
let g_c : S.ext_point_c =
Spec.Ed25519.Lemmas.g_is_on_curve ();
S.g
inline_for_extraction noextract
let pow_point (k:nat) (p:S.aff_point_c) =
LE.pow S.mk_ed25519_comm_monoid p k
//----------------
noextract
| false | true |
Hacl.Ed25519.PrecompTable.fsti
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val g_aff:S.aff_point_c
|
[] |
Hacl.Ed25519.PrecompTable.g_aff
|
{
"file_name": "code/ed25519/Hacl.Ed25519.PrecompTable.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
Spec.Ed25519.aff_point_c
|
{
"end_col": 20,
"end_line": 59,
"start_col": 2,
"start_line": 58
}
|
Prims.Tot
|
[
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519.Group",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Ed25519.PrecompTable",
"short_module": "SPTE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "LM"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"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.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519.Group",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation.Definition",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"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.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let precomp_table_acc_inv
(p:S.aff_point_c)
(table_len:nat{table_len * 20 <= max_size_t})
(table:LSeq.lseq uint64 (table_len * 20))
(j:nat{j < table_len})
=
Math.Lemmas.lemma_mult_lt_right 20 j table_len;
Math.Lemmas.lemma_mult_le_right 20 (j + 1) table_len;
let bj = LSeq.sub table (j * 20) 20 in
F51.linv bj /\ refl bj == pow_point j p
|
let precomp_table_acc_inv
(p: S.aff_point_c)
(table_len: nat{table_len * 20 <= max_size_t})
(table: LSeq.lseq uint64 (table_len * 20))
(j: nat{j < table_len})
=
| false | null | false |
Math.Lemmas.lemma_mult_lt_right 20 j table_len;
Math.Lemmas.lemma_mult_le_right 20 (j + 1) table_len;
let bj = LSeq.sub table (j * 20) 20 in
F51.linv bj /\ refl bj == pow_point j p
|
{
"checked_file": "Hacl.Ed25519.PrecompTable.fsti.checked",
"dependencies": [
"Spec.Exponentiation.fsti.checked",
"Spec.Ed25519.Lemmas.fsti.checked",
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.Definition.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"Hacl.Impl.Ed25519.Group.fst.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Bignum25519.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Ed25519.PrecompTable.fsti"
}
|
[
"total"
] |
[
"Spec.Ed25519.aff_point_c",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Prims.op_LessThan",
"Prims.l_and",
"Hacl.Impl.Ed25519.Field51.linv",
"Prims.eq2",
"Hacl.Impl.Ed25519.Group.refl",
"Hacl.Ed25519.PrecompTable.pow_point",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.op_Multiply",
"Prims.op_Addition",
"Prims.l_Forall",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.Sequence.sub",
"Prims.unit",
"FStar.Math.Lemmas.lemma_mult_le_right",
"FStar.Math.Lemmas.lemma_mult_lt_right",
"Prims.logical"
] |
[] |
module Hacl.Ed25519.PrecompTable
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module LSeq = Lib.Sequence
module LE = Lib.Exponentiation.Definition
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module SPT = Hacl.Spec.PrecompBaseTable
module S = Spec.Ed25519
include Hacl.Impl.Ed25519.Group
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val ext_point_to_list: p:S.ext_point_c
-> x:list uint64{FStar.List.Tot.length x = 20 /\
mk_to_ed25519_comm_monoid.BE.linv (Seq.seq_of_list x)}
val lemma_refl: x:S.ext_point_c ->
Lemma (S.mk_ed25519_concrete_ops.SE.to.SE.refl x ==
mk_to_ed25519_comm_monoid.BE.refl (Seq.seq_of_list (ext_point_to_list x)))
inline_for_extraction noextract
let mk_ed25519_precomp_base_table: SPT.mk_precomp_base_table S.ext_point_c U64 20ul 0ul = {
SPT.concr_ops = S.mk_ed25519_concrete_ops;
SPT.to_cm = mk_to_ed25519_comm_monoid;
SPT.to_list = ext_point_to_list;
SPT.lemma_refl = lemma_refl;
}
inline_for_extraction noextract
let g_c : S.ext_point_c =
Spec.Ed25519.Lemmas.g_is_on_curve ();
S.g
inline_for_extraction noextract
let pow_point (k:nat) (p:S.aff_point_c) =
LE.pow S.mk_ed25519_comm_monoid p k
//----------------
noextract
let g_aff : S.aff_point_c =
Spec.Ed25519.Lemmas.g_is_on_curve ();
S.to_aff_point S.g
// [pow2 64]G
noextract
let g_pow2_64 : S.aff_point = pow_point (pow2 64) g_aff
// [pow2 128]G
noextract
let g_pow2_128 : S.aff_point = pow_point (pow2 128) g_aff
// [pow2 192]G
noextract
let g_pow2_192 : S.aff_point = pow_point (pow2 192) g_aff
inline_for_extraction noextract
val ext_g_pow2_64_lseq : LSeq.lseq uint64 20
inline_for_extraction noextract
val ext_g_pow2_128_lseq : LSeq.lseq uint64 20
inline_for_extraction noextract
val ext_g_pow2_192_lseq : LSeq.lseq uint64 20
val ext_g_pow2_64_lseq_lemma: unit ->
Lemma (F51.linv ext_g_pow2_64_lseq /\ refl ext_g_pow2_64_lseq == g_pow2_64)
val ext_g_pow2_128_lseq_lemma: unit ->
Lemma (F51.linv ext_g_pow2_128_lseq /\ refl ext_g_pow2_128_lseq == g_pow2_128)
val ext_g_pow2_192_lseq_lemma: unit ->
Lemma (F51.linv ext_g_pow2_192_lseq /\ refl ext_g_pow2_192_lseq == g_pow2_192)
inline_for_extraction
val mk_ext_g_pow2_64: unit -> StackInline (lbuffer uint64 20ul)
(requires fun _ -> True)
(ensures fun h0 b h1 -> live h1 b /\ stack_allocated b h0 h1 ext_g_pow2_64_lseq)
inline_for_extraction
val mk_ext_g_pow2_128: unit -> StackInline (lbuffer uint64 20ul)
(requires fun _ -> True)
(ensures fun h0 b h1 -> live h1 b /\ stack_allocated b h0 h1 ext_g_pow2_128_lseq)
inline_for_extraction
val mk_ext_g_pow2_192: unit -> StackInline (lbuffer uint64 20ul)
(requires fun _ -> True)
(ensures fun h0 b h1 -> live h1 b /\ stack_allocated b h0 h1 ext_g_pow2_192_lseq)
//----------------
unfold
let precomp_table_acc_inv
(p:S.aff_point_c)
(table_len:nat{table_len * 20 <= max_size_t})
(table:LSeq.lseq uint64 (table_len * 20))
(j:nat{j < table_len})
| false | false |
Hacl.Ed25519.PrecompTable.fsti
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val precomp_table_acc_inv : p: Spec.Ed25519.aff_point_c ->
table_len: Prims.nat{table_len * 20 <= Lib.IntTypes.max_size_t} ->
table: Lib.Sequence.lseq Lib.IntTypes.uint64 (table_len * 20) ->
j: Prims.nat{j < table_len}
-> Prims.logical
|
[] |
Hacl.Ed25519.PrecompTable.precomp_table_acc_inv
|
{
"file_name": "code/ed25519/Hacl.Ed25519.PrecompTable.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
p: Spec.Ed25519.aff_point_c ->
table_len: Prims.nat{table_len * 20 <= Lib.IntTypes.max_size_t} ->
table: Lib.Sequence.lseq Lib.IntTypes.uint64 (table_len * 20) ->
j: Prims.nat{j < table_len}
-> Prims.logical
|
{
"end_col": 41,
"end_line": 118,
"start_col": 2,
"start_line": 115
}
|
|
Prims.Tot
|
val mk_ed25519_precomp_base_table:SPT.mk_precomp_base_table S.ext_point_c U64 20ul 0ul
|
[
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519.Group",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Ed25519.PrecompTable",
"short_module": "SPTE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "LM"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"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.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519.Group",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable",
"short_module": "SPT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation.Definition",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"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.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let mk_ed25519_precomp_base_table: SPT.mk_precomp_base_table S.ext_point_c U64 20ul 0ul = {
SPT.concr_ops = S.mk_ed25519_concrete_ops;
SPT.to_cm = mk_to_ed25519_comm_monoid;
SPT.to_list = ext_point_to_list;
SPT.lemma_refl = lemma_refl;
}
|
val mk_ed25519_precomp_base_table:SPT.mk_precomp_base_table S.ext_point_c U64 20ul 0ul
let mk_ed25519_precomp_base_table:SPT.mk_precomp_base_table S.ext_point_c U64 20ul 0ul =
| false | null | false |
{
SPT.concr_ops = S.mk_ed25519_concrete_ops;
SPT.to_cm = mk_to_ed25519_comm_monoid;
SPT.to_list = ext_point_to_list;
SPT.lemma_refl = lemma_refl
}
|
{
"checked_file": "Hacl.Ed25519.PrecompTable.fsti.checked",
"dependencies": [
"Spec.Exponentiation.fsti.checked",
"Spec.Ed25519.Lemmas.fsti.checked",
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.Definition.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"Hacl.Impl.Ed25519.Group.fst.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Bignum25519.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Ed25519.PrecompTable.fsti"
}
|
[
"total"
] |
[
"Hacl.Spec.PrecompBaseTable.Mkmk_precomp_base_table",
"Spec.Ed25519.ext_point_c",
"Lib.IntTypes.U64",
"FStar.UInt32.uint_to_t",
"Spec.Ed25519.mk_ed25519_concrete_ops",
"Hacl.Impl.Ed25519.Group.mk_to_ed25519_comm_monoid",
"Hacl.Ed25519.PrecompTable.ext_point_to_list",
"Hacl.Ed25519.PrecompTable.lemma_refl"
] |
[] |
module Hacl.Ed25519.PrecompTable
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module LSeq = Lib.Sequence
module LE = Lib.Exponentiation.Definition
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module SPT = Hacl.Spec.PrecompBaseTable
module S = Spec.Ed25519
include Hacl.Impl.Ed25519.Group
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val ext_point_to_list: p:S.ext_point_c
-> x:list uint64{FStar.List.Tot.length x = 20 /\
mk_to_ed25519_comm_monoid.BE.linv (Seq.seq_of_list x)}
val lemma_refl: x:S.ext_point_c ->
Lemma (S.mk_ed25519_concrete_ops.SE.to.SE.refl x ==
mk_to_ed25519_comm_monoid.BE.refl (Seq.seq_of_list (ext_point_to_list x)))
inline_for_extraction noextract
| false | false |
Hacl.Ed25519.PrecompTable.fsti
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val mk_ed25519_precomp_base_table:SPT.mk_precomp_base_table S.ext_point_c U64 20ul 0ul
|
[] |
Hacl.Ed25519.PrecompTable.mk_ed25519_precomp_base_table
|
{
"file_name": "code/ed25519/Hacl.Ed25519.PrecompTable.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
Hacl.Spec.PrecompBaseTable.mk_precomp_base_table Spec.Ed25519.ext_point_c
Lib.IntTypes.U64
(FStar.UInt32.uint_to_t 20 <: FStar.UInt32.t)
(FStar.UInt32.uint_to_t 0 <: FStar.UInt32.t)
|
{
"end_col": 30,
"end_line": 40,
"start_col": 2,
"start_line": 37
}
|
Prims.Tot
|
[
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.ModInvLimb",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.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
}
] | false |
let mod_inv_limb_st (t:limb_t) =
n0:limb t ->
Stack (limb t)
(requires fun h -> True)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
r == S.mod_inv_limb n0)
|
let mod_inv_limb_st (t: limb_t) =
| false | null | false |
n0: limb t
-> Stack (limb t)
(requires fun h -> True)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\ r == S.mod_inv_limb n0)
|
{
"checked_file": "Hacl.Bignum.ModInvLimb.fsti.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.ModInvLimb.fsti.checked",
"Hacl.Bignum.Definitions.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.Bignum.ModInvLimb.fsti"
}
|
[
"total"
] |
[
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Bignum.Definitions.limb",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_True",
"Prims.l_and",
"Lib.Buffer.modifies0",
"Prims.eq2",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb"
] |
[] |
module Hacl.Bignum.ModInvLimb
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module S = Hacl.Spec.Bignum.ModInvLimb
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
| false | true |
Hacl.Bignum.ModInvLimb.fsti
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val mod_inv_limb_st : t: Hacl.Bignum.Definitions.limb_t -> Type0
|
[] |
Hacl.Bignum.ModInvLimb.mod_inv_limb_st
|
{
"file_name": "code/bignum/Hacl.Bignum.ModInvLimb.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
t: Hacl.Bignum.Definitions.limb_t -> Type0
|
{
"end_col": 27,
"end_line": 23,
"start_col": 2,
"start_line": 19
}
|
|
Prims.Tot
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let bytes_seed_a = 16
|
let bytes_seed_a =
| false | null | false |
16
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"total"
] |
[] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
| false | true |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val bytes_seed_a : Prims.int
|
[] |
Spec.Frodo.Params.bytes_seed_a
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
Prims.int
|
{
"end_col": 21,
"end_line": 59,
"start_col": 19,
"start_line": 59
}
|
|
Prims.Tot
|
val bytes_pkhash (a: frodo_alg) : size_pos
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let bytes_pkhash (a:frodo_alg) : size_pos =
crypto_bytes a
|
val bytes_pkhash (a: frodo_alg) : size_pos
let bytes_pkhash (a: frodo_alg) : size_pos =
| false | null | false |
crypto_bytes a
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"total"
] |
[
"Spec.Frodo.Params.frodo_alg",
"Spec.Frodo.Params.crypto_bytes",
"Lib.IntTypes.size_pos"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
let params_nbar = 8
let bytes_seed_a = 16
| false | true |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val bytes_pkhash (a: frodo_alg) : size_pos
|
[] |
Spec.Frodo.Params.bytes_pkhash
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
a: Spec.Frodo.Params.frodo_alg -> Lib.IntTypes.size_pos
|
{
"end_col": 16,
"end_line": 62,
"start_col": 2,
"start_line": 62
}
|
Prims.Tot
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let params_nbar = 8
|
let params_nbar =
| false | null | false |
8
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"total"
] |
[] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
| false | true |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val params_nbar : Prims.int
|
[] |
Spec.Frodo.Params.params_nbar
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
Prims.int
|
{
"end_col": 19,
"end_line": 58,
"start_col": 18,
"start_line": 58
}
|
|
Prims.Tot
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let frodo_shake_st =
inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> outputByteLen:size_nat
-> lbytes outputByteLen
|
let frodo_shake_st =
| false | null | false |
inputByteLen: nat -> input: bytes{length input == inputByteLen} -> outputByteLen: size_nat
-> lbytes outputByteLen
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"total"
] |
[
"Prims.nat",
"Lib.ByteSequence.bytes",
"Prims.eq2",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.IntTypes.size_nat",
"Lib.ByteSequence.lbytes"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
let params_nbar = 8
let bytes_seed_a = 16
let bytes_pkhash (a:frodo_alg) : size_pos =
crypto_bytes a
let bytes_mu (a:frodo_alg) : size_pos =
params_extracted_bits a * params_nbar * params_nbar / 8
let publicmatrixbytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_n a * params_nbar / 8)
let secretmatrixbytes_len (a:frodo_alg) : size_pos =
2 * params_n a * params_nbar
let ct1bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_n a / 8)
let ct2bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_nbar / 8)
let crypto_publickeybytes (a:frodo_alg) : size_pos =
bytes_seed_a + publicmatrixbytes_len a
let crypto_secretkeybytes (a:frodo_alg) : size_pos =
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a
let crypto_ciphertextbytes (a:frodo_alg) : size_pos =
ct1bytes_len a + ct2bytes_len a
val expand_crypto_publickeybytes: a:frodo_alg ->
Lemma (crypto_publickeybytes a == bytes_seed_a + publicmatrixbytes_len a)
let expand_crypto_publickeybytes a = ()
val expand_crypto_secretkeybytes: a:frodo_alg ->
Lemma (crypto_secretkeybytes a ==
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a)
let expand_crypto_secretkeybytes a = ()
val expand_crypto_ciphertextbytes: a:frodo_alg ->
Lemma (crypto_ciphertextbytes a == ct1bytes_len a + ct2bytes_len a)
let expand_crypto_ciphertextbytes a = ()
val params_n_sqr: a:frodo_alg ->
Lemma (params_n a * params_n a <= max_size_t /\ params_n a <= maxint U16)
let params_n_sqr a =
assert (params_n a <= maxint U16);
Math.Lemmas.lemma_mult_lt_sqr (params_n a) (params_n a) (maxint U16);
Math.Lemmas.pow2_plus 16 16
inline_for_extraction noextract
| false | true |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val frodo_shake_st : Type0
|
[] |
Spec.Frodo.Params.frodo_shake_st
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
Type0
|
{
"end_col": 25,
"end_line": 114,
"start_col": 4,
"start_line": 111
}
|
|
Prims.Tot
|
val frodo_gen_matrix (a: frodo_gen_a) : frodo_gen_matrix_st
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let frodo_gen_matrix (a:frodo_gen_a) : frodo_gen_matrix_st =
match a with
| SHAKE128 -> Spec.Frodo.Gen.frodo_gen_matrix_shake
| AES128 -> Spec.Frodo.Gen.frodo_gen_matrix_aes
|
val frodo_gen_matrix (a: frodo_gen_a) : frodo_gen_matrix_st
let frodo_gen_matrix (a: frodo_gen_a) : frodo_gen_matrix_st =
| false | null | false |
match a with
| SHAKE128 -> Spec.Frodo.Gen.frodo_gen_matrix_shake
| AES128 -> Spec.Frodo.Gen.frodo_gen_matrix_aes
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"total"
] |
[
"Spec.Frodo.Params.frodo_gen_a",
"Spec.Frodo.Gen.frodo_gen_matrix_shake",
"Spec.Frodo.Gen.frodo_gen_matrix_aes",
"Spec.Frodo.Params.frodo_gen_matrix_st"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
let params_nbar = 8
let bytes_seed_a = 16
let bytes_pkhash (a:frodo_alg) : size_pos =
crypto_bytes a
let bytes_mu (a:frodo_alg) : size_pos =
params_extracted_bits a * params_nbar * params_nbar / 8
let publicmatrixbytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_n a * params_nbar / 8)
let secretmatrixbytes_len (a:frodo_alg) : size_pos =
2 * params_n a * params_nbar
let ct1bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_n a / 8)
let ct2bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_nbar / 8)
let crypto_publickeybytes (a:frodo_alg) : size_pos =
bytes_seed_a + publicmatrixbytes_len a
let crypto_secretkeybytes (a:frodo_alg) : size_pos =
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a
let crypto_ciphertextbytes (a:frodo_alg) : size_pos =
ct1bytes_len a + ct2bytes_len a
val expand_crypto_publickeybytes: a:frodo_alg ->
Lemma (crypto_publickeybytes a == bytes_seed_a + publicmatrixbytes_len a)
let expand_crypto_publickeybytes a = ()
val expand_crypto_secretkeybytes: a:frodo_alg ->
Lemma (crypto_secretkeybytes a ==
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a)
let expand_crypto_secretkeybytes a = ()
val expand_crypto_ciphertextbytes: a:frodo_alg ->
Lemma (crypto_ciphertextbytes a == ct1bytes_len a + ct2bytes_len a)
let expand_crypto_ciphertextbytes a = ()
val params_n_sqr: a:frodo_alg ->
Lemma (params_n a * params_n a <= max_size_t /\ params_n a <= maxint U16)
let params_n_sqr a =
assert (params_n a <= maxint U16);
Math.Lemmas.lemma_mult_lt_sqr (params_n a) (params_n a) (maxint U16);
Math.Lemmas.pow2_plus 16 16
inline_for_extraction noextract
let frodo_shake_st =
inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> outputByteLen:size_nat
-> lbytes outputByteLen
inline_for_extraction
let frodo_shake (a:frodo_alg) : frodo_shake_st =
match a with
| Frodo64 | Frodo640 -> Spec.SHA3.shake128
| Frodo976 | Frodo1344 -> Spec.SHA3.shake256
inline_for_extraction noextract
let frodo_gen_matrix_st =
n:size_nat{n * n <= max_size_t /\ n <= maxint U16 /\ n % 4 = 0}
-> seed:lbytes 16
-> matrix n n
inline_for_extraction
| false | true |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val frodo_gen_matrix (a: frodo_gen_a) : frodo_gen_matrix_st
|
[] |
Spec.Frodo.Params.frodo_gen_matrix
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
a: Spec.Frodo.Params.frodo_gen_a -> Spec.Frodo.Params.frodo_gen_matrix_st
|
{
"end_col": 49,
"end_line": 135,
"start_col": 2,
"start_line": 133
}
|
Prims.Tot
|
val frodo_shake (a: frodo_alg) : frodo_shake_st
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let frodo_shake (a:frodo_alg) : frodo_shake_st =
match a with
| Frodo64 | Frodo640 -> Spec.SHA3.shake128
| Frodo976 | Frodo1344 -> Spec.SHA3.shake256
|
val frodo_shake (a: frodo_alg) : frodo_shake_st
let frodo_shake (a: frodo_alg) : frodo_shake_st =
| false | null | false |
match a with
| Frodo64 | Frodo640 -> Spec.SHA3.shake128
| Frodo976 | Frodo1344 -> Spec.SHA3.shake256
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"total"
] |
[
"Spec.Frodo.Params.frodo_alg",
"Spec.SHA3.shake128",
"Spec.SHA3.shake256",
"Spec.Frodo.Params.frodo_shake_st"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
let params_nbar = 8
let bytes_seed_a = 16
let bytes_pkhash (a:frodo_alg) : size_pos =
crypto_bytes a
let bytes_mu (a:frodo_alg) : size_pos =
params_extracted_bits a * params_nbar * params_nbar / 8
let publicmatrixbytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_n a * params_nbar / 8)
let secretmatrixbytes_len (a:frodo_alg) : size_pos =
2 * params_n a * params_nbar
let ct1bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_n a / 8)
let ct2bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_nbar / 8)
let crypto_publickeybytes (a:frodo_alg) : size_pos =
bytes_seed_a + publicmatrixbytes_len a
let crypto_secretkeybytes (a:frodo_alg) : size_pos =
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a
let crypto_ciphertextbytes (a:frodo_alg) : size_pos =
ct1bytes_len a + ct2bytes_len a
val expand_crypto_publickeybytes: a:frodo_alg ->
Lemma (crypto_publickeybytes a == bytes_seed_a + publicmatrixbytes_len a)
let expand_crypto_publickeybytes a = ()
val expand_crypto_secretkeybytes: a:frodo_alg ->
Lemma (crypto_secretkeybytes a ==
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a)
let expand_crypto_secretkeybytes a = ()
val expand_crypto_ciphertextbytes: a:frodo_alg ->
Lemma (crypto_ciphertextbytes a == ct1bytes_len a + ct2bytes_len a)
let expand_crypto_ciphertextbytes a = ()
val params_n_sqr: a:frodo_alg ->
Lemma (params_n a * params_n a <= max_size_t /\ params_n a <= maxint U16)
let params_n_sqr a =
assert (params_n a <= maxint U16);
Math.Lemmas.lemma_mult_lt_sqr (params_n a) (params_n a) (maxint U16);
Math.Lemmas.pow2_plus 16 16
inline_for_extraction noextract
let frodo_shake_st =
inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> outputByteLen:size_nat
-> lbytes outputByteLen
inline_for_extraction
| false | true |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val frodo_shake (a: frodo_alg) : frodo_shake_st
|
[] |
Spec.Frodo.Params.frodo_shake
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
a: Spec.Frodo.Params.frodo_alg -> Spec.Frodo.Params.frodo_shake_st
|
{
"end_col": 46,
"end_line": 121,
"start_col": 2,
"start_line": 119
}
|
Prims.Tot
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let frodo_gen_matrix_st =
n:size_nat{n * n <= max_size_t /\ n <= maxint U16 /\ n % 4 = 0}
-> seed:lbytes 16
-> matrix n n
|
let frodo_gen_matrix_st =
| false | null | false |
n: size_nat{n * n <= max_size_t /\ n <= maxint U16 /\ n % 4 = 0} -> seed: lbytes 16 -> matrix n n
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"total"
] |
[
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Lib.IntTypes.maxint",
"Lib.IntTypes.U16",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Lib.ByteSequence.lbytes",
"Spec.Matrix.matrix"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
let params_nbar = 8
let bytes_seed_a = 16
let bytes_pkhash (a:frodo_alg) : size_pos =
crypto_bytes a
let bytes_mu (a:frodo_alg) : size_pos =
params_extracted_bits a * params_nbar * params_nbar / 8
let publicmatrixbytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_n a * params_nbar / 8)
let secretmatrixbytes_len (a:frodo_alg) : size_pos =
2 * params_n a * params_nbar
let ct1bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_n a / 8)
let ct2bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_nbar / 8)
let crypto_publickeybytes (a:frodo_alg) : size_pos =
bytes_seed_a + publicmatrixbytes_len a
let crypto_secretkeybytes (a:frodo_alg) : size_pos =
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a
let crypto_ciphertextbytes (a:frodo_alg) : size_pos =
ct1bytes_len a + ct2bytes_len a
val expand_crypto_publickeybytes: a:frodo_alg ->
Lemma (crypto_publickeybytes a == bytes_seed_a + publicmatrixbytes_len a)
let expand_crypto_publickeybytes a = ()
val expand_crypto_secretkeybytes: a:frodo_alg ->
Lemma (crypto_secretkeybytes a ==
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a)
let expand_crypto_secretkeybytes a = ()
val expand_crypto_ciphertextbytes: a:frodo_alg ->
Lemma (crypto_ciphertextbytes a == ct1bytes_len a + ct2bytes_len a)
let expand_crypto_ciphertextbytes a = ()
val params_n_sqr: a:frodo_alg ->
Lemma (params_n a * params_n a <= max_size_t /\ params_n a <= maxint U16)
let params_n_sqr a =
assert (params_n a <= maxint U16);
Math.Lemmas.lemma_mult_lt_sqr (params_n a) (params_n a) (maxint U16);
Math.Lemmas.pow2_plus 16 16
inline_for_extraction noextract
let frodo_shake_st =
inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> outputByteLen:size_nat
-> lbytes outputByteLen
inline_for_extraction
let frodo_shake (a:frodo_alg) : frodo_shake_st =
match a with
| Frodo64 | Frodo640 -> Spec.SHA3.shake128
| Frodo976 | Frodo1344 -> Spec.SHA3.shake256
inline_for_extraction noextract
| false | true |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val frodo_gen_matrix_st : Type0
|
[] |
Spec.Frodo.Params.frodo_gen_matrix_st
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
Type0
|
{
"end_col": 15,
"end_line": 128,
"start_col": 4,
"start_line": 126
}
|
|
Prims.Tot
|
val crypto_ciphertextbytes (a: frodo_alg) : size_pos
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let crypto_ciphertextbytes (a:frodo_alg) : size_pos =
ct1bytes_len a + ct2bytes_len a
|
val crypto_ciphertextbytes (a: frodo_alg) : size_pos
let crypto_ciphertextbytes (a: frodo_alg) : size_pos =
| false | null | false |
ct1bytes_len a + ct2bytes_len a
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"total"
] |
[
"Spec.Frodo.Params.frodo_alg",
"Prims.op_Addition",
"Spec.Frodo.Params.ct1bytes_len",
"Spec.Frodo.Params.ct2bytes_len",
"Lib.IntTypes.size_pos"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
let params_nbar = 8
let bytes_seed_a = 16
let bytes_pkhash (a:frodo_alg) : size_pos =
crypto_bytes a
let bytes_mu (a:frodo_alg) : size_pos =
params_extracted_bits a * params_nbar * params_nbar / 8
let publicmatrixbytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_n a * params_nbar / 8)
let secretmatrixbytes_len (a:frodo_alg) : size_pos =
2 * params_n a * params_nbar
let ct1bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_n a / 8)
let ct2bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_nbar / 8)
let crypto_publickeybytes (a:frodo_alg) : size_pos =
bytes_seed_a + publicmatrixbytes_len a
let crypto_secretkeybytes (a:frodo_alg) : size_pos =
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a
| false | true |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val crypto_ciphertextbytes (a: frodo_alg) : size_pos
|
[] |
Spec.Frodo.Params.crypto_ciphertextbytes
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
a: Spec.Frodo.Params.frodo_alg -> Lib.IntTypes.size_pos
|
{
"end_col": 33,
"end_line": 86,
"start_col": 2,
"start_line": 86
}
|
Prims.Tot
|
val cdf_list_640:list uint16
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let cdf_list_640: list uint16 =
[ u16 4643; u16 13363; u16 20579; u16 25843; u16 29227; u16 31145; u16 32103; u16 32525;
u16 32689; u16 32745; u16 32762; u16 32766; u16 32767 ]
|
val cdf_list_640:list uint16
let cdf_list_640:list uint16 =
| false | null | false |
[
u16 4643; u16 13363; u16 20579; u16 25843; u16 29227; u16 31145; u16 32103; u16 32525; u16 32689;
u16 32745; u16 32762; u16 32766; u16 32767
]
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"total"
] |
[
"Prims.Cons",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U16",
"Lib.IntTypes.SEC",
"Lib.IntTypes.u16",
"Prims.Nil"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
let params_nbar = 8
let bytes_seed_a = 16
let bytes_pkhash (a:frodo_alg) : size_pos =
crypto_bytes a
let bytes_mu (a:frodo_alg) : size_pos =
params_extracted_bits a * params_nbar * params_nbar / 8
let publicmatrixbytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_n a * params_nbar / 8)
let secretmatrixbytes_len (a:frodo_alg) : size_pos =
2 * params_n a * params_nbar
let ct1bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_n a / 8)
let ct2bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_nbar / 8)
let crypto_publickeybytes (a:frodo_alg) : size_pos =
bytes_seed_a + publicmatrixbytes_len a
let crypto_secretkeybytes (a:frodo_alg) : size_pos =
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a
let crypto_ciphertextbytes (a:frodo_alg) : size_pos =
ct1bytes_len a + ct2bytes_len a
val expand_crypto_publickeybytes: a:frodo_alg ->
Lemma (crypto_publickeybytes a == bytes_seed_a + publicmatrixbytes_len a)
let expand_crypto_publickeybytes a = ()
val expand_crypto_secretkeybytes: a:frodo_alg ->
Lemma (crypto_secretkeybytes a ==
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a)
let expand_crypto_secretkeybytes a = ()
val expand_crypto_ciphertextbytes: a:frodo_alg ->
Lemma (crypto_ciphertextbytes a == ct1bytes_len a + ct2bytes_len a)
let expand_crypto_ciphertextbytes a = ()
val params_n_sqr: a:frodo_alg ->
Lemma (params_n a * params_n a <= max_size_t /\ params_n a <= maxint U16)
let params_n_sqr a =
assert (params_n a <= maxint U16);
Math.Lemmas.lemma_mult_lt_sqr (params_n a) (params_n a) (maxint U16);
Math.Lemmas.pow2_plus 16 16
inline_for_extraction noextract
let frodo_shake_st =
inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> outputByteLen:size_nat
-> lbytes outputByteLen
inline_for_extraction
let frodo_shake (a:frodo_alg) : frodo_shake_st =
match a with
| Frodo64 | Frodo640 -> Spec.SHA3.shake128
| Frodo976 | Frodo1344 -> Spec.SHA3.shake256
inline_for_extraction noextract
let frodo_gen_matrix_st =
n:size_nat{n * n <= max_size_t /\ n <= maxint U16 /\ n % 4 = 0}
-> seed:lbytes 16
-> matrix n n
inline_for_extraction
let frodo_gen_matrix (a:frodo_gen_a) : frodo_gen_matrix_st =
match a with
| SHAKE128 -> Spec.Frodo.Gen.frodo_gen_matrix_shake
| AES128 -> Spec.Frodo.Gen.frodo_gen_matrix_aes
(** CDF tables *)
| false | true |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val cdf_list_640:list uint16
|
[] |
Spec.Frodo.Params.cdf_list_640
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
Prims.list (Lib.IntTypes.int_t Lib.IntTypes.U16 Lib.IntTypes.SEC)
|
{
"end_col": 59,
"end_line": 141,
"start_col": 2,
"start_line": 140
}
|
Prims.Tot
|
val params_extracted_bits (a: frodo_alg) : x: size_pos{x < params_logq a /\ x <= 8}
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
|
val params_extracted_bits (a: frodo_alg) : x: size_pos{x < params_logq a /\ x <= 8}
let params_extracted_bits (a: frodo_alg) : x: size_pos{x < params_logq a /\ x <= 8} =
| false | null | false |
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"total"
] |
[
"Spec.Frodo.Params.frodo_alg",
"Lib.IntTypes.size_pos",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Spec.Frodo.Params.params_logq",
"Prims.op_LessThanOrEqual"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
| false | false |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val params_extracted_bits (a: frodo_alg) : x: size_pos{x < params_logq a /\ x <= 8}
|
[] |
Spec.Frodo.Params.params_extracted_bits
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
a: Spec.Frodo.Params.frodo_alg
-> x: Lib.IntTypes.size_pos{x < Spec.Frodo.Params.params_logq a /\ x <= 8}
|
{
"end_col": 18,
"end_line": 47,
"start_col": 2,
"start_line": 44
}
|
Prims.Tot
|
val cdf_table (a: frodo_alg) : lseq uint16 (cdf_table_len a)
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let cdf_table (a:frodo_alg) : lseq uint16 (cdf_table_len a) =
createL (cdf_list a)
|
val cdf_table (a: frodo_alg) : lseq uint16 (cdf_table_len a)
let cdf_table (a: frodo_alg) : lseq uint16 (cdf_table_len a) =
| false | null | false |
createL (cdf_list a)
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"total"
] |
[
"Spec.Frodo.Params.frodo_alg",
"Lib.Sequence.createL",
"Lib.IntTypes.uint16",
"Spec.Frodo.Params.cdf_list",
"Lib.Sequence.lseq",
"Spec.Frodo.Params.cdf_table_len"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
let params_nbar = 8
let bytes_seed_a = 16
let bytes_pkhash (a:frodo_alg) : size_pos =
crypto_bytes a
let bytes_mu (a:frodo_alg) : size_pos =
params_extracted_bits a * params_nbar * params_nbar / 8
let publicmatrixbytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_n a * params_nbar / 8)
let secretmatrixbytes_len (a:frodo_alg) : size_pos =
2 * params_n a * params_nbar
let ct1bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_n a / 8)
let ct2bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_nbar / 8)
let crypto_publickeybytes (a:frodo_alg) : size_pos =
bytes_seed_a + publicmatrixbytes_len a
let crypto_secretkeybytes (a:frodo_alg) : size_pos =
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a
let crypto_ciphertextbytes (a:frodo_alg) : size_pos =
ct1bytes_len a + ct2bytes_len a
val expand_crypto_publickeybytes: a:frodo_alg ->
Lemma (crypto_publickeybytes a == bytes_seed_a + publicmatrixbytes_len a)
let expand_crypto_publickeybytes a = ()
val expand_crypto_secretkeybytes: a:frodo_alg ->
Lemma (crypto_secretkeybytes a ==
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a)
let expand_crypto_secretkeybytes a = ()
val expand_crypto_ciphertextbytes: a:frodo_alg ->
Lemma (crypto_ciphertextbytes a == ct1bytes_len a + ct2bytes_len a)
let expand_crypto_ciphertextbytes a = ()
val params_n_sqr: a:frodo_alg ->
Lemma (params_n a * params_n a <= max_size_t /\ params_n a <= maxint U16)
let params_n_sqr a =
assert (params_n a <= maxint U16);
Math.Lemmas.lemma_mult_lt_sqr (params_n a) (params_n a) (maxint U16);
Math.Lemmas.pow2_plus 16 16
inline_for_extraction noextract
let frodo_shake_st =
inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> outputByteLen:size_nat
-> lbytes outputByteLen
inline_for_extraction
let frodo_shake (a:frodo_alg) : frodo_shake_st =
match a with
| Frodo64 | Frodo640 -> Spec.SHA3.shake128
| Frodo976 | Frodo1344 -> Spec.SHA3.shake256
inline_for_extraction noextract
let frodo_gen_matrix_st =
n:size_nat{n * n <= max_size_t /\ n <= maxint U16 /\ n % 4 = 0}
-> seed:lbytes 16
-> matrix n n
inline_for_extraction
let frodo_gen_matrix (a:frodo_gen_a) : frodo_gen_matrix_st =
match a with
| SHAKE128 -> Spec.Frodo.Gen.frodo_gen_matrix_shake
| AES128 -> Spec.Frodo.Gen.frodo_gen_matrix_aes
(** CDF tables *)
unfold let cdf_list_640: list uint16 =
[ u16 4643; u16 13363; u16 20579; u16 25843; u16 29227; u16 31145; u16 32103; u16 32525;
u16 32689; u16 32745; u16 32762; u16 32766; u16 32767 ]
unfold let cdf_list_976: list uint16 =
[ u16 5638; u16 15915; u16 23689; u16 28571; u16 31116; u16 32217; u16 32613; u16 32731;
u16 32760; u16 32766; u16 32767 ]
unfold let cdf_list_1344: list uint16 =
[ u16 9142; u16 23462; u16 30338; u16 32361; u16 32725; u16 32765; u16 32767 ]
inline_for_extraction
let cdf_table_len (a:frodo_alg) : size_pos =
match a with
| Frodo64 | Frodo640 -> 13
| Frodo976 -> 11
| Frodo1344 -> 7
inline_for_extraction
let cdf_list (a:frodo_alg) : x:list uint16{List.Tot.length x == cdf_table_len a} =
match a with
| Frodo64 | Frodo640 ->
assert_norm (List.Tot.length cdf_list_640 = 13);
cdf_list_640
| Frodo976 ->
assert_norm (List.Tot.length cdf_list_976 = 11);
cdf_list_976
| Frodo1344 ->
assert_norm (List.Tot.length cdf_list_1344 = 7);
cdf_list_1344
inline_for_extraction
| false | false |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val cdf_table (a: frodo_alg) : lseq uint16 (cdf_table_len a)
|
[] |
Spec.Frodo.Params.cdf_table
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
a: Spec.Frodo.Params.frodo_alg
-> Lib.Sequence.lseq Lib.IntTypes.uint16 (Spec.Frodo.Params.cdf_table_len a)
|
{
"end_col": 22,
"end_line": 175,
"start_col": 2,
"start_line": 175
}
|
Prims.Tot
|
val params_logq (a: frodo_alg) : x: size_pos{x <= 16}
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
|
val params_logq (a: frodo_alg) : x: size_pos{x <= 16}
let params_logq (a: frodo_alg) : x: size_pos{x <= 16} =
| false | null | false |
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"total"
] |
[
"Spec.Frodo.Params.frodo_alg",
"Lib.IntTypes.size_pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
| false | false |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val params_logq (a: frodo_alg) : x: size_pos{x <= 16}
|
[] |
Spec.Frodo.Params.params_logq
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
a: Spec.Frodo.Params.frodo_alg -> x: Lib.IntTypes.size_pos{x <= 16}
|
{
"end_col": 30,
"end_line": 39,
"start_col": 2,
"start_line": 37
}
|
Prims.Tot
|
val crypto_secretkeybytes (a: frodo_alg) : size_pos
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let crypto_secretkeybytes (a:frodo_alg) : size_pos =
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a
|
val crypto_secretkeybytes (a: frodo_alg) : size_pos
let crypto_secretkeybytes (a: frodo_alg) : size_pos =
| false | null | false |
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"total"
] |
[
"Spec.Frodo.Params.frodo_alg",
"Prims.op_Addition",
"Spec.Frodo.Params.crypto_bytes",
"Spec.Frodo.Params.crypto_publickeybytes",
"Spec.Frodo.Params.secretmatrixbytes_len",
"Spec.Frodo.Params.bytes_pkhash",
"Lib.IntTypes.size_pos"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
let params_nbar = 8
let bytes_seed_a = 16
let bytes_pkhash (a:frodo_alg) : size_pos =
crypto_bytes a
let bytes_mu (a:frodo_alg) : size_pos =
params_extracted_bits a * params_nbar * params_nbar / 8
let publicmatrixbytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_n a * params_nbar / 8)
let secretmatrixbytes_len (a:frodo_alg) : size_pos =
2 * params_n a * params_nbar
let ct1bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_n a / 8)
let ct2bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_nbar / 8)
let crypto_publickeybytes (a:frodo_alg) : size_pos =
bytes_seed_a + publicmatrixbytes_len a
| false | true |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val crypto_secretkeybytes (a: frodo_alg) : size_pos
|
[] |
Spec.Frodo.Params.crypto_secretkeybytes
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
a: Spec.Frodo.Params.frodo_alg -> Lib.IntTypes.size_pos
|
{
"end_col": 85,
"end_line": 83,
"start_col": 2,
"start_line": 83
}
|
Prims.Tot
|
val ct2bytes_len (a: frodo_alg) : size_pos
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let ct2bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_nbar / 8)
|
val ct2bytes_len (a: frodo_alg) : size_pos
let ct2bytes_len (a: frodo_alg) : size_pos =
| false | null | false |
params_logq a * (params_nbar * params_nbar / 8)
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"total"
] |
[
"Spec.Frodo.Params.frodo_alg",
"FStar.Mul.op_Star",
"Spec.Frodo.Params.params_logq",
"Prims.op_Division",
"Spec.Frodo.Params.params_nbar",
"Lib.IntTypes.size_pos"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
let params_nbar = 8
let bytes_seed_a = 16
let bytes_pkhash (a:frodo_alg) : size_pos =
crypto_bytes a
let bytes_mu (a:frodo_alg) : size_pos =
params_extracted_bits a * params_nbar * params_nbar / 8
let publicmatrixbytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_n a * params_nbar / 8)
let secretmatrixbytes_len (a:frodo_alg) : size_pos =
2 * params_n a * params_nbar
let ct1bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_n a / 8)
| false | true |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val ct2bytes_len (a: frodo_alg) : size_pos
|
[] |
Spec.Frodo.Params.ct2bytes_len
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
a: Spec.Frodo.Params.frodo_alg -> Lib.IntTypes.size_pos
|
{
"end_col": 49,
"end_line": 77,
"start_col": 2,
"start_line": 77
}
|
Prims.Tot
|
val secretmatrixbytes_len (a: frodo_alg) : size_pos
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let secretmatrixbytes_len (a:frodo_alg) : size_pos =
2 * params_n a * params_nbar
|
val secretmatrixbytes_len (a: frodo_alg) : size_pos
let secretmatrixbytes_len (a: frodo_alg) : size_pos =
| false | null | false |
(2 * params_n a) * params_nbar
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"total"
] |
[
"Spec.Frodo.Params.frodo_alg",
"FStar.Mul.op_Star",
"Spec.Frodo.Params.params_n",
"Spec.Frodo.Params.params_nbar",
"Lib.IntTypes.size_pos"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
let params_nbar = 8
let bytes_seed_a = 16
let bytes_pkhash (a:frodo_alg) : size_pos =
crypto_bytes a
let bytes_mu (a:frodo_alg) : size_pos =
params_extracted_bits a * params_nbar * params_nbar / 8
let publicmatrixbytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_n a * params_nbar / 8)
| false | true |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val secretmatrixbytes_len (a: frodo_alg) : size_pos
|
[] |
Spec.Frodo.Params.secretmatrixbytes_len
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
a: Spec.Frodo.Params.frodo_alg -> Lib.IntTypes.size_pos
|
{
"end_col": 30,
"end_line": 71,
"start_col": 2,
"start_line": 71
}
|
Prims.Tot
|
val cdf_table_len (a: frodo_alg) : size_pos
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let cdf_table_len (a:frodo_alg) : size_pos =
match a with
| Frodo64 | Frodo640 -> 13
| Frodo976 -> 11
| Frodo1344 -> 7
|
val cdf_table_len (a: frodo_alg) : size_pos
let cdf_table_len (a: frodo_alg) : size_pos =
| false | null | false |
match a with
| Frodo64 | Frodo640 -> 13
| Frodo976 -> 11
| Frodo1344 -> 7
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"total"
] |
[
"Spec.Frodo.Params.frodo_alg",
"Lib.IntTypes.size_pos"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
let params_nbar = 8
let bytes_seed_a = 16
let bytes_pkhash (a:frodo_alg) : size_pos =
crypto_bytes a
let bytes_mu (a:frodo_alg) : size_pos =
params_extracted_bits a * params_nbar * params_nbar / 8
let publicmatrixbytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_n a * params_nbar / 8)
let secretmatrixbytes_len (a:frodo_alg) : size_pos =
2 * params_n a * params_nbar
let ct1bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_n a / 8)
let ct2bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_nbar / 8)
let crypto_publickeybytes (a:frodo_alg) : size_pos =
bytes_seed_a + publicmatrixbytes_len a
let crypto_secretkeybytes (a:frodo_alg) : size_pos =
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a
let crypto_ciphertextbytes (a:frodo_alg) : size_pos =
ct1bytes_len a + ct2bytes_len a
val expand_crypto_publickeybytes: a:frodo_alg ->
Lemma (crypto_publickeybytes a == bytes_seed_a + publicmatrixbytes_len a)
let expand_crypto_publickeybytes a = ()
val expand_crypto_secretkeybytes: a:frodo_alg ->
Lemma (crypto_secretkeybytes a ==
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a)
let expand_crypto_secretkeybytes a = ()
val expand_crypto_ciphertextbytes: a:frodo_alg ->
Lemma (crypto_ciphertextbytes a == ct1bytes_len a + ct2bytes_len a)
let expand_crypto_ciphertextbytes a = ()
val params_n_sqr: a:frodo_alg ->
Lemma (params_n a * params_n a <= max_size_t /\ params_n a <= maxint U16)
let params_n_sqr a =
assert (params_n a <= maxint U16);
Math.Lemmas.lemma_mult_lt_sqr (params_n a) (params_n a) (maxint U16);
Math.Lemmas.pow2_plus 16 16
inline_for_extraction noextract
let frodo_shake_st =
inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> outputByteLen:size_nat
-> lbytes outputByteLen
inline_for_extraction
let frodo_shake (a:frodo_alg) : frodo_shake_st =
match a with
| Frodo64 | Frodo640 -> Spec.SHA3.shake128
| Frodo976 | Frodo1344 -> Spec.SHA3.shake256
inline_for_extraction noextract
let frodo_gen_matrix_st =
n:size_nat{n * n <= max_size_t /\ n <= maxint U16 /\ n % 4 = 0}
-> seed:lbytes 16
-> matrix n n
inline_for_extraction
let frodo_gen_matrix (a:frodo_gen_a) : frodo_gen_matrix_st =
match a with
| SHAKE128 -> Spec.Frodo.Gen.frodo_gen_matrix_shake
| AES128 -> Spec.Frodo.Gen.frodo_gen_matrix_aes
(** CDF tables *)
unfold let cdf_list_640: list uint16 =
[ u16 4643; u16 13363; u16 20579; u16 25843; u16 29227; u16 31145; u16 32103; u16 32525;
u16 32689; u16 32745; u16 32762; u16 32766; u16 32767 ]
unfold let cdf_list_976: list uint16 =
[ u16 5638; u16 15915; u16 23689; u16 28571; u16 31116; u16 32217; u16 32613; u16 32731;
u16 32760; u16 32766; u16 32767 ]
unfold let cdf_list_1344: list uint16 =
[ u16 9142; u16 23462; u16 30338; u16 32361; u16 32725; u16 32765; u16 32767 ]
inline_for_extraction
| false | true |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val cdf_table_len (a: frodo_alg) : size_pos
|
[] |
Spec.Frodo.Params.cdf_table_len
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
a: Spec.Frodo.Params.frodo_alg -> Lib.IntTypes.size_pos
|
{
"end_col": 18,
"end_line": 156,
"start_col": 2,
"start_line": 153
}
|
Prims.Tot
|
val crypto_bytes (a: frodo_alg) : x: size_pos{x <= 32}
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
|
val crypto_bytes (a: frodo_alg) : x: size_pos{x <= 32}
let crypto_bytes (a: frodo_alg) : x: size_pos{x <= 32} =
| false | null | false |
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"total"
] |
[
"Spec.Frodo.Params.frodo_alg",
"Lib.IntTypes.size_pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
| false | false |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val crypto_bytes (a: frodo_alg) : x: size_pos{x <= 32}
|
[] |
Spec.Frodo.Params.crypto_bytes
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
a: Spec.Frodo.Params.frodo_alg -> x: Lib.IntTypes.size_pos{x <= 32}
|
{
"end_col": 19,
"end_line": 55,
"start_col": 2,
"start_line": 52
}
|
FStar.Pervasives.Lemma
|
val params_n_sqr: a:frodo_alg ->
Lemma (params_n a * params_n a <= max_size_t /\ params_n a <= maxint U16)
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let params_n_sqr a =
assert (params_n a <= maxint U16);
Math.Lemmas.lemma_mult_lt_sqr (params_n a) (params_n a) (maxint U16);
Math.Lemmas.pow2_plus 16 16
|
val params_n_sqr: a:frodo_alg ->
Lemma (params_n a * params_n a <= max_size_t /\ params_n a <= maxint U16)
let params_n_sqr a =
| false | null | true |
assert (params_n a <= maxint U16);
Math.Lemmas.lemma_mult_lt_sqr (params_n a) (params_n a) (maxint U16);
Math.Lemmas.pow2_plus 16 16
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"lemma"
] |
[
"Spec.Frodo.Params.frodo_alg",
"FStar.Math.Lemmas.pow2_plus",
"Prims.unit",
"FStar.Math.Lemmas.lemma_mult_lt_sqr",
"Spec.Frodo.Params.params_n",
"Lib.IntTypes.maxint",
"Lib.IntTypes.U16",
"Prims._assert",
"Prims.b2t",
"Prims.op_LessThanOrEqual"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
let params_nbar = 8
let bytes_seed_a = 16
let bytes_pkhash (a:frodo_alg) : size_pos =
crypto_bytes a
let bytes_mu (a:frodo_alg) : size_pos =
params_extracted_bits a * params_nbar * params_nbar / 8
let publicmatrixbytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_n a * params_nbar / 8)
let secretmatrixbytes_len (a:frodo_alg) : size_pos =
2 * params_n a * params_nbar
let ct1bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_n a / 8)
let ct2bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_nbar / 8)
let crypto_publickeybytes (a:frodo_alg) : size_pos =
bytes_seed_a + publicmatrixbytes_len a
let crypto_secretkeybytes (a:frodo_alg) : size_pos =
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a
let crypto_ciphertextbytes (a:frodo_alg) : size_pos =
ct1bytes_len a + ct2bytes_len a
val expand_crypto_publickeybytes: a:frodo_alg ->
Lemma (crypto_publickeybytes a == bytes_seed_a + publicmatrixbytes_len a)
let expand_crypto_publickeybytes a = ()
val expand_crypto_secretkeybytes: a:frodo_alg ->
Lemma (crypto_secretkeybytes a ==
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a)
let expand_crypto_secretkeybytes a = ()
val expand_crypto_ciphertextbytes: a:frodo_alg ->
Lemma (crypto_ciphertextbytes a == ct1bytes_len a + ct2bytes_len a)
let expand_crypto_ciphertextbytes a = ()
val params_n_sqr: a:frodo_alg ->
Lemma (params_n a * params_n a <= max_size_t /\ params_n a <= maxint U16)
| false | false |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val params_n_sqr: a:frodo_alg ->
Lemma (params_n a * params_n a <= max_size_t /\ params_n a <= maxint U16)
|
[] |
Spec.Frodo.Params.params_n_sqr
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
a: Spec.Frodo.Params.frodo_alg
-> FStar.Pervasives.Lemma
(ensures
Spec.Frodo.Params.params_n a * Spec.Frodo.Params.params_n a <= Lib.IntTypes.max_size_t /\
Spec.Frodo.Params.params_n a <= Lib.IntTypes.maxint Lib.IntTypes.U16)
|
{
"end_col": 29,
"end_line": 106,
"start_col": 2,
"start_line": 104
}
|
Prims.Tot
|
val params_n (a: frodo_alg) : x: size_pos{x % 8 = 0 /\ x <= 1344}
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
|
val params_n (a: frodo_alg) : x: size_pos{x % 8 = 0 /\ x <= 1344}
let params_n (a: frodo_alg) : x: size_pos{x % 8 = 0 /\ x <= 1344} =
| false | null | false |
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"total"
] |
[
"Spec.Frodo.Params.frodo_alg",
"Lib.IntTypes.size_pos",
"Prims.l_and",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Prims.op_LessThanOrEqual"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
| false | false |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val params_n (a: frodo_alg) : x: size_pos{x % 8 = 0 /\ x <= 1344}
|
[] |
Spec.Frodo.Params.params_n
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
a: Spec.Frodo.Params.frodo_alg -> x: Lib.IntTypes.size_pos{x % 8 = 0 /\ x <= 1344}
|
{
"end_col": 21,
"end_line": 32,
"start_col": 2,
"start_line": 28
}
|
Prims.Tot
|
val cdf_list (a: frodo_alg) : x: list uint16 {List.Tot.length x == cdf_table_len a}
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let cdf_list (a:frodo_alg) : x:list uint16{List.Tot.length x == cdf_table_len a} =
match a with
| Frodo64 | Frodo640 ->
assert_norm (List.Tot.length cdf_list_640 = 13);
cdf_list_640
| Frodo976 ->
assert_norm (List.Tot.length cdf_list_976 = 11);
cdf_list_976
| Frodo1344 ->
assert_norm (List.Tot.length cdf_list_1344 = 7);
cdf_list_1344
|
val cdf_list (a: frodo_alg) : x: list uint16 {List.Tot.length x == cdf_table_len a}
let cdf_list (a: frodo_alg) : x: list uint16 {List.Tot.length x == cdf_table_len a} =
| false | null | false |
match a with
| Frodo64
| Frodo640 ->
assert_norm (List.Tot.length cdf_list_640 = 13);
cdf_list_640
| Frodo976 ->
assert_norm (List.Tot.length cdf_list_976 = 11);
cdf_list_976
| Frodo1344 ->
assert_norm (List.Tot.length cdf_list_1344 = 7);
cdf_list_1344
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"total"
] |
[
"Spec.Frodo.Params.frodo_alg",
"Spec.Frodo.Params.cdf_list_640",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.List.Tot.Base.length",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U16",
"Lib.IntTypes.SEC",
"Spec.Frodo.Params.cdf_list_976",
"Spec.Frodo.Params.cdf_list_1344",
"Prims.list",
"Lib.IntTypes.uint16",
"Prims.eq2",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"Prims.l_and",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.max_size_t",
"Spec.Frodo.Params.cdf_table_len"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
let params_nbar = 8
let bytes_seed_a = 16
let bytes_pkhash (a:frodo_alg) : size_pos =
crypto_bytes a
let bytes_mu (a:frodo_alg) : size_pos =
params_extracted_bits a * params_nbar * params_nbar / 8
let publicmatrixbytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_n a * params_nbar / 8)
let secretmatrixbytes_len (a:frodo_alg) : size_pos =
2 * params_n a * params_nbar
let ct1bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_n a / 8)
let ct2bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_nbar / 8)
let crypto_publickeybytes (a:frodo_alg) : size_pos =
bytes_seed_a + publicmatrixbytes_len a
let crypto_secretkeybytes (a:frodo_alg) : size_pos =
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a
let crypto_ciphertextbytes (a:frodo_alg) : size_pos =
ct1bytes_len a + ct2bytes_len a
val expand_crypto_publickeybytes: a:frodo_alg ->
Lemma (crypto_publickeybytes a == bytes_seed_a + publicmatrixbytes_len a)
let expand_crypto_publickeybytes a = ()
val expand_crypto_secretkeybytes: a:frodo_alg ->
Lemma (crypto_secretkeybytes a ==
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a)
let expand_crypto_secretkeybytes a = ()
val expand_crypto_ciphertextbytes: a:frodo_alg ->
Lemma (crypto_ciphertextbytes a == ct1bytes_len a + ct2bytes_len a)
let expand_crypto_ciphertextbytes a = ()
val params_n_sqr: a:frodo_alg ->
Lemma (params_n a * params_n a <= max_size_t /\ params_n a <= maxint U16)
let params_n_sqr a =
assert (params_n a <= maxint U16);
Math.Lemmas.lemma_mult_lt_sqr (params_n a) (params_n a) (maxint U16);
Math.Lemmas.pow2_plus 16 16
inline_for_extraction noextract
let frodo_shake_st =
inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> outputByteLen:size_nat
-> lbytes outputByteLen
inline_for_extraction
let frodo_shake (a:frodo_alg) : frodo_shake_st =
match a with
| Frodo64 | Frodo640 -> Spec.SHA3.shake128
| Frodo976 | Frodo1344 -> Spec.SHA3.shake256
inline_for_extraction noextract
let frodo_gen_matrix_st =
n:size_nat{n * n <= max_size_t /\ n <= maxint U16 /\ n % 4 = 0}
-> seed:lbytes 16
-> matrix n n
inline_for_extraction
let frodo_gen_matrix (a:frodo_gen_a) : frodo_gen_matrix_st =
match a with
| SHAKE128 -> Spec.Frodo.Gen.frodo_gen_matrix_shake
| AES128 -> Spec.Frodo.Gen.frodo_gen_matrix_aes
(** CDF tables *)
unfold let cdf_list_640: list uint16 =
[ u16 4643; u16 13363; u16 20579; u16 25843; u16 29227; u16 31145; u16 32103; u16 32525;
u16 32689; u16 32745; u16 32762; u16 32766; u16 32767 ]
unfold let cdf_list_976: list uint16 =
[ u16 5638; u16 15915; u16 23689; u16 28571; u16 31116; u16 32217; u16 32613; u16 32731;
u16 32760; u16 32766; u16 32767 ]
unfold let cdf_list_1344: list uint16 =
[ u16 9142; u16 23462; u16 30338; u16 32361; u16 32725; u16 32765; u16 32767 ]
inline_for_extraction
let cdf_table_len (a:frodo_alg) : size_pos =
match a with
| Frodo64 | Frodo640 -> 13
| Frodo976 -> 11
| Frodo1344 -> 7
inline_for_extraction
| false | false |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val cdf_list (a: frodo_alg) : x: list uint16 {List.Tot.length x == cdf_table_len a}
|
[] |
Spec.Frodo.Params.cdf_list
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
a: Spec.Frodo.Params.frodo_alg
-> x:
Prims.list Lib.IntTypes.uint16
{FStar.List.Tot.Base.length x == Spec.Frodo.Params.cdf_table_len a}
|
{
"end_col": 17,
"end_line": 170,
"start_col": 2,
"start_line": 161
}
|
Prims.Tot
|
val publicmatrixbytes_len (a: frodo_alg) : size_pos
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let publicmatrixbytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_n a * params_nbar / 8)
|
val publicmatrixbytes_len (a: frodo_alg) : size_pos
let publicmatrixbytes_len (a: frodo_alg) : size_pos =
| false | null | false |
params_logq a * (params_n a * params_nbar / 8)
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"total"
] |
[
"Spec.Frodo.Params.frodo_alg",
"FStar.Mul.op_Star",
"Spec.Frodo.Params.params_logq",
"Prims.op_Division",
"Spec.Frodo.Params.params_n",
"Spec.Frodo.Params.params_nbar",
"Lib.IntTypes.size_pos"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
let params_nbar = 8
let bytes_seed_a = 16
let bytes_pkhash (a:frodo_alg) : size_pos =
crypto_bytes a
let bytes_mu (a:frodo_alg) : size_pos =
params_extracted_bits a * params_nbar * params_nbar / 8
| false | true |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val publicmatrixbytes_len (a: frodo_alg) : size_pos
|
[] |
Spec.Frodo.Params.publicmatrixbytes_len
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
a: Spec.Frodo.Params.frodo_alg -> Lib.IntTypes.size_pos
|
{
"end_col": 48,
"end_line": 68,
"start_col": 2,
"start_line": 68
}
|
Prims.Tot
|
val bytes_mu (a: frodo_alg) : size_pos
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let bytes_mu (a:frodo_alg) : size_pos =
params_extracted_bits a * params_nbar * params_nbar / 8
|
val bytes_mu (a: frodo_alg) : size_pos
let bytes_mu (a: frodo_alg) : size_pos =
| false | null | false |
(params_extracted_bits a * params_nbar) * params_nbar / 8
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"total"
] |
[
"Spec.Frodo.Params.frodo_alg",
"Prims.op_Division",
"FStar.Mul.op_Star",
"Spec.Frodo.Params.params_extracted_bits",
"Spec.Frodo.Params.params_nbar",
"Lib.IntTypes.size_pos"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
let params_nbar = 8
let bytes_seed_a = 16
let bytes_pkhash (a:frodo_alg) : size_pos =
crypto_bytes a
| false | true |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val bytes_mu (a: frodo_alg) : size_pos
|
[] |
Spec.Frodo.Params.bytes_mu
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
a: Spec.Frodo.Params.frodo_alg -> Lib.IntTypes.size_pos
|
{
"end_col": 57,
"end_line": 65,
"start_col": 2,
"start_line": 65
}
|
Prims.Tot
|
val crypto_publickeybytes (a: frodo_alg) : size_pos
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let crypto_publickeybytes (a:frodo_alg) : size_pos =
bytes_seed_a + publicmatrixbytes_len a
|
val crypto_publickeybytes (a: frodo_alg) : size_pos
let crypto_publickeybytes (a: frodo_alg) : size_pos =
| false | null | false |
bytes_seed_a + publicmatrixbytes_len a
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"total"
] |
[
"Spec.Frodo.Params.frodo_alg",
"Prims.op_Addition",
"Spec.Frodo.Params.bytes_seed_a",
"Spec.Frodo.Params.publicmatrixbytes_len",
"Lib.IntTypes.size_pos"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
let params_nbar = 8
let bytes_seed_a = 16
let bytes_pkhash (a:frodo_alg) : size_pos =
crypto_bytes a
let bytes_mu (a:frodo_alg) : size_pos =
params_extracted_bits a * params_nbar * params_nbar / 8
let publicmatrixbytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_n a * params_nbar / 8)
let secretmatrixbytes_len (a:frodo_alg) : size_pos =
2 * params_n a * params_nbar
let ct1bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_n a / 8)
let ct2bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_nbar / 8)
| false | true |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val crypto_publickeybytes (a: frodo_alg) : size_pos
|
[] |
Spec.Frodo.Params.crypto_publickeybytes
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
a: Spec.Frodo.Params.frodo_alg -> Lib.IntTypes.size_pos
|
{
"end_col": 40,
"end_line": 80,
"start_col": 2,
"start_line": 80
}
|
Prims.Tot
|
val ct1bytes_len (a: frodo_alg) : size_pos
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let ct1bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_n a / 8)
|
val ct1bytes_len (a: frodo_alg) : size_pos
let ct1bytes_len (a: frodo_alg) : size_pos =
| false | null | false |
params_logq a * (params_nbar * params_n a / 8)
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"total"
] |
[
"Spec.Frodo.Params.frodo_alg",
"FStar.Mul.op_Star",
"Spec.Frodo.Params.params_logq",
"Prims.op_Division",
"Spec.Frodo.Params.params_nbar",
"Spec.Frodo.Params.params_n",
"Lib.IntTypes.size_pos"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
let params_nbar = 8
let bytes_seed_a = 16
let bytes_pkhash (a:frodo_alg) : size_pos =
crypto_bytes a
let bytes_mu (a:frodo_alg) : size_pos =
params_extracted_bits a * params_nbar * params_nbar / 8
let publicmatrixbytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_n a * params_nbar / 8)
let secretmatrixbytes_len (a:frodo_alg) : size_pos =
2 * params_n a * params_nbar
| false | true |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val ct1bytes_len (a: frodo_alg) : size_pos
|
[] |
Spec.Frodo.Params.ct1bytes_len
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
a: Spec.Frodo.Params.frodo_alg -> Lib.IntTypes.size_pos
|
{
"end_col": 48,
"end_line": 74,
"start_col": 2,
"start_line": 74
}
|
Prims.Tot
|
val cdf_list_1344:list uint16
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let cdf_list_1344: list uint16 =
[ u16 9142; u16 23462; u16 30338; u16 32361; u16 32725; u16 32765; u16 32767 ]
|
val cdf_list_1344:list uint16
let cdf_list_1344:list uint16 =
| false | null | false |
[u16 9142; u16 23462; u16 30338; u16 32361; u16 32725; u16 32765; u16 32767]
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"total"
] |
[
"Prims.Cons",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U16",
"Lib.IntTypes.SEC",
"Lib.IntTypes.u16",
"Prims.Nil"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
let params_nbar = 8
let bytes_seed_a = 16
let bytes_pkhash (a:frodo_alg) : size_pos =
crypto_bytes a
let bytes_mu (a:frodo_alg) : size_pos =
params_extracted_bits a * params_nbar * params_nbar / 8
let publicmatrixbytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_n a * params_nbar / 8)
let secretmatrixbytes_len (a:frodo_alg) : size_pos =
2 * params_n a * params_nbar
let ct1bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_n a / 8)
let ct2bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_nbar / 8)
let crypto_publickeybytes (a:frodo_alg) : size_pos =
bytes_seed_a + publicmatrixbytes_len a
let crypto_secretkeybytes (a:frodo_alg) : size_pos =
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a
let crypto_ciphertextbytes (a:frodo_alg) : size_pos =
ct1bytes_len a + ct2bytes_len a
val expand_crypto_publickeybytes: a:frodo_alg ->
Lemma (crypto_publickeybytes a == bytes_seed_a + publicmatrixbytes_len a)
let expand_crypto_publickeybytes a = ()
val expand_crypto_secretkeybytes: a:frodo_alg ->
Lemma (crypto_secretkeybytes a ==
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a)
let expand_crypto_secretkeybytes a = ()
val expand_crypto_ciphertextbytes: a:frodo_alg ->
Lemma (crypto_ciphertextbytes a == ct1bytes_len a + ct2bytes_len a)
let expand_crypto_ciphertextbytes a = ()
val params_n_sqr: a:frodo_alg ->
Lemma (params_n a * params_n a <= max_size_t /\ params_n a <= maxint U16)
let params_n_sqr a =
assert (params_n a <= maxint U16);
Math.Lemmas.lemma_mult_lt_sqr (params_n a) (params_n a) (maxint U16);
Math.Lemmas.pow2_plus 16 16
inline_for_extraction noextract
let frodo_shake_st =
inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> outputByteLen:size_nat
-> lbytes outputByteLen
inline_for_extraction
let frodo_shake (a:frodo_alg) : frodo_shake_st =
match a with
| Frodo64 | Frodo640 -> Spec.SHA3.shake128
| Frodo976 | Frodo1344 -> Spec.SHA3.shake256
inline_for_extraction noextract
let frodo_gen_matrix_st =
n:size_nat{n * n <= max_size_t /\ n <= maxint U16 /\ n % 4 = 0}
-> seed:lbytes 16
-> matrix n n
inline_for_extraction
let frodo_gen_matrix (a:frodo_gen_a) : frodo_gen_matrix_st =
match a with
| SHAKE128 -> Spec.Frodo.Gen.frodo_gen_matrix_shake
| AES128 -> Spec.Frodo.Gen.frodo_gen_matrix_aes
(** CDF tables *)
unfold let cdf_list_640: list uint16 =
[ u16 4643; u16 13363; u16 20579; u16 25843; u16 29227; u16 31145; u16 32103; u16 32525;
u16 32689; u16 32745; u16 32762; u16 32766; u16 32767 ]
unfold let cdf_list_976: list uint16 =
[ u16 5638; u16 15915; u16 23689; u16 28571; u16 31116; u16 32217; u16 32613; u16 32731;
u16 32760; u16 32766; u16 32767 ]
| false | true |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val cdf_list_1344:list uint16
|
[] |
Spec.Frodo.Params.cdf_list_1344
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
Prims.list (Lib.IntTypes.int_t Lib.IntTypes.U16 Lib.IntTypes.SEC)
|
{
"end_col": 80,
"end_line": 148,
"start_col": 2,
"start_line": 148
}
|
Prims.Tot
|
val cdf_list_976:list uint16
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let cdf_list_976: list uint16 =
[ u16 5638; u16 15915; u16 23689; u16 28571; u16 31116; u16 32217; u16 32613; u16 32731;
u16 32760; u16 32766; u16 32767 ]
|
val cdf_list_976:list uint16
let cdf_list_976:list uint16 =
| false | null | false |
[
u16 5638; u16 15915; u16 23689; u16 28571; u16 31116; u16 32217; u16 32613; u16 32731; u16 32760;
u16 32766; u16 32767
]
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"total"
] |
[
"Prims.Cons",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U16",
"Lib.IntTypes.SEC",
"Lib.IntTypes.u16",
"Prims.Nil"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
let params_nbar = 8
let bytes_seed_a = 16
let bytes_pkhash (a:frodo_alg) : size_pos =
crypto_bytes a
let bytes_mu (a:frodo_alg) : size_pos =
params_extracted_bits a * params_nbar * params_nbar / 8
let publicmatrixbytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_n a * params_nbar / 8)
let secretmatrixbytes_len (a:frodo_alg) : size_pos =
2 * params_n a * params_nbar
let ct1bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_n a / 8)
let ct2bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_nbar / 8)
let crypto_publickeybytes (a:frodo_alg) : size_pos =
bytes_seed_a + publicmatrixbytes_len a
let crypto_secretkeybytes (a:frodo_alg) : size_pos =
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a
let crypto_ciphertextbytes (a:frodo_alg) : size_pos =
ct1bytes_len a + ct2bytes_len a
val expand_crypto_publickeybytes: a:frodo_alg ->
Lemma (crypto_publickeybytes a == bytes_seed_a + publicmatrixbytes_len a)
let expand_crypto_publickeybytes a = ()
val expand_crypto_secretkeybytes: a:frodo_alg ->
Lemma (crypto_secretkeybytes a ==
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a)
let expand_crypto_secretkeybytes a = ()
val expand_crypto_ciphertextbytes: a:frodo_alg ->
Lemma (crypto_ciphertextbytes a == ct1bytes_len a + ct2bytes_len a)
let expand_crypto_ciphertextbytes a = ()
val params_n_sqr: a:frodo_alg ->
Lemma (params_n a * params_n a <= max_size_t /\ params_n a <= maxint U16)
let params_n_sqr a =
assert (params_n a <= maxint U16);
Math.Lemmas.lemma_mult_lt_sqr (params_n a) (params_n a) (maxint U16);
Math.Lemmas.pow2_plus 16 16
inline_for_extraction noextract
let frodo_shake_st =
inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> outputByteLen:size_nat
-> lbytes outputByteLen
inline_for_extraction
let frodo_shake (a:frodo_alg) : frodo_shake_st =
match a with
| Frodo64 | Frodo640 -> Spec.SHA3.shake128
| Frodo976 | Frodo1344 -> Spec.SHA3.shake256
inline_for_extraction noextract
let frodo_gen_matrix_st =
n:size_nat{n * n <= max_size_t /\ n <= maxint U16 /\ n % 4 = 0}
-> seed:lbytes 16
-> matrix n n
inline_for_extraction
let frodo_gen_matrix (a:frodo_gen_a) : frodo_gen_matrix_st =
match a with
| SHAKE128 -> Spec.Frodo.Gen.frodo_gen_matrix_shake
| AES128 -> Spec.Frodo.Gen.frodo_gen_matrix_aes
(** CDF tables *)
unfold let cdf_list_640: list uint16 =
[ u16 4643; u16 13363; u16 20579; u16 25843; u16 29227; u16 31145; u16 32103; u16 32525;
u16 32689; u16 32745; u16 32762; u16 32766; u16 32767 ]
| false | true |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val cdf_list_976:list uint16
|
[] |
Spec.Frodo.Params.cdf_list_976
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
Prims.list (Lib.IntTypes.int_t Lib.IntTypes.U16 Lib.IntTypes.SEC)
|
{
"end_col": 37,
"end_line": 145,
"start_col": 2,
"start_line": 144
}
|
FStar.Pervasives.Lemma
|
val lemma_cdf_list: a:frodo_alg -> i:size_nat{i < cdf_table_len a} ->
Lemma (uint_v (List.Tot.index (cdf_list a) i) < pow2 15)
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let lemma_cdf_list a i =
match a with
| Frodo64 | Frodo640 ->
assert_norm (List.Tot.length cdf_list_640 = 13);
lemma_cdf_list_640 i
| Frodo976 ->
assert_norm (List.Tot.length cdf_list_976 = 11);
lemma_cdf_list_976 i
| Frodo1344 ->
assert_norm (List.Tot.length cdf_list_1344 = 7);
lemma_cdf_list_1344 i
|
val lemma_cdf_list: a:frodo_alg -> i:size_nat{i < cdf_table_len a} ->
Lemma (uint_v (List.Tot.index (cdf_list a) i) < pow2 15)
let lemma_cdf_list a i =
| false | null | true |
match a with
| Frodo64
| Frodo640 ->
assert_norm (List.Tot.length cdf_list_640 = 13);
lemma_cdf_list_640 i
| Frodo976 ->
assert_norm (List.Tot.length cdf_list_976 = 11);
lemma_cdf_list_976 i
| Frodo1344 ->
assert_norm (List.Tot.length cdf_list_1344 = 7);
lemma_cdf_list_1344 i
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"lemma"
] |
[
"Spec.Frodo.Params.frodo_alg",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThan",
"Spec.Frodo.Params.cdf_table_len",
"Spec.Frodo.Params.lemma_cdf_list_640",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"FStar.List.Tot.Base.length",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U16",
"Lib.IntTypes.SEC",
"Spec.Frodo.Params.cdf_list_640",
"Spec.Frodo.Params.lemma_cdf_list_976",
"Spec.Frodo.Params.cdf_list_976",
"Spec.Frodo.Params.lemma_cdf_list_1344",
"Spec.Frodo.Params.cdf_list_1344"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
let params_nbar = 8
let bytes_seed_a = 16
let bytes_pkhash (a:frodo_alg) : size_pos =
crypto_bytes a
let bytes_mu (a:frodo_alg) : size_pos =
params_extracted_bits a * params_nbar * params_nbar / 8
let publicmatrixbytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_n a * params_nbar / 8)
let secretmatrixbytes_len (a:frodo_alg) : size_pos =
2 * params_n a * params_nbar
let ct1bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_n a / 8)
let ct2bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_nbar / 8)
let crypto_publickeybytes (a:frodo_alg) : size_pos =
bytes_seed_a + publicmatrixbytes_len a
let crypto_secretkeybytes (a:frodo_alg) : size_pos =
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a
let crypto_ciphertextbytes (a:frodo_alg) : size_pos =
ct1bytes_len a + ct2bytes_len a
val expand_crypto_publickeybytes: a:frodo_alg ->
Lemma (crypto_publickeybytes a == bytes_seed_a + publicmatrixbytes_len a)
let expand_crypto_publickeybytes a = ()
val expand_crypto_secretkeybytes: a:frodo_alg ->
Lemma (crypto_secretkeybytes a ==
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a)
let expand_crypto_secretkeybytes a = ()
val expand_crypto_ciphertextbytes: a:frodo_alg ->
Lemma (crypto_ciphertextbytes a == ct1bytes_len a + ct2bytes_len a)
let expand_crypto_ciphertextbytes a = ()
val params_n_sqr: a:frodo_alg ->
Lemma (params_n a * params_n a <= max_size_t /\ params_n a <= maxint U16)
let params_n_sqr a =
assert (params_n a <= maxint U16);
Math.Lemmas.lemma_mult_lt_sqr (params_n a) (params_n a) (maxint U16);
Math.Lemmas.pow2_plus 16 16
inline_for_extraction noextract
let frodo_shake_st =
inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> outputByteLen:size_nat
-> lbytes outputByteLen
inline_for_extraction
let frodo_shake (a:frodo_alg) : frodo_shake_st =
match a with
| Frodo64 | Frodo640 -> Spec.SHA3.shake128
| Frodo976 | Frodo1344 -> Spec.SHA3.shake256
inline_for_extraction noextract
let frodo_gen_matrix_st =
n:size_nat{n * n <= max_size_t /\ n <= maxint U16 /\ n % 4 = 0}
-> seed:lbytes 16
-> matrix n n
inline_for_extraction
let frodo_gen_matrix (a:frodo_gen_a) : frodo_gen_matrix_st =
match a with
| SHAKE128 -> Spec.Frodo.Gen.frodo_gen_matrix_shake
| AES128 -> Spec.Frodo.Gen.frodo_gen_matrix_aes
(** CDF tables *)
unfold let cdf_list_640: list uint16 =
[ u16 4643; u16 13363; u16 20579; u16 25843; u16 29227; u16 31145; u16 32103; u16 32525;
u16 32689; u16 32745; u16 32762; u16 32766; u16 32767 ]
unfold let cdf_list_976: list uint16 =
[ u16 5638; u16 15915; u16 23689; u16 28571; u16 31116; u16 32217; u16 32613; u16 32731;
u16 32760; u16 32766; u16 32767 ]
unfold let cdf_list_1344: list uint16 =
[ u16 9142; u16 23462; u16 30338; u16 32361; u16 32725; u16 32765; u16 32767 ]
inline_for_extraction
let cdf_table_len (a:frodo_alg) : size_pos =
match a with
| Frodo64 | Frodo640 -> 13
| Frodo976 -> 11
| Frodo1344 -> 7
inline_for_extraction
let cdf_list (a:frodo_alg) : x:list uint16{List.Tot.length x == cdf_table_len a} =
match a with
| Frodo64 | Frodo640 ->
assert_norm (List.Tot.length cdf_list_640 = 13);
cdf_list_640
| Frodo976 ->
assert_norm (List.Tot.length cdf_list_976 = 11);
cdf_list_976
| Frodo1344 ->
assert_norm (List.Tot.length cdf_list_1344 = 7);
cdf_list_1344
inline_for_extraction
let cdf_table (a:frodo_alg) : lseq uint16 (cdf_table_len a) =
createL (cdf_list a)
val lemma_cdf_list_640: i:size_nat{i < List.Tot.length cdf_list_640} ->
Lemma (uint_v (List.Tot.index cdf_list_640 i) < pow2 15)
let lemma_cdf_list_640 i =
assert_norm (List.Tot.length cdf_list_640 = 13);
assert_norm (uint_v (List.Tot.index cdf_list_640 0) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 1) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 2) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 3) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 4) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 5) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 6) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 7) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 8) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 9) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 10) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 11) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 12) < pow2 15)
val lemma_cdf_list_976: i:size_nat{i < List.Tot.length cdf_list_976} ->
Lemma (uint_v (List.Tot.index cdf_list_976 i) < pow2 15)
let lemma_cdf_list_976 i =
assert_norm (List.Tot.length cdf_list_976 = 11);
assert_norm (uint_v (List.Tot.index cdf_list_976 0) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 1) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 2) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 3) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 4) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 5) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 6) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 7) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 8) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 9) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 10) < pow2 15)
val lemma_cdf_list_1344: i:size_nat{i < List.Tot.length cdf_list_1344} ->
Lemma (uint_v (List.Tot.index cdf_list_1344 i) < pow2 15)
let lemma_cdf_list_1344 i =
assert_norm (List.Tot.length cdf_list_1344 = 7);
assert_norm (uint_v (List.Tot.index cdf_list_1344 0) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_1344 1) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_1344 2) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_1344 3) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_1344 4) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_1344 5) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_1344 6) < pow2 15)
val lemma_cdf_list: a:frodo_alg -> i:size_nat{i < cdf_table_len a} ->
Lemma (uint_v (List.Tot.index (cdf_list a) i) < pow2 15)
| false | false |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val lemma_cdf_list: a:frodo_alg -> i:size_nat{i < cdf_table_len a} ->
Lemma (uint_v (List.Tot.index (cdf_list a) i) < pow2 15)
|
[] |
Spec.Frodo.Params.lemma_cdf_list
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
a: Spec.Frodo.Params.frodo_alg -> i: Lib.IntTypes.size_nat{i < Spec.Frodo.Params.cdf_table_len a}
-> FStar.Pervasives.Lemma
(ensures
Lib.IntTypes.uint_v (FStar.List.Tot.Base.index (Spec.Frodo.Params.cdf_list a) i) <
Prims.pow2 15)
|
{
"end_col": 25,
"end_line": 240,
"start_col": 2,
"start_line": 231
}
|
FStar.Pervasives.Lemma
|
val lemma_cdf_list_1344: i:size_nat{i < List.Tot.length cdf_list_1344} ->
Lemma (uint_v (List.Tot.index cdf_list_1344 i) < pow2 15)
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let lemma_cdf_list_1344 i =
assert_norm (List.Tot.length cdf_list_1344 = 7);
assert_norm (uint_v (List.Tot.index cdf_list_1344 0) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_1344 1) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_1344 2) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_1344 3) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_1344 4) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_1344 5) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_1344 6) < pow2 15)
|
val lemma_cdf_list_1344: i:size_nat{i < List.Tot.length cdf_list_1344} ->
Lemma (uint_v (List.Tot.index cdf_list_1344 i) < pow2 15)
let lemma_cdf_list_1344 i =
| false | null | true |
assert_norm (List.Tot.length cdf_list_1344 = 7);
assert_norm (uint_v (List.Tot.index cdf_list_1344 0) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_1344 1) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_1344 2) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_1344 3) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_1344 4) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_1344 5) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_1344 6) < pow2 15)
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"lemma"
] |
[
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.List.Tot.Base.length",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U16",
"Lib.IntTypes.SEC",
"Spec.Frodo.Params.cdf_list_1344",
"FStar.Pervasives.assert_norm",
"Lib.IntTypes.uint_v",
"FStar.List.Tot.Base.index",
"Prims.pow2",
"Prims.unit",
"Prims.op_Equality",
"Prims.int"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
let params_nbar = 8
let bytes_seed_a = 16
let bytes_pkhash (a:frodo_alg) : size_pos =
crypto_bytes a
let bytes_mu (a:frodo_alg) : size_pos =
params_extracted_bits a * params_nbar * params_nbar / 8
let publicmatrixbytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_n a * params_nbar / 8)
let secretmatrixbytes_len (a:frodo_alg) : size_pos =
2 * params_n a * params_nbar
let ct1bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_n a / 8)
let ct2bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_nbar / 8)
let crypto_publickeybytes (a:frodo_alg) : size_pos =
bytes_seed_a + publicmatrixbytes_len a
let crypto_secretkeybytes (a:frodo_alg) : size_pos =
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a
let crypto_ciphertextbytes (a:frodo_alg) : size_pos =
ct1bytes_len a + ct2bytes_len a
val expand_crypto_publickeybytes: a:frodo_alg ->
Lemma (crypto_publickeybytes a == bytes_seed_a + publicmatrixbytes_len a)
let expand_crypto_publickeybytes a = ()
val expand_crypto_secretkeybytes: a:frodo_alg ->
Lemma (crypto_secretkeybytes a ==
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a)
let expand_crypto_secretkeybytes a = ()
val expand_crypto_ciphertextbytes: a:frodo_alg ->
Lemma (crypto_ciphertextbytes a == ct1bytes_len a + ct2bytes_len a)
let expand_crypto_ciphertextbytes a = ()
val params_n_sqr: a:frodo_alg ->
Lemma (params_n a * params_n a <= max_size_t /\ params_n a <= maxint U16)
let params_n_sqr a =
assert (params_n a <= maxint U16);
Math.Lemmas.lemma_mult_lt_sqr (params_n a) (params_n a) (maxint U16);
Math.Lemmas.pow2_plus 16 16
inline_for_extraction noextract
let frodo_shake_st =
inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> outputByteLen:size_nat
-> lbytes outputByteLen
inline_for_extraction
let frodo_shake (a:frodo_alg) : frodo_shake_st =
match a with
| Frodo64 | Frodo640 -> Spec.SHA3.shake128
| Frodo976 | Frodo1344 -> Spec.SHA3.shake256
inline_for_extraction noextract
let frodo_gen_matrix_st =
n:size_nat{n * n <= max_size_t /\ n <= maxint U16 /\ n % 4 = 0}
-> seed:lbytes 16
-> matrix n n
inline_for_extraction
let frodo_gen_matrix (a:frodo_gen_a) : frodo_gen_matrix_st =
match a with
| SHAKE128 -> Spec.Frodo.Gen.frodo_gen_matrix_shake
| AES128 -> Spec.Frodo.Gen.frodo_gen_matrix_aes
(** CDF tables *)
unfold let cdf_list_640: list uint16 =
[ u16 4643; u16 13363; u16 20579; u16 25843; u16 29227; u16 31145; u16 32103; u16 32525;
u16 32689; u16 32745; u16 32762; u16 32766; u16 32767 ]
unfold let cdf_list_976: list uint16 =
[ u16 5638; u16 15915; u16 23689; u16 28571; u16 31116; u16 32217; u16 32613; u16 32731;
u16 32760; u16 32766; u16 32767 ]
unfold let cdf_list_1344: list uint16 =
[ u16 9142; u16 23462; u16 30338; u16 32361; u16 32725; u16 32765; u16 32767 ]
inline_for_extraction
let cdf_table_len (a:frodo_alg) : size_pos =
match a with
| Frodo64 | Frodo640 -> 13
| Frodo976 -> 11
| Frodo1344 -> 7
inline_for_extraction
let cdf_list (a:frodo_alg) : x:list uint16{List.Tot.length x == cdf_table_len a} =
match a with
| Frodo64 | Frodo640 ->
assert_norm (List.Tot.length cdf_list_640 = 13);
cdf_list_640
| Frodo976 ->
assert_norm (List.Tot.length cdf_list_976 = 11);
cdf_list_976
| Frodo1344 ->
assert_norm (List.Tot.length cdf_list_1344 = 7);
cdf_list_1344
inline_for_extraction
let cdf_table (a:frodo_alg) : lseq uint16 (cdf_table_len a) =
createL (cdf_list a)
val lemma_cdf_list_640: i:size_nat{i < List.Tot.length cdf_list_640} ->
Lemma (uint_v (List.Tot.index cdf_list_640 i) < pow2 15)
let lemma_cdf_list_640 i =
assert_norm (List.Tot.length cdf_list_640 = 13);
assert_norm (uint_v (List.Tot.index cdf_list_640 0) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 1) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 2) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 3) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 4) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 5) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 6) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 7) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 8) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 9) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 10) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 11) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 12) < pow2 15)
val lemma_cdf_list_976: i:size_nat{i < List.Tot.length cdf_list_976} ->
Lemma (uint_v (List.Tot.index cdf_list_976 i) < pow2 15)
let lemma_cdf_list_976 i =
assert_norm (List.Tot.length cdf_list_976 = 11);
assert_norm (uint_v (List.Tot.index cdf_list_976 0) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 1) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 2) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 3) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 4) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 5) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 6) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 7) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 8) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 9) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 10) < pow2 15)
val lemma_cdf_list_1344: i:size_nat{i < List.Tot.length cdf_list_1344} ->
Lemma (uint_v (List.Tot.index cdf_list_1344 i) < pow2 15)
| false | false |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val lemma_cdf_list_1344: i:size_nat{i < List.Tot.length cdf_list_1344} ->
Lemma (uint_v (List.Tot.index cdf_list_1344 i) < pow2 15)
|
[] |
Spec.Frodo.Params.lemma_cdf_list_1344
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
i: Lib.IntTypes.size_nat{i < FStar.List.Tot.Base.length Spec.Frodo.Params.cdf_list_1344}
-> FStar.Pervasives.Lemma
(ensures
Lib.IntTypes.uint_v (FStar.List.Tot.Base.index Spec.Frodo.Params.cdf_list_1344 i) <
Prims.pow2 15)
|
{
"end_col": 65,
"end_line": 224,
"start_col": 2,
"start_line": 217
}
|
FStar.Pervasives.Lemma
|
val lemma_cdf_list_976: i:size_nat{i < List.Tot.length cdf_list_976} ->
Lemma (uint_v (List.Tot.index cdf_list_976 i) < pow2 15)
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let lemma_cdf_list_976 i =
assert_norm (List.Tot.length cdf_list_976 = 11);
assert_norm (uint_v (List.Tot.index cdf_list_976 0) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 1) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 2) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 3) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 4) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 5) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 6) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 7) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 8) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 9) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 10) < pow2 15)
|
val lemma_cdf_list_976: i:size_nat{i < List.Tot.length cdf_list_976} ->
Lemma (uint_v (List.Tot.index cdf_list_976 i) < pow2 15)
let lemma_cdf_list_976 i =
| false | null | true |
assert_norm (List.Tot.length cdf_list_976 = 11);
assert_norm (uint_v (List.Tot.index cdf_list_976 0) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 1) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 2) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 3) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 4) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 5) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 6) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 7) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 8) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 9) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_976 10) < pow2 15)
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"lemma"
] |
[
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.List.Tot.Base.length",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U16",
"Lib.IntTypes.SEC",
"Spec.Frodo.Params.cdf_list_976",
"FStar.Pervasives.assert_norm",
"Lib.IntTypes.uint_v",
"FStar.List.Tot.Base.index",
"Prims.pow2",
"Prims.unit",
"Prims.op_Equality",
"Prims.int"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
let params_nbar = 8
let bytes_seed_a = 16
let bytes_pkhash (a:frodo_alg) : size_pos =
crypto_bytes a
let bytes_mu (a:frodo_alg) : size_pos =
params_extracted_bits a * params_nbar * params_nbar / 8
let publicmatrixbytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_n a * params_nbar / 8)
let secretmatrixbytes_len (a:frodo_alg) : size_pos =
2 * params_n a * params_nbar
let ct1bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_n a / 8)
let ct2bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_nbar / 8)
let crypto_publickeybytes (a:frodo_alg) : size_pos =
bytes_seed_a + publicmatrixbytes_len a
let crypto_secretkeybytes (a:frodo_alg) : size_pos =
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a
let crypto_ciphertextbytes (a:frodo_alg) : size_pos =
ct1bytes_len a + ct2bytes_len a
val expand_crypto_publickeybytes: a:frodo_alg ->
Lemma (crypto_publickeybytes a == bytes_seed_a + publicmatrixbytes_len a)
let expand_crypto_publickeybytes a = ()
val expand_crypto_secretkeybytes: a:frodo_alg ->
Lemma (crypto_secretkeybytes a ==
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a)
let expand_crypto_secretkeybytes a = ()
val expand_crypto_ciphertextbytes: a:frodo_alg ->
Lemma (crypto_ciphertextbytes a == ct1bytes_len a + ct2bytes_len a)
let expand_crypto_ciphertextbytes a = ()
val params_n_sqr: a:frodo_alg ->
Lemma (params_n a * params_n a <= max_size_t /\ params_n a <= maxint U16)
let params_n_sqr a =
assert (params_n a <= maxint U16);
Math.Lemmas.lemma_mult_lt_sqr (params_n a) (params_n a) (maxint U16);
Math.Lemmas.pow2_plus 16 16
inline_for_extraction noextract
let frodo_shake_st =
inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> outputByteLen:size_nat
-> lbytes outputByteLen
inline_for_extraction
let frodo_shake (a:frodo_alg) : frodo_shake_st =
match a with
| Frodo64 | Frodo640 -> Spec.SHA3.shake128
| Frodo976 | Frodo1344 -> Spec.SHA3.shake256
inline_for_extraction noextract
let frodo_gen_matrix_st =
n:size_nat{n * n <= max_size_t /\ n <= maxint U16 /\ n % 4 = 0}
-> seed:lbytes 16
-> matrix n n
inline_for_extraction
let frodo_gen_matrix (a:frodo_gen_a) : frodo_gen_matrix_st =
match a with
| SHAKE128 -> Spec.Frodo.Gen.frodo_gen_matrix_shake
| AES128 -> Spec.Frodo.Gen.frodo_gen_matrix_aes
(** CDF tables *)
unfold let cdf_list_640: list uint16 =
[ u16 4643; u16 13363; u16 20579; u16 25843; u16 29227; u16 31145; u16 32103; u16 32525;
u16 32689; u16 32745; u16 32762; u16 32766; u16 32767 ]
unfold let cdf_list_976: list uint16 =
[ u16 5638; u16 15915; u16 23689; u16 28571; u16 31116; u16 32217; u16 32613; u16 32731;
u16 32760; u16 32766; u16 32767 ]
unfold let cdf_list_1344: list uint16 =
[ u16 9142; u16 23462; u16 30338; u16 32361; u16 32725; u16 32765; u16 32767 ]
inline_for_extraction
let cdf_table_len (a:frodo_alg) : size_pos =
match a with
| Frodo64 | Frodo640 -> 13
| Frodo976 -> 11
| Frodo1344 -> 7
inline_for_extraction
let cdf_list (a:frodo_alg) : x:list uint16{List.Tot.length x == cdf_table_len a} =
match a with
| Frodo64 | Frodo640 ->
assert_norm (List.Tot.length cdf_list_640 = 13);
cdf_list_640
| Frodo976 ->
assert_norm (List.Tot.length cdf_list_976 = 11);
cdf_list_976
| Frodo1344 ->
assert_norm (List.Tot.length cdf_list_1344 = 7);
cdf_list_1344
inline_for_extraction
let cdf_table (a:frodo_alg) : lseq uint16 (cdf_table_len a) =
createL (cdf_list a)
val lemma_cdf_list_640: i:size_nat{i < List.Tot.length cdf_list_640} ->
Lemma (uint_v (List.Tot.index cdf_list_640 i) < pow2 15)
let lemma_cdf_list_640 i =
assert_norm (List.Tot.length cdf_list_640 = 13);
assert_norm (uint_v (List.Tot.index cdf_list_640 0) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 1) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 2) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 3) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 4) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 5) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 6) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 7) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 8) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 9) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 10) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 11) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 12) < pow2 15)
val lemma_cdf_list_976: i:size_nat{i < List.Tot.length cdf_list_976} ->
Lemma (uint_v (List.Tot.index cdf_list_976 i) < pow2 15)
| false | false |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val lemma_cdf_list_976: i:size_nat{i < List.Tot.length cdf_list_976} ->
Lemma (uint_v (List.Tot.index cdf_list_976 i) < pow2 15)
|
[] |
Spec.Frodo.Params.lemma_cdf_list_976
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
i: Lib.IntTypes.size_nat{i < FStar.List.Tot.Base.length Spec.Frodo.Params.cdf_list_976}
-> FStar.Pervasives.Lemma
(ensures
Lib.IntTypes.uint_v (FStar.List.Tot.Base.index Spec.Frodo.Params.cdf_list_976 i) <
Prims.pow2 15)
|
{
"end_col": 65,
"end_line": 211,
"start_col": 2,
"start_line": 200
}
|
FStar.Pervasives.Lemma
|
val lemma_cdf_list_640: i:size_nat{i < List.Tot.length cdf_list_640} ->
Lemma (uint_v (List.Tot.index cdf_list_640 i) < pow2 15)
|
[
{
"abbrev": false,
"full_module": "Spec.Matrix",
"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.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let lemma_cdf_list_640 i =
assert_norm (List.Tot.length cdf_list_640 = 13);
assert_norm (uint_v (List.Tot.index cdf_list_640 0) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 1) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 2) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 3) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 4) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 5) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 6) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 7) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 8) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 9) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 10) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 11) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 12) < pow2 15)
|
val lemma_cdf_list_640: i:size_nat{i < List.Tot.length cdf_list_640} ->
Lemma (uint_v (List.Tot.index cdf_list_640 i) < pow2 15)
let lemma_cdf_list_640 i =
| false | null | true |
assert_norm (List.Tot.length cdf_list_640 = 13);
assert_norm (uint_v (List.Tot.index cdf_list_640 0) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 1) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 2) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 3) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 4) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 5) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 6) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 7) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 8) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 9) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 10) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 11) < pow2 15);
assert_norm (uint_v (List.Tot.index cdf_list_640 12) < pow2 15)
|
{
"checked_file": "Spec.Frodo.Params.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.Frodo.Gen.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Params.fst"
}
|
[
"lemma"
] |
[
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.List.Tot.Base.length",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U16",
"Lib.IntTypes.SEC",
"Spec.Frodo.Params.cdf_list_640",
"FStar.Pervasives.assert_norm",
"Lib.IntTypes.uint_v",
"FStar.List.Tot.Base.index",
"Prims.pow2",
"Prims.unit",
"Prims.op_Equality",
"Prims.int"
] |
[] |
module Spec.Frodo.Params
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
type frodo_alg =
| Frodo64 (* this variant is used only for testing purposes *)
| Frodo640
| Frodo976
| Frodo1344
type frodo_gen_a =
| SHAKE128
| AES128
let _: squash (inversion frodo_alg) = allow_inversion frodo_alg
let _: squash (inversion frodo_gen_a) = allow_inversion frodo_gen_a
inline_for_extraction
let params_n (a:frodo_alg) : x:size_pos{x % 8 = 0 /\ x <= 1344} =
match a with
| Frodo64 -> 64
| Frodo640 -> 640
| Frodo976 -> 976
| Frodo1344 -> 1344
inline_for_extraction
let params_logq (a:frodo_alg) : x:size_pos{x <= 16} =
match a with
| Frodo64 | Frodo640 -> 15
| Frodo976 | Frodo1344 -> 16
inline_for_extraction
let params_extracted_bits (a:frodo_alg) : x:size_pos{x < params_logq a /\ x <= 8} =
match a with
| Frodo64 | Frodo640 -> 2
| Frodo976 -> 3
| Frodo1344 -> 4
inline_for_extraction
let crypto_bytes (a:frodo_alg) : x:size_pos{x <= 32} =
match a with
| Frodo64 | Frodo640 -> 16
| Frodo976 -> 24
| Frodo1344 -> 32
let params_nbar = 8
let bytes_seed_a = 16
let bytes_pkhash (a:frodo_alg) : size_pos =
crypto_bytes a
let bytes_mu (a:frodo_alg) : size_pos =
params_extracted_bits a * params_nbar * params_nbar / 8
let publicmatrixbytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_n a * params_nbar / 8)
let secretmatrixbytes_len (a:frodo_alg) : size_pos =
2 * params_n a * params_nbar
let ct1bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_n a / 8)
let ct2bytes_len (a:frodo_alg) : size_pos =
params_logq a * (params_nbar * params_nbar / 8)
let crypto_publickeybytes (a:frodo_alg) : size_pos =
bytes_seed_a + publicmatrixbytes_len a
let crypto_secretkeybytes (a:frodo_alg) : size_pos =
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a
let crypto_ciphertextbytes (a:frodo_alg) : size_pos =
ct1bytes_len a + ct2bytes_len a
val expand_crypto_publickeybytes: a:frodo_alg ->
Lemma (crypto_publickeybytes a == bytes_seed_a + publicmatrixbytes_len a)
let expand_crypto_publickeybytes a = ()
val expand_crypto_secretkeybytes: a:frodo_alg ->
Lemma (crypto_secretkeybytes a ==
crypto_bytes a + crypto_publickeybytes a + secretmatrixbytes_len a + bytes_pkhash a)
let expand_crypto_secretkeybytes a = ()
val expand_crypto_ciphertextbytes: a:frodo_alg ->
Lemma (crypto_ciphertextbytes a == ct1bytes_len a + ct2bytes_len a)
let expand_crypto_ciphertextbytes a = ()
val params_n_sqr: a:frodo_alg ->
Lemma (params_n a * params_n a <= max_size_t /\ params_n a <= maxint U16)
let params_n_sqr a =
assert (params_n a <= maxint U16);
Math.Lemmas.lemma_mult_lt_sqr (params_n a) (params_n a) (maxint U16);
Math.Lemmas.pow2_plus 16 16
inline_for_extraction noextract
let frodo_shake_st =
inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> outputByteLen:size_nat
-> lbytes outputByteLen
inline_for_extraction
let frodo_shake (a:frodo_alg) : frodo_shake_st =
match a with
| Frodo64 | Frodo640 -> Spec.SHA3.shake128
| Frodo976 | Frodo1344 -> Spec.SHA3.shake256
inline_for_extraction noextract
let frodo_gen_matrix_st =
n:size_nat{n * n <= max_size_t /\ n <= maxint U16 /\ n % 4 = 0}
-> seed:lbytes 16
-> matrix n n
inline_for_extraction
let frodo_gen_matrix (a:frodo_gen_a) : frodo_gen_matrix_st =
match a with
| SHAKE128 -> Spec.Frodo.Gen.frodo_gen_matrix_shake
| AES128 -> Spec.Frodo.Gen.frodo_gen_matrix_aes
(** CDF tables *)
unfold let cdf_list_640: list uint16 =
[ u16 4643; u16 13363; u16 20579; u16 25843; u16 29227; u16 31145; u16 32103; u16 32525;
u16 32689; u16 32745; u16 32762; u16 32766; u16 32767 ]
unfold let cdf_list_976: list uint16 =
[ u16 5638; u16 15915; u16 23689; u16 28571; u16 31116; u16 32217; u16 32613; u16 32731;
u16 32760; u16 32766; u16 32767 ]
unfold let cdf_list_1344: list uint16 =
[ u16 9142; u16 23462; u16 30338; u16 32361; u16 32725; u16 32765; u16 32767 ]
inline_for_extraction
let cdf_table_len (a:frodo_alg) : size_pos =
match a with
| Frodo64 | Frodo640 -> 13
| Frodo976 -> 11
| Frodo1344 -> 7
inline_for_extraction
let cdf_list (a:frodo_alg) : x:list uint16{List.Tot.length x == cdf_table_len a} =
match a with
| Frodo64 | Frodo640 ->
assert_norm (List.Tot.length cdf_list_640 = 13);
cdf_list_640
| Frodo976 ->
assert_norm (List.Tot.length cdf_list_976 = 11);
cdf_list_976
| Frodo1344 ->
assert_norm (List.Tot.length cdf_list_1344 = 7);
cdf_list_1344
inline_for_extraction
let cdf_table (a:frodo_alg) : lseq uint16 (cdf_table_len a) =
createL (cdf_list a)
val lemma_cdf_list_640: i:size_nat{i < List.Tot.length cdf_list_640} ->
Lemma (uint_v (List.Tot.index cdf_list_640 i) < pow2 15)
| false | false |
Spec.Frodo.Params.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val lemma_cdf_list_640: i:size_nat{i < List.Tot.length cdf_list_640} ->
Lemma (uint_v (List.Tot.index cdf_list_640 i) < pow2 15)
|
[] |
Spec.Frodo.Params.lemma_cdf_list_640
|
{
"file_name": "specs/frodo/Spec.Frodo.Params.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
i: Lib.IntTypes.size_nat{i < FStar.List.Tot.Base.length Spec.Frodo.Params.cdf_list_640}
-> FStar.Pervasives.Lemma
(ensures
Lib.IntTypes.uint_v (FStar.List.Tot.Base.index Spec.Frodo.Params.cdf_list_640 i) <
Prims.pow2 15)
|
{
"end_col": 65,
"end_line": 194,
"start_col": 2,
"start_line": 181
}
|
Prims.Tot
|
val flag_of (f:flags_t) : nat1
|
[
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.Defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.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
}
] | false |
let flag_of f = bool_to_nat1 (overflow f)
|
val flag_of (f:flags_t) : nat1
let flag_of f =
| false | null | false |
bool_to_nat1 (overflow f)
|
{
"checked_file": "Vale.Bignum.X64.fst.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Bignum.Defs.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Bignum.X64.fst"
}
|
[
"total"
] |
[
"Vale.Bignum.X64.flags_t",
"Vale.Bignum.X64.bool_to_nat1",
"Vale.X64.Decls.overflow",
"Vale.Def.Words_s.nat1"
] |
[] |
module Vale.Bignum.X64
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
open Vale.Bignum.Defs
open FStar.Mul
open FStar.Seq
open Vale.Def.Words_s
let bool_to_nat1 (b:bool) : nat1 = if b then 1 else 0
| false | true |
Vale.Bignum.X64.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val flag_of (f:flags_t) : nat1
|
[] |
Vale.Bignum.X64.flag_of
|
{
"file_name": "obj/Vale.Bignum.X64.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
f: Vale.Bignum.X64.flags_t -> Vale.Def.Words_s.nat1
|
{
"end_col": 41,
"end_line": 22,
"start_col": 16,
"start_line": 22
}
|
Prims.Tot
|
val flag_cf (f:flags_t) : nat1
|
[
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.Defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.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
}
] | false |
let flag_cf f = bool_to_nat1 (cf f)
|
val flag_cf (f:flags_t) : nat1
let flag_cf f =
| false | null | false |
bool_to_nat1 (cf f)
|
{
"checked_file": "Vale.Bignum.X64.fst.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Bignum.Defs.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Bignum.X64.fst"
}
|
[
"total"
] |
[
"Vale.Bignum.X64.flags_t",
"Vale.Bignum.X64.bool_to_nat1",
"Vale.X64.Decls.cf",
"Vale.Def.Words_s.nat1"
] |
[] |
module Vale.Bignum.X64
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
open Vale.Bignum.Defs
open FStar.Mul
open FStar.Seq
open Vale.Def.Words_s
| false | true |
Vale.Bignum.X64.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val flag_cf (f:flags_t) : nat1
|
[] |
Vale.Bignum.X64.flag_cf
|
{
"file_name": "obj/Vale.Bignum.X64.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
f: Vale.Bignum.X64.flags_t -> Vale.Def.Words_s.nat1
|
{
"end_col": 35,
"end_line": 21,
"start_col": 16,
"start_line": 21
}
|
Prims.Tot
|
val va_code_Adcx_64 : dst:va_operand_dst_opr64 -> src:va_operand_opr64 -> Tot va_code
|
[
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.Defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.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
}
] | false |
let va_code_Adcx_64 dst src =
(va_Block (va_CCons (va_code_Adcx64Wrap dst src) (va_CNil ())))
|
val va_code_Adcx_64 : dst:va_operand_dst_opr64 -> src:va_operand_opr64 -> Tot va_code
let va_code_Adcx_64 dst src =
| false | null | false |
(va_Block (va_CCons (va_code_Adcx64Wrap dst src) (va_CNil ())))
|
{
"checked_file": "Vale.Bignum.X64.fst.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Bignum.Defs.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Bignum.X64.fst"
}
|
[
"total"
] |
[
"Vale.X64.Decls.va_operand_dst_opr64",
"Vale.X64.Decls.va_operand_opr64",
"Vale.X64.Decls.va_Block",
"Vale.X64.Decls.va_CCons",
"Vale.X64.InsBasic.va_code_Adcx64Wrap",
"Vale.X64.Decls.va_CNil",
"Vale.X64.Decls.va_code"
] |
[] |
module Vale.Bignum.X64
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
open Vale.Bignum.Defs
open FStar.Mul
open FStar.Seq
open Vale.Def.Words_s
let bool_to_nat1 (b:bool) : nat1 = if b then 1 else 0
let flag_cf f = bool_to_nat1 (cf f)
let flag_of f = bool_to_nat1 (overflow f)
//-- reveal_flags
let reveal_flags f =
()
//--
//-- lemma_add_hi_lo64
let lemma_add_hi_lo64 dummy =
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
()
//--
//-- Adcx_64
[@ "opaque_to_smt"]
| false | true |
Vale.Bignum.X64.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val va_code_Adcx_64 : dst:va_operand_dst_opr64 -> src:va_operand_opr64 -> Tot va_code
|
[] |
Vale.Bignum.X64.va_code_Adcx_64
|
{
"file_name": "obj/Vale.Bignum.X64.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
dst: Vale.X64.Decls.va_operand_dst_opr64 -> src: Vale.X64.Decls.va_operand_opr64
-> Vale.X64.Decls.va_code
|
{
"end_col": 65,
"end_line": 39,
"start_col": 2,
"start_line": 39
}
|
Prims.Tot
|
val va_code_Adox_64 : dst:va_operand_dst_opr64 -> src:va_operand_opr64 -> Tot va_code
|
[
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.Defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.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
}
] | false |
let va_code_Adox_64 dst src =
(va_Block (va_CCons (va_code_Adox64Wrap dst src) (va_CNil ())))
|
val va_code_Adox_64 : dst:va_operand_dst_opr64 -> src:va_operand_opr64 -> Tot va_code
let va_code_Adox_64 dst src =
| false | null | false |
(va_Block (va_CCons (va_code_Adox64Wrap dst src) (va_CNil ())))
|
{
"checked_file": "Vale.Bignum.X64.fst.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Bignum.Defs.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Bignum.X64.fst"
}
|
[
"total"
] |
[
"Vale.X64.Decls.va_operand_dst_opr64",
"Vale.X64.Decls.va_operand_opr64",
"Vale.X64.Decls.va_Block",
"Vale.X64.Decls.va_CCons",
"Vale.X64.InsBasic.va_code_Adox64Wrap",
"Vale.X64.Decls.va_CNil",
"Vale.X64.Decls.va_code"
] |
[] |
module Vale.Bignum.X64
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
open Vale.Bignum.Defs
open FStar.Mul
open FStar.Seq
open Vale.Def.Words_s
let bool_to_nat1 (b:bool) : nat1 = if b then 1 else 0
let flag_cf f = bool_to_nat1 (cf f)
let flag_of f = bool_to_nat1 (overflow f)
//-- reveal_flags
let reveal_flags f =
()
//--
//-- lemma_add_hi_lo64
let lemma_add_hi_lo64 dummy =
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
()
//--
//-- Adcx_64
[@ "opaque_to_smt"]
let va_code_Adcx_64 dst src =
(va_Block (va_CCons (va_code_Adcx64Wrap dst src) (va_CNil ())))
[@ "opaque_to_smt"]
let va_codegen_success_Adcx_64 dst src =
(va_pbool_and (va_codegen_success_Adcx64Wrap dst src) (va_ttrue ()))
[@"opaque_to_smt"]
let va_lemma_Adcx_64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Adcx_64) (va_code_Adcx_64 dst src);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
let (va_s4, va_fc4) = va_lemma_Adcx64Wrap (va_hd va_b1) va_s0 dst src in
let va_b4 = va_tl va_b1 in
let (va_sM, va_f4) = va_lemma_empty_total va_s4 va_b4 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc4 va_s4 va_f4 va_sM in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Adcx_64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Adcx_64 (va_code_Adcx_64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_dst_opr64
dst va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_dst_opr64 dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Adox_64
[@ "opaque_to_smt"]
| false | true |
Vale.Bignum.X64.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val va_code_Adox_64 : dst:va_operand_dst_opr64 -> src:va_operand_opr64 -> Tot va_code
|
[] |
Vale.Bignum.X64.va_code_Adox_64
|
{
"file_name": "obj/Vale.Bignum.X64.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
dst: Vale.X64.Decls.va_operand_dst_opr64 -> src: Vale.X64.Decls.va_operand_opr64
-> Vale.X64.Decls.va_code
|
{
"end_col": 65,
"end_line": 74,
"start_col": 2,
"start_line": 74
}
|
Prims.Tot
|
val va_codegen_success_Mulx_64 : dst_hi:va_operand_dst_opr64 -> dst_lo:va_operand_dst_opr64 ->
src:va_operand_opr64 -> Tot va_pbool
|
[
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.Defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.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
}
] | false |
let va_codegen_success_Mulx_64 dst_hi dst_lo src =
(va_pbool_and (va_codegen_success_Mulx64 dst_hi dst_lo src) (va_ttrue ()))
|
val va_codegen_success_Mulx_64 : dst_hi:va_operand_dst_opr64 -> dst_lo:va_operand_dst_opr64 ->
src:va_operand_opr64 -> Tot va_pbool
let va_codegen_success_Mulx_64 dst_hi dst_lo src =
| false | null | false |
(va_pbool_and (va_codegen_success_Mulx64 dst_hi dst_lo src) (va_ttrue ()))
|
{
"checked_file": "Vale.Bignum.X64.fst.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Bignum.Defs.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Bignum.X64.fst"
}
|
[
"total"
] |
[
"Vale.X64.Decls.va_operand_dst_opr64",
"Vale.X64.Decls.va_operand_opr64",
"Vale.X64.Decls.va_pbool_and",
"Vale.X64.InsBasic.va_codegen_success_Mulx64",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] |
[] |
module Vale.Bignum.X64
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
open Vale.Bignum.Defs
open FStar.Mul
open FStar.Seq
open Vale.Def.Words_s
let bool_to_nat1 (b:bool) : nat1 = if b then 1 else 0
let flag_cf f = bool_to_nat1 (cf f)
let flag_of f = bool_to_nat1 (overflow f)
//-- reveal_flags
let reveal_flags f =
()
//--
//-- lemma_add_hi_lo64
let lemma_add_hi_lo64 dummy =
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
()
//--
//-- Adcx_64
[@ "opaque_to_smt"]
let va_code_Adcx_64 dst src =
(va_Block (va_CCons (va_code_Adcx64Wrap dst src) (va_CNil ())))
[@ "opaque_to_smt"]
let va_codegen_success_Adcx_64 dst src =
(va_pbool_and (va_codegen_success_Adcx64Wrap dst src) (va_ttrue ()))
[@"opaque_to_smt"]
let va_lemma_Adcx_64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Adcx_64) (va_code_Adcx_64 dst src);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
let (va_s4, va_fc4) = va_lemma_Adcx64Wrap (va_hd va_b1) va_s0 dst src in
let va_b4 = va_tl va_b1 in
let (va_sM, va_f4) = va_lemma_empty_total va_s4 va_b4 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc4 va_s4 va_f4 va_sM in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Adcx_64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Adcx_64 (va_code_Adcx_64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_dst_opr64
dst va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_dst_opr64 dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Adox_64
[@ "opaque_to_smt"]
let va_code_Adox_64 dst src =
(va_Block (va_CCons (va_code_Adox64Wrap dst src) (va_CNil ())))
[@ "opaque_to_smt"]
let va_codegen_success_Adox_64 dst src =
(va_pbool_and (va_codegen_success_Adox64Wrap dst src) (va_ttrue ()))
[@"opaque_to_smt"]
let va_lemma_Adox_64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Adox_64) (va_code_Adox_64 dst src);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
let (va_s4, va_fc4) = va_lemma_Adox64Wrap (va_hd va_b1) va_s0 dst src in
let va_b4 = va_tl va_b1 in
let (va_sM, va_f4) = va_lemma_empty_total va_s4 va_b4 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc4 va_s4 va_f4 va_sM in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Adox_64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Adox_64 (va_code_Adox_64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_dst_opr64
dst va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_dst_opr64 dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Mulx_64
[@ "opaque_to_smt"]
let va_code_Mulx_64 dst_hi dst_lo src =
(va_Block (va_CCons (va_code_Mulx64 dst_hi dst_lo src) (va_CNil ())))
[@ "opaque_to_smt"]
| false | true |
Vale.Bignum.X64.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val va_codegen_success_Mulx_64 : dst_hi:va_operand_dst_opr64 -> dst_lo:va_operand_dst_opr64 ->
src:va_operand_opr64 -> Tot va_pbool
|
[] |
Vale.Bignum.X64.va_codegen_success_Mulx_64
|
{
"file_name": "obj/Vale.Bignum.X64.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
dst_hi: Vale.X64.Decls.va_operand_dst_opr64 ->
dst_lo: Vale.X64.Decls.va_operand_dst_opr64 ->
src: Vale.X64.Decls.va_operand_opr64
-> Vale.X64.Decls.va_pbool
|
{
"end_col": 76,
"end_line": 113,
"start_col": 2,
"start_line": 113
}
|
Prims.Tot
|
val bool_to_nat1 (b: bool) : nat1
|
[
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.Defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.Defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.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
}
] | false |
let bool_to_nat1 (b:bool) : nat1 = if b then 1 else 0
|
val bool_to_nat1 (b: bool) : nat1
let bool_to_nat1 (b: bool) : nat1 =
| false | null | false |
if b then 1 else 0
|
{
"checked_file": "Vale.Bignum.X64.fst.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Bignum.Defs.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Bignum.X64.fst"
}
|
[
"total"
] |
[
"Prims.bool",
"Vale.Def.Words_s.nat1"
] |
[] |
module Vale.Bignum.X64
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
open Vale.Bignum.Defs
open FStar.Mul
open FStar.Seq
| false | true |
Vale.Bignum.X64.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val bool_to_nat1 (b: bool) : nat1
|
[] |
Vale.Bignum.X64.bool_to_nat1
|
{
"file_name": "obj/Vale.Bignum.X64.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
b: Prims.bool -> Vale.Def.Words_s.nat1
|
{
"end_col": 53,
"end_line": 20,
"start_col": 35,
"start_line": 20
}
|
Prims.Tot
|
val va_codegen_success_Adox_64 : dst:va_operand_dst_opr64 -> src:va_operand_opr64 -> Tot va_pbool
|
[
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.Defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.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
}
] | false |
let va_codegen_success_Adox_64 dst src =
(va_pbool_and (va_codegen_success_Adox64Wrap dst src) (va_ttrue ()))
|
val va_codegen_success_Adox_64 : dst:va_operand_dst_opr64 -> src:va_operand_opr64 -> Tot va_pbool
let va_codegen_success_Adox_64 dst src =
| false | null | false |
(va_pbool_and (va_codegen_success_Adox64Wrap dst src) (va_ttrue ()))
|
{
"checked_file": "Vale.Bignum.X64.fst.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Bignum.Defs.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Bignum.X64.fst"
}
|
[
"total"
] |
[
"Vale.X64.Decls.va_operand_dst_opr64",
"Vale.X64.Decls.va_operand_opr64",
"Vale.X64.Decls.va_pbool_and",
"Vale.X64.InsBasic.va_codegen_success_Adox64Wrap",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] |
[] |
module Vale.Bignum.X64
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
open Vale.Bignum.Defs
open FStar.Mul
open FStar.Seq
open Vale.Def.Words_s
let bool_to_nat1 (b:bool) : nat1 = if b then 1 else 0
let flag_cf f = bool_to_nat1 (cf f)
let flag_of f = bool_to_nat1 (overflow f)
//-- reveal_flags
let reveal_flags f =
()
//--
//-- lemma_add_hi_lo64
let lemma_add_hi_lo64 dummy =
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
()
//--
//-- Adcx_64
[@ "opaque_to_smt"]
let va_code_Adcx_64 dst src =
(va_Block (va_CCons (va_code_Adcx64Wrap dst src) (va_CNil ())))
[@ "opaque_to_smt"]
let va_codegen_success_Adcx_64 dst src =
(va_pbool_and (va_codegen_success_Adcx64Wrap dst src) (va_ttrue ()))
[@"opaque_to_smt"]
let va_lemma_Adcx_64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Adcx_64) (va_code_Adcx_64 dst src);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
let (va_s4, va_fc4) = va_lemma_Adcx64Wrap (va_hd va_b1) va_s0 dst src in
let va_b4 = va_tl va_b1 in
let (va_sM, va_f4) = va_lemma_empty_total va_s4 va_b4 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc4 va_s4 va_f4 va_sM in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Adcx_64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Adcx_64 (va_code_Adcx_64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_dst_opr64
dst va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_dst_opr64 dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Adox_64
[@ "opaque_to_smt"]
let va_code_Adox_64 dst src =
(va_Block (va_CCons (va_code_Adox64Wrap dst src) (va_CNil ())))
[@ "opaque_to_smt"]
| false | true |
Vale.Bignum.X64.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val va_codegen_success_Adox_64 : dst:va_operand_dst_opr64 -> src:va_operand_opr64 -> Tot va_pbool
|
[] |
Vale.Bignum.X64.va_codegen_success_Adox_64
|
{
"file_name": "obj/Vale.Bignum.X64.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
dst: Vale.X64.Decls.va_operand_dst_opr64 -> src: Vale.X64.Decls.va_operand_opr64
-> Vale.X64.Decls.va_pbool
|
{
"end_col": 70,
"end_line": 78,
"start_col": 2,
"start_line": 78
}
|
Prims.Tot
|
val va_codegen_success_Adcx_64 : dst:va_operand_dst_opr64 -> src:va_operand_opr64 -> Tot va_pbool
|
[
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.Defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.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
}
] | false |
let va_codegen_success_Adcx_64 dst src =
(va_pbool_and (va_codegen_success_Adcx64Wrap dst src) (va_ttrue ()))
|
val va_codegen_success_Adcx_64 : dst:va_operand_dst_opr64 -> src:va_operand_opr64 -> Tot va_pbool
let va_codegen_success_Adcx_64 dst src =
| false | null | false |
(va_pbool_and (va_codegen_success_Adcx64Wrap dst src) (va_ttrue ()))
|
{
"checked_file": "Vale.Bignum.X64.fst.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Bignum.Defs.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Bignum.X64.fst"
}
|
[
"total"
] |
[
"Vale.X64.Decls.va_operand_dst_opr64",
"Vale.X64.Decls.va_operand_opr64",
"Vale.X64.Decls.va_pbool_and",
"Vale.X64.InsBasic.va_codegen_success_Adcx64Wrap",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] |
[] |
module Vale.Bignum.X64
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
open Vale.Bignum.Defs
open FStar.Mul
open FStar.Seq
open Vale.Def.Words_s
let bool_to_nat1 (b:bool) : nat1 = if b then 1 else 0
let flag_cf f = bool_to_nat1 (cf f)
let flag_of f = bool_to_nat1 (overflow f)
//-- reveal_flags
let reveal_flags f =
()
//--
//-- lemma_add_hi_lo64
let lemma_add_hi_lo64 dummy =
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
()
//--
//-- Adcx_64
[@ "opaque_to_smt"]
let va_code_Adcx_64 dst src =
(va_Block (va_CCons (va_code_Adcx64Wrap dst src) (va_CNil ())))
[@ "opaque_to_smt"]
| false | true |
Vale.Bignum.X64.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val va_codegen_success_Adcx_64 : dst:va_operand_dst_opr64 -> src:va_operand_opr64 -> Tot va_pbool
|
[] |
Vale.Bignum.X64.va_codegen_success_Adcx_64
|
{
"file_name": "obj/Vale.Bignum.X64.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
dst: Vale.X64.Decls.va_operand_dst_opr64 -> src: Vale.X64.Decls.va_operand_opr64
-> Vale.X64.Decls.va_pbool
|
{
"end_col": 70,
"end_line": 43,
"start_col": 2,
"start_line": 43
}
|
Prims.Tot
|
val va_code_Mulx_64 : dst_hi:va_operand_dst_opr64 -> dst_lo:va_operand_dst_opr64 ->
src:va_operand_opr64 -> Tot va_code
|
[
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.Defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.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
}
] | false |
let va_code_Mulx_64 dst_hi dst_lo src =
(va_Block (va_CCons (va_code_Mulx64 dst_hi dst_lo src) (va_CNil ())))
|
val va_code_Mulx_64 : dst_hi:va_operand_dst_opr64 -> dst_lo:va_operand_dst_opr64 ->
src:va_operand_opr64 -> Tot va_code
let va_code_Mulx_64 dst_hi dst_lo src =
| false | null | false |
(va_Block (va_CCons (va_code_Mulx64 dst_hi dst_lo src) (va_CNil ())))
|
{
"checked_file": "Vale.Bignum.X64.fst.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Bignum.Defs.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Bignum.X64.fst"
}
|
[
"total"
] |
[
"Vale.X64.Decls.va_operand_dst_opr64",
"Vale.X64.Decls.va_operand_opr64",
"Vale.X64.Decls.va_Block",
"Vale.X64.Decls.va_CCons",
"Vale.X64.InsBasic.va_code_Mulx64",
"Vale.X64.Decls.va_CNil",
"Vale.X64.Decls.va_code"
] |
[] |
module Vale.Bignum.X64
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
open Vale.Bignum.Defs
open FStar.Mul
open FStar.Seq
open Vale.Def.Words_s
let bool_to_nat1 (b:bool) : nat1 = if b then 1 else 0
let flag_cf f = bool_to_nat1 (cf f)
let flag_of f = bool_to_nat1 (overflow f)
//-- reveal_flags
let reveal_flags f =
()
//--
//-- lemma_add_hi_lo64
let lemma_add_hi_lo64 dummy =
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
()
//--
//-- Adcx_64
[@ "opaque_to_smt"]
let va_code_Adcx_64 dst src =
(va_Block (va_CCons (va_code_Adcx64Wrap dst src) (va_CNil ())))
[@ "opaque_to_smt"]
let va_codegen_success_Adcx_64 dst src =
(va_pbool_and (va_codegen_success_Adcx64Wrap dst src) (va_ttrue ()))
[@"opaque_to_smt"]
let va_lemma_Adcx_64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Adcx_64) (va_code_Adcx_64 dst src);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
let (va_s4, va_fc4) = va_lemma_Adcx64Wrap (va_hd va_b1) va_s0 dst src in
let va_b4 = va_tl va_b1 in
let (va_sM, va_f4) = va_lemma_empty_total va_s4 va_b4 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc4 va_s4 va_f4 va_sM in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Adcx_64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Adcx_64 (va_code_Adcx_64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_dst_opr64
dst va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_dst_opr64 dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Adox_64
[@ "opaque_to_smt"]
let va_code_Adox_64 dst src =
(va_Block (va_CCons (va_code_Adox64Wrap dst src) (va_CNil ())))
[@ "opaque_to_smt"]
let va_codegen_success_Adox_64 dst src =
(va_pbool_and (va_codegen_success_Adox64Wrap dst src) (va_ttrue ()))
[@"opaque_to_smt"]
let va_lemma_Adox_64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Adox_64) (va_code_Adox_64 dst src);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
let (va_s4, va_fc4) = va_lemma_Adox64Wrap (va_hd va_b1) va_s0 dst src in
let va_b4 = va_tl va_b1 in
let (va_sM, va_f4) = va_lemma_empty_total va_s4 va_b4 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc4 va_s4 va_f4 va_sM in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Adox_64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Adox_64 (va_code_Adox_64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_dst_opr64
dst va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_dst_opr64 dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Mulx_64
[@ "opaque_to_smt"]
| false | true |
Vale.Bignum.X64.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val va_code_Mulx_64 : dst_hi:va_operand_dst_opr64 -> dst_lo:va_operand_dst_opr64 ->
src:va_operand_opr64 -> Tot va_code
|
[] |
Vale.Bignum.X64.va_code_Mulx_64
|
{
"file_name": "obj/Vale.Bignum.X64.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
dst_hi: Vale.X64.Decls.va_operand_dst_opr64 ->
dst_lo: Vale.X64.Decls.va_operand_dst_opr64 ->
src: Vale.X64.Decls.va_operand_opr64
-> Vale.X64.Decls.va_code
|
{
"end_col": 71,
"end_line": 109,
"start_col": 2,
"start_line": 109
}
|
FStar.Pervasives.Lemma
|
val lemma_add_hi_lo64 : dummy:int
-> Lemma
(requires true)
(ensures (forall (a:nat64) (b:nat64) (c:nat1) . {:pattern(add_lo a b c); (add_hi a b
c)}Vale.Bignum.Defs.add_lo a b c + va_mul_nat pow2_64 (Vale.Bignum.Defs.add_hi a b c) == a + b
+ c))
|
[
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.Defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.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
}
] | false |
let lemma_add_hi_lo64 dummy =
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
()
|
val lemma_add_hi_lo64 : dummy:int
-> Lemma
(requires true)
(ensures (forall (a:nat64) (b:nat64) (c:nat1) . {:pattern(add_lo a b c); (add_hi a b
c)}Vale.Bignum.Defs.add_lo a b c + va_mul_nat pow2_64 (Vale.Bignum.Defs.add_hi a b c) == a + b
+ c))
let lemma_add_hi_lo64 dummy =
| false | null | true |
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
()
|
{
"checked_file": "Vale.Bignum.X64.fst.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Bignum.Defs.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Bignum.X64.fst"
}
|
[
"lemma"
] |
[
"Prims.int",
"Prims.unit",
"Vale.Bignum.Defs.reveal_add_lo_all",
"Vale.Bignum.Defs.reveal_add_hi_all"
] |
[] |
module Vale.Bignum.X64
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
open Vale.Bignum.Defs
open FStar.Mul
open FStar.Seq
open Vale.Def.Words_s
let bool_to_nat1 (b:bool) : nat1 = if b then 1 else 0
let flag_cf f = bool_to_nat1 (cf f)
let flag_of f = bool_to_nat1 (overflow f)
//-- reveal_flags
let reveal_flags f =
()
//--
//-- lemma_add_hi_lo64
| false | false |
Vale.Bignum.X64.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val lemma_add_hi_lo64 : dummy:int
-> Lemma
(requires true)
(ensures (forall (a:nat64) (b:nat64) (c:nat1) . {:pattern(add_lo a b c); (add_hi a b
c)}Vale.Bignum.Defs.add_lo a b c + va_mul_nat pow2_64 (Vale.Bignum.Defs.add_hi a b c) == a + b
+ c))
|
[] |
Vale.Bignum.X64.lemma_add_hi_lo64
|
{
"file_name": "obj/Vale.Bignum.X64.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
dummy: Prims.int
-> FStar.Pervasives.Lemma (requires true)
(ensures
forall (a: Vale.Def.Words_s.nat64) (b: Vale.Def.Words_s.nat64) (c: Vale.Def.Words_s.nat1).
{:pattern Vale.Bignum.Defs.add_lo a b c; Vale.Bignum.Defs.add_hi a b c}
Vale.Bignum.Defs.add_lo a b c +
Vale.X64.Decls.va_mul_nat Vale.Def.Words_s.pow2_64 (Vale.Bignum.Defs.add_hi a b c) ==
a + b + c)
|
{
"end_col": 4,
"end_line": 33,
"start_col": 2,
"start_line": 31
}
|
Prims.Ghost
|
val va_wpProof_Adox_64 : dst:va_operand_dst_opr64 -> src:va_operand_opr64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Adox_64 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Adox_64 dst src) ([va_Mod_flags;
va_mod_dst_opr64 dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
|
[
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.Defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.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
}
] | false |
let va_wpProof_Adox_64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Adox_64 (va_code_Adox_64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_dst_opr64
dst va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_dst_opr64 dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
|
val va_wpProof_Adox_64 : dst:va_operand_dst_opr64 -> src:va_operand_opr64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Adox_64 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Adox_64 dst src) ([va_Mod_flags;
va_mod_dst_opr64 dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
let va_wpProof_Adox_64 dst src va_s0 va_k =
| false | null | false |
let va_sM, va_f0 = va_lemma_Adox_64 (va_code_Adox_64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM
(va_update_flags va_sM (va_update_ok va_sM (va_update_operand_dst_opr64 dst va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_dst_opr64 dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
|
{
"checked_file": "Vale.Bignum.X64.fst.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Bignum.Defs.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Bignum.X64.fst"
}
|
[] |
[
"Vale.X64.Decls.va_operand_dst_opr64",
"Vale.X64.Decls.va_operand_opr64",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_dst_opr64",
"Prims.Nil",
"Prims._assert",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_flags",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_operand_dst_opr64",
"Vale.X64.Decls.va_lemma_upd_update",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.Bignum.X64.va_lemma_Adox_64",
"Vale.Bignum.X64.va_code_Adox_64"
] |
[] |
module Vale.Bignum.X64
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
open Vale.Bignum.Defs
open FStar.Mul
open FStar.Seq
open Vale.Def.Words_s
let bool_to_nat1 (b:bool) : nat1 = if b then 1 else 0
let flag_cf f = bool_to_nat1 (cf f)
let flag_of f = bool_to_nat1 (overflow f)
//-- reveal_flags
let reveal_flags f =
()
//--
//-- lemma_add_hi_lo64
let lemma_add_hi_lo64 dummy =
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
()
//--
//-- Adcx_64
[@ "opaque_to_smt"]
let va_code_Adcx_64 dst src =
(va_Block (va_CCons (va_code_Adcx64Wrap dst src) (va_CNil ())))
[@ "opaque_to_smt"]
let va_codegen_success_Adcx_64 dst src =
(va_pbool_and (va_codegen_success_Adcx64Wrap dst src) (va_ttrue ()))
[@"opaque_to_smt"]
let va_lemma_Adcx_64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Adcx_64) (va_code_Adcx_64 dst src);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
let (va_s4, va_fc4) = va_lemma_Adcx64Wrap (va_hd va_b1) va_s0 dst src in
let va_b4 = va_tl va_b1 in
let (va_sM, va_f4) = va_lemma_empty_total va_s4 va_b4 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc4 va_s4 va_f4 va_sM in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Adcx_64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Adcx_64 (va_code_Adcx_64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_dst_opr64
dst va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_dst_opr64 dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Adox_64
[@ "opaque_to_smt"]
let va_code_Adox_64 dst src =
(va_Block (va_CCons (va_code_Adox64Wrap dst src) (va_CNil ())))
[@ "opaque_to_smt"]
let va_codegen_success_Adox_64 dst src =
(va_pbool_and (va_codegen_success_Adox64Wrap dst src) (va_ttrue ()))
[@"opaque_to_smt"]
let va_lemma_Adox_64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Adox_64) (va_code_Adox_64 dst src);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
let (va_s4, va_fc4) = va_lemma_Adox64Wrap (va_hd va_b1) va_s0 dst src in
let va_b4 = va_tl va_b1 in
let (va_sM, va_f4) = va_lemma_empty_total va_s4 va_b4 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc4 va_s4 va_f4 va_sM in
(va_sM, va_fM)
| false | false |
Vale.Bignum.X64.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val va_wpProof_Adox_64 : dst:va_operand_dst_opr64 -> src:va_operand_opr64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Adox_64 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Adox_64 dst src) ([va_Mod_flags;
va_mod_dst_opr64 dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
|
[] |
Vale.Bignum.X64.va_wpProof_Adox_64
|
{
"file_name": "obj/Vale.Bignum.X64.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
dst: Vale.X64.Decls.va_operand_dst_opr64 ->
src: Vale.X64.Decls.va_operand_opr64 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) * Prims.unit)
|
{
"end_col": 22,
"end_line": 102,
"start_col": 43,
"start_line": 95
}
|
Prims.Ghost
|
val va_lemma_Mulx_64 : va_b0:va_code -> va_s0:va_state -> dst_hi:va_operand_dst_opr64 ->
dst_lo:va_operand_dst_opr64 -> src:va_operand_opr64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mulx_64 dst_hi dst_lo src) va_s0 /\
va_is_dst_dst_opr64 dst_hi va_s0 /\ va_is_dst_dst_opr64 dst_lo va_s0 /\ va_is_src_opr64 src
va_s0 /\ va_get_ok va_s0 /\ bmi2_enabled /\ dst_hi =!= dst_lo))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_dst_opr64 va_sM dst_hi == Vale.Bignum.Defs.mul_hi (va_get_reg64 rRdx va_s0)
(va_eval_opr64 va_s0 src) /\ va_eval_dst_opr64 va_sM dst_lo == Vale.Bignum.Defs.mul_lo
(va_get_reg64 rRdx va_s0) (va_eval_opr64 va_s0 src) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_dst_opr64 dst_lo va_sM (va_update_operand_dst_opr64 dst_hi va_sM va_s0)))))
|
[
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.Defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.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
}
] | false |
let va_lemma_Mulx_64 va_b0 va_s0 dst_hi dst_lo src =
va_reveal_opaque (`%va_code_Mulx_64) (va_code_Mulx_64 dst_hi dst_lo src);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
Vale.Bignum.Defs.reveal_mul_hi_all ();
Vale.Bignum.Defs.reveal_mul_lo_all ();
let (va_s4, va_fc4) = va_lemma_Mulx64 (va_hd va_b1) va_s0 dst_hi dst_lo src in
let va_b4 = va_tl va_b1 in
let (va_sM, va_f4) = va_lemma_empty_total va_s4 va_b4 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc4 va_s4 va_f4 va_sM in
(va_sM, va_fM)
|
val va_lemma_Mulx_64 : va_b0:va_code -> va_s0:va_state -> dst_hi:va_operand_dst_opr64 ->
dst_lo:va_operand_dst_opr64 -> src:va_operand_opr64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mulx_64 dst_hi dst_lo src) va_s0 /\
va_is_dst_dst_opr64 dst_hi va_s0 /\ va_is_dst_dst_opr64 dst_lo va_s0 /\ va_is_src_opr64 src
va_s0 /\ va_get_ok va_s0 /\ bmi2_enabled /\ dst_hi =!= dst_lo))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_dst_opr64 va_sM dst_hi == Vale.Bignum.Defs.mul_hi (va_get_reg64 rRdx va_s0)
(va_eval_opr64 va_s0 src) /\ va_eval_dst_opr64 va_sM dst_lo == Vale.Bignum.Defs.mul_lo
(va_get_reg64 rRdx va_s0) (va_eval_opr64 va_s0 src) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_dst_opr64 dst_lo va_sM (va_update_operand_dst_opr64 dst_hi va_sM va_s0)))))
let va_lemma_Mulx_64 va_b0 va_s0 dst_hi dst_lo src =
| false | null | false |
va_reveal_opaque (`%va_code_Mulx_64) (va_code_Mulx_64 dst_hi dst_lo src);
let va_old_s:va_state = va_s0 in
let va_b1:va_codes = va_get_block va_b0 in
Vale.Bignum.Defs.reveal_mul_hi_all ();
Vale.Bignum.Defs.reveal_mul_lo_all ();
let va_s4, va_fc4 = va_lemma_Mulx64 (va_hd va_b1) va_s0 dst_hi dst_lo src in
let va_b4 = va_tl va_b1 in
let va_sM, va_f4 = va_lemma_empty_total va_s4 va_b4 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc4 va_s4 va_f4 va_sM in
(va_sM, va_fM)
|
{
"checked_file": "Vale.Bignum.X64.fst.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Bignum.Defs.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Bignum.X64.fst"
}
|
[] |
[
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_operand_dst_opr64",
"Vale.X64.Decls.va_operand_opr64",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Decls.va_lemma_merge_total",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_lemma_empty_total",
"Prims.list",
"Vale.X64.Machine_s.precode",
"Vale.X64.Decls.ins",
"Vale.X64.Decls.ocmp",
"Vale.X64.Decls.va_tl",
"Vale.X64.InsBasic.va_lemma_Mulx64",
"Vale.X64.Decls.va_hd",
"Prims.unit",
"Vale.Bignum.Defs.reveal_mul_lo_all",
"Vale.Bignum.Defs.reveal_mul_hi_all",
"Vale.X64.Decls.va_get_block",
"Vale.X64.Decls.va_reveal_opaque",
"Vale.Bignum.X64.va_code_Mulx_64"
] |
[] |
module Vale.Bignum.X64
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
open Vale.Bignum.Defs
open FStar.Mul
open FStar.Seq
open Vale.Def.Words_s
let bool_to_nat1 (b:bool) : nat1 = if b then 1 else 0
let flag_cf f = bool_to_nat1 (cf f)
let flag_of f = bool_to_nat1 (overflow f)
//-- reveal_flags
let reveal_flags f =
()
//--
//-- lemma_add_hi_lo64
let lemma_add_hi_lo64 dummy =
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
()
//--
//-- Adcx_64
[@ "opaque_to_smt"]
let va_code_Adcx_64 dst src =
(va_Block (va_CCons (va_code_Adcx64Wrap dst src) (va_CNil ())))
[@ "opaque_to_smt"]
let va_codegen_success_Adcx_64 dst src =
(va_pbool_and (va_codegen_success_Adcx64Wrap dst src) (va_ttrue ()))
[@"opaque_to_smt"]
let va_lemma_Adcx_64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Adcx_64) (va_code_Adcx_64 dst src);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
let (va_s4, va_fc4) = va_lemma_Adcx64Wrap (va_hd va_b1) va_s0 dst src in
let va_b4 = va_tl va_b1 in
let (va_sM, va_f4) = va_lemma_empty_total va_s4 va_b4 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc4 va_s4 va_f4 va_sM in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Adcx_64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Adcx_64 (va_code_Adcx_64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_dst_opr64
dst va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_dst_opr64 dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Adox_64
[@ "opaque_to_smt"]
let va_code_Adox_64 dst src =
(va_Block (va_CCons (va_code_Adox64Wrap dst src) (va_CNil ())))
[@ "opaque_to_smt"]
let va_codegen_success_Adox_64 dst src =
(va_pbool_and (va_codegen_success_Adox64Wrap dst src) (va_ttrue ()))
[@"opaque_to_smt"]
let va_lemma_Adox_64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Adox_64) (va_code_Adox_64 dst src);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
let (va_s4, va_fc4) = va_lemma_Adox64Wrap (va_hd va_b1) va_s0 dst src in
let va_b4 = va_tl va_b1 in
let (va_sM, va_f4) = va_lemma_empty_total va_s4 va_b4 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc4 va_s4 va_f4 va_sM in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Adox_64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Adox_64 (va_code_Adox_64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_dst_opr64
dst va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_dst_opr64 dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Mulx_64
[@ "opaque_to_smt"]
let va_code_Mulx_64 dst_hi dst_lo src =
(va_Block (va_CCons (va_code_Mulx64 dst_hi dst_lo src) (va_CNil ())))
[@ "opaque_to_smt"]
let va_codegen_success_Mulx_64 dst_hi dst_lo src =
(va_pbool_and (va_codegen_success_Mulx64 dst_hi dst_lo src) (va_ttrue ()))
[@"opaque_to_smt"]
| false | false |
Vale.Bignum.X64.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val va_lemma_Mulx_64 : va_b0:va_code -> va_s0:va_state -> dst_hi:va_operand_dst_opr64 ->
dst_lo:va_operand_dst_opr64 -> src:va_operand_opr64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Mulx_64 dst_hi dst_lo src) va_s0 /\
va_is_dst_dst_opr64 dst_hi va_s0 /\ va_is_dst_dst_opr64 dst_lo va_s0 /\ va_is_src_opr64 src
va_s0 /\ va_get_ok va_s0 /\ bmi2_enabled /\ dst_hi =!= dst_lo))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_dst_opr64 va_sM dst_hi == Vale.Bignum.Defs.mul_hi (va_get_reg64 rRdx va_s0)
(va_eval_opr64 va_s0 src) /\ va_eval_dst_opr64 va_sM dst_lo == Vale.Bignum.Defs.mul_lo
(va_get_reg64 rRdx va_s0) (va_eval_opr64 va_s0 src) /\ va_state_eq va_sM (va_update_ok va_sM
(va_update_operand_dst_opr64 dst_lo va_sM (va_update_operand_dst_opr64 dst_hi va_sM va_s0)))))
|
[] |
Vale.Bignum.X64.va_lemma_Mulx_64
|
{
"file_name": "obj/Vale.Bignum.X64.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst_hi: Vale.X64.Decls.va_operand_dst_opr64 ->
dst_lo: Vale.X64.Decls.va_operand_dst_opr64 ->
src: Vale.X64.Decls.va_operand_opr64
-> Prims.Ghost (Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel)
|
{
"end_col": 16,
"end_line": 126,
"start_col": 2,
"start_line": 117
}
|
Prims.Ghost
|
val va_wpProof_Adcx_64 : dst:va_operand_dst_opr64 -> src:va_operand_opr64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Adcx_64 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Adcx_64 dst src) ([va_Mod_flags;
va_mod_dst_opr64 dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
|
[
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.Defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.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
}
] | false |
let va_wpProof_Adcx_64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Adcx_64 (va_code_Adcx_64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_dst_opr64
dst va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_dst_opr64 dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
|
val va_wpProof_Adcx_64 : dst:va_operand_dst_opr64 -> src:va_operand_opr64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Adcx_64 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Adcx_64 dst src) ([va_Mod_flags;
va_mod_dst_opr64 dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
let va_wpProof_Adcx_64 dst src va_s0 va_k =
| false | null | false |
let va_sM, va_f0 = va_lemma_Adcx_64 (va_code_Adcx_64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM
(va_update_flags va_sM (va_update_ok va_sM (va_update_operand_dst_opr64 dst va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_dst_opr64 dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
|
{
"checked_file": "Vale.Bignum.X64.fst.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Bignum.Defs.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Bignum.X64.fst"
}
|
[] |
[
"Vale.X64.Decls.va_operand_dst_opr64",
"Vale.X64.Decls.va_operand_opr64",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_dst_opr64",
"Prims.Nil",
"Prims._assert",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_flags",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_operand_dst_opr64",
"Vale.X64.Decls.va_lemma_upd_update",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.Bignum.X64.va_lemma_Adcx_64",
"Vale.Bignum.X64.va_code_Adcx_64"
] |
[] |
module Vale.Bignum.X64
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
open Vale.Bignum.Defs
open FStar.Mul
open FStar.Seq
open Vale.Def.Words_s
let bool_to_nat1 (b:bool) : nat1 = if b then 1 else 0
let flag_cf f = bool_to_nat1 (cf f)
let flag_of f = bool_to_nat1 (overflow f)
//-- reveal_flags
let reveal_flags f =
()
//--
//-- lemma_add_hi_lo64
let lemma_add_hi_lo64 dummy =
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
()
//--
//-- Adcx_64
[@ "opaque_to_smt"]
let va_code_Adcx_64 dst src =
(va_Block (va_CCons (va_code_Adcx64Wrap dst src) (va_CNil ())))
[@ "opaque_to_smt"]
let va_codegen_success_Adcx_64 dst src =
(va_pbool_and (va_codegen_success_Adcx64Wrap dst src) (va_ttrue ()))
[@"opaque_to_smt"]
let va_lemma_Adcx_64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Adcx_64) (va_code_Adcx_64 dst src);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
let (va_s4, va_fc4) = va_lemma_Adcx64Wrap (va_hd va_b1) va_s0 dst src in
let va_b4 = va_tl va_b1 in
let (va_sM, va_f4) = va_lemma_empty_total va_s4 va_b4 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc4 va_s4 va_f4 va_sM in
(va_sM, va_fM)
| false | false |
Vale.Bignum.X64.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val va_wpProof_Adcx_64 : dst:va_operand_dst_opr64 -> src:va_operand_opr64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Adcx_64 dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Adcx_64 dst src) ([va_Mod_flags;
va_mod_dst_opr64 dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
|
[] |
Vale.Bignum.X64.va_wpProof_Adcx_64
|
{
"file_name": "obj/Vale.Bignum.X64.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
dst: Vale.X64.Decls.va_operand_dst_opr64 ->
src: Vale.X64.Decls.va_operand_opr64 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) * Prims.unit)
|
{
"end_col": 22,
"end_line": 67,
"start_col": 43,
"start_line": 60
}
|
Prims.Ghost
|
val va_lemma_Adcx_64 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_dst_opr64 ->
src:va_operand_opr64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Adcx_64 dst src) va_s0 /\ va_is_dst_dst_opr64 dst
va_s0 /\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ adx_enabled /\ Vale.X64.Decls.valid_cf
(va_get_flags va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_dst_opr64 va_sM dst == Vale.Bignum.Defs.add_lo (va_eval_dst_opr64 va_s0 dst)
(va_eval_opr64 va_s0 src) (flag_cf (va_get_flags va_s0)) /\ update_cf (va_get_flags va_sM)
(Vale.Bignum.Defs.add_hi (va_eval_dst_opr64 va_s0 dst) (va_eval_opr64 va_s0 src) (flag_cf
(va_get_flags va_s0))) /\ maintain_of (va_get_flags va_sM) (va_get_flags va_s0) /\ va_state_eq
va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_dst_opr64 dst va_sM
va_s0)))))
|
[
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.Defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.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
}
] | false |
let va_lemma_Adcx_64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Adcx_64) (va_code_Adcx_64 dst src);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
let (va_s4, va_fc4) = va_lemma_Adcx64Wrap (va_hd va_b1) va_s0 dst src in
let va_b4 = va_tl va_b1 in
let (va_sM, va_f4) = va_lemma_empty_total va_s4 va_b4 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc4 va_s4 va_f4 va_sM in
(va_sM, va_fM)
|
val va_lemma_Adcx_64 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_dst_opr64 ->
src:va_operand_opr64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Adcx_64 dst src) va_s0 /\ va_is_dst_dst_opr64 dst
va_s0 /\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ adx_enabled /\ Vale.X64.Decls.valid_cf
(va_get_flags va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_dst_opr64 va_sM dst == Vale.Bignum.Defs.add_lo (va_eval_dst_opr64 va_s0 dst)
(va_eval_opr64 va_s0 src) (flag_cf (va_get_flags va_s0)) /\ update_cf (va_get_flags va_sM)
(Vale.Bignum.Defs.add_hi (va_eval_dst_opr64 va_s0 dst) (va_eval_opr64 va_s0 src) (flag_cf
(va_get_flags va_s0))) /\ maintain_of (va_get_flags va_sM) (va_get_flags va_s0) /\ va_state_eq
va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_dst_opr64 dst va_sM
va_s0)))))
let va_lemma_Adcx_64 va_b0 va_s0 dst src =
| false | null | false |
va_reveal_opaque (`%va_code_Adcx_64) (va_code_Adcx_64 dst src);
let va_old_s:va_state = va_s0 in
let va_b1:va_codes = va_get_block va_b0 in
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
let va_s4, va_fc4 = va_lemma_Adcx64Wrap (va_hd va_b1) va_s0 dst src in
let va_b4 = va_tl va_b1 in
let va_sM, va_f4 = va_lemma_empty_total va_s4 va_b4 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc4 va_s4 va_f4 va_sM in
(va_sM, va_fM)
|
{
"checked_file": "Vale.Bignum.X64.fst.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Bignum.Defs.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Bignum.X64.fst"
}
|
[] |
[
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_operand_dst_opr64",
"Vale.X64.Decls.va_operand_opr64",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Decls.va_lemma_merge_total",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_lemma_empty_total",
"Prims.list",
"Vale.X64.Machine_s.precode",
"Vale.X64.Decls.ins",
"Vale.X64.Decls.ocmp",
"Vale.X64.Decls.va_tl",
"Vale.X64.InsBasic.va_lemma_Adcx64Wrap",
"Vale.X64.Decls.va_hd",
"Prims.unit",
"Vale.Bignum.Defs.reveal_add_lo_all",
"Vale.Bignum.Defs.reveal_add_hi_all",
"Vale.X64.Decls.va_get_block",
"Vale.X64.Decls.va_reveal_opaque",
"Vale.Bignum.X64.va_code_Adcx_64"
] |
[] |
module Vale.Bignum.X64
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
open Vale.Bignum.Defs
open FStar.Mul
open FStar.Seq
open Vale.Def.Words_s
let bool_to_nat1 (b:bool) : nat1 = if b then 1 else 0
let flag_cf f = bool_to_nat1 (cf f)
let flag_of f = bool_to_nat1 (overflow f)
//-- reveal_flags
let reveal_flags f =
()
//--
//-- lemma_add_hi_lo64
let lemma_add_hi_lo64 dummy =
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
()
//--
//-- Adcx_64
[@ "opaque_to_smt"]
let va_code_Adcx_64 dst src =
(va_Block (va_CCons (va_code_Adcx64Wrap dst src) (va_CNil ())))
[@ "opaque_to_smt"]
let va_codegen_success_Adcx_64 dst src =
(va_pbool_and (va_codegen_success_Adcx64Wrap dst src) (va_ttrue ()))
[@"opaque_to_smt"]
| false | false |
Vale.Bignum.X64.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val va_lemma_Adcx_64 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_dst_opr64 ->
src:va_operand_opr64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Adcx_64 dst src) va_s0 /\ va_is_dst_dst_opr64 dst
va_s0 /\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ adx_enabled /\ Vale.X64.Decls.valid_cf
(va_get_flags va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_dst_opr64 va_sM dst == Vale.Bignum.Defs.add_lo (va_eval_dst_opr64 va_s0 dst)
(va_eval_opr64 va_s0 src) (flag_cf (va_get_flags va_s0)) /\ update_cf (va_get_flags va_sM)
(Vale.Bignum.Defs.add_hi (va_eval_dst_opr64 va_s0 dst) (va_eval_opr64 va_s0 src) (flag_cf
(va_get_flags va_s0))) /\ maintain_of (va_get_flags va_sM) (va_get_flags va_s0) /\ va_state_eq
va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_dst_opr64 dst va_sM
va_s0)))))
|
[] |
Vale.Bignum.X64.va_lemma_Adcx_64
|
{
"file_name": "obj/Vale.Bignum.X64.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst: Vale.X64.Decls.va_operand_dst_opr64 ->
src: Vale.X64.Decls.va_operand_opr64
-> Prims.Ghost (Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel)
|
{
"end_col": 16,
"end_line": 56,
"start_col": 2,
"start_line": 47
}
|
Prims.Ghost
|
val va_lemma_Adox_64 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_dst_opr64 ->
src:va_operand_opr64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Adox_64 dst src) va_s0 /\ va_is_dst_dst_opr64 dst
va_s0 /\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ adx_enabled /\ Vale.X64.Decls.valid_of
(va_get_flags va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_dst_opr64 va_sM dst == Vale.Bignum.Defs.add_lo (va_eval_dst_opr64 va_s0 dst)
(va_eval_opr64 va_s0 src) (flag_of (va_get_flags va_s0)) /\ update_of (va_get_flags va_sM)
(Vale.Bignum.Defs.add_hi (va_eval_dst_opr64 va_s0 dst) (va_eval_opr64 va_s0 src) (flag_of
(va_get_flags va_s0))) /\ maintain_cf (va_get_flags va_sM) (va_get_flags va_s0) /\ va_state_eq
va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_dst_opr64 dst va_sM
va_s0)))))
|
[
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.Defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.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
}
] | false |
let va_lemma_Adox_64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Adox_64) (va_code_Adox_64 dst src);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
let (va_s4, va_fc4) = va_lemma_Adox64Wrap (va_hd va_b1) va_s0 dst src in
let va_b4 = va_tl va_b1 in
let (va_sM, va_f4) = va_lemma_empty_total va_s4 va_b4 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc4 va_s4 va_f4 va_sM in
(va_sM, va_fM)
|
val va_lemma_Adox_64 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_dst_opr64 ->
src:va_operand_opr64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Adox_64 dst src) va_s0 /\ va_is_dst_dst_opr64 dst
va_s0 /\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ adx_enabled /\ Vale.X64.Decls.valid_of
(va_get_flags va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_dst_opr64 va_sM dst == Vale.Bignum.Defs.add_lo (va_eval_dst_opr64 va_s0 dst)
(va_eval_opr64 va_s0 src) (flag_of (va_get_flags va_s0)) /\ update_of (va_get_flags va_sM)
(Vale.Bignum.Defs.add_hi (va_eval_dst_opr64 va_s0 dst) (va_eval_opr64 va_s0 src) (flag_of
(va_get_flags va_s0))) /\ maintain_cf (va_get_flags va_sM) (va_get_flags va_s0) /\ va_state_eq
va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_dst_opr64 dst va_sM
va_s0)))))
let va_lemma_Adox_64 va_b0 va_s0 dst src =
| false | null | false |
va_reveal_opaque (`%va_code_Adox_64) (va_code_Adox_64 dst src);
let va_old_s:va_state = va_s0 in
let va_b1:va_codes = va_get_block va_b0 in
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
let va_s4, va_fc4 = va_lemma_Adox64Wrap (va_hd va_b1) va_s0 dst src in
let va_b4 = va_tl va_b1 in
let va_sM, va_f4 = va_lemma_empty_total va_s4 va_b4 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc4 va_s4 va_f4 va_sM in
(va_sM, va_fM)
|
{
"checked_file": "Vale.Bignum.X64.fst.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Bignum.Defs.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Bignum.X64.fst"
}
|
[] |
[
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_operand_dst_opr64",
"Vale.X64.Decls.va_operand_opr64",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Decls.va_lemma_merge_total",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_lemma_empty_total",
"Prims.list",
"Vale.X64.Machine_s.precode",
"Vale.X64.Decls.ins",
"Vale.X64.Decls.ocmp",
"Vale.X64.Decls.va_tl",
"Vale.X64.InsBasic.va_lemma_Adox64Wrap",
"Vale.X64.Decls.va_hd",
"Prims.unit",
"Vale.Bignum.Defs.reveal_add_lo_all",
"Vale.Bignum.Defs.reveal_add_hi_all",
"Vale.X64.Decls.va_get_block",
"Vale.X64.Decls.va_reveal_opaque",
"Vale.Bignum.X64.va_code_Adox_64"
] |
[] |
module Vale.Bignum.X64
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
open Vale.Bignum.Defs
open FStar.Mul
open FStar.Seq
open Vale.Def.Words_s
let bool_to_nat1 (b:bool) : nat1 = if b then 1 else 0
let flag_cf f = bool_to_nat1 (cf f)
let flag_of f = bool_to_nat1 (overflow f)
//-- reveal_flags
let reveal_flags f =
()
//--
//-- lemma_add_hi_lo64
let lemma_add_hi_lo64 dummy =
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
()
//--
//-- Adcx_64
[@ "opaque_to_smt"]
let va_code_Adcx_64 dst src =
(va_Block (va_CCons (va_code_Adcx64Wrap dst src) (va_CNil ())))
[@ "opaque_to_smt"]
let va_codegen_success_Adcx_64 dst src =
(va_pbool_and (va_codegen_success_Adcx64Wrap dst src) (va_ttrue ()))
[@"opaque_to_smt"]
let va_lemma_Adcx_64 va_b0 va_s0 dst src =
va_reveal_opaque (`%va_code_Adcx_64) (va_code_Adcx_64 dst src);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
Vale.Bignum.Defs.reveal_add_hi_all ();
Vale.Bignum.Defs.reveal_add_lo_all ();
let (va_s4, va_fc4) = va_lemma_Adcx64Wrap (va_hd va_b1) va_s0 dst src in
let va_b4 = va_tl va_b1 in
let (va_sM, va_f4) = va_lemma_empty_total va_s4 va_b4 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc4 va_s4 va_f4 va_sM in
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Adcx_64 dst src va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Adcx_64 (va_code_Adcx_64 dst src) va_s0 dst src in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_dst_opr64
dst va_sM va_s0))));
va_lemma_norm_mods ([va_Mod_flags; va_mod_dst_opr64 dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Adox_64
[@ "opaque_to_smt"]
let va_code_Adox_64 dst src =
(va_Block (va_CCons (va_code_Adox64Wrap dst src) (va_CNil ())))
[@ "opaque_to_smt"]
let va_codegen_success_Adox_64 dst src =
(va_pbool_and (va_codegen_success_Adox64Wrap dst src) (va_ttrue ()))
[@"opaque_to_smt"]
| false | false |
Vale.Bignum.X64.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val va_lemma_Adox_64 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_dst_opr64 ->
src:va_operand_opr64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Adox_64 dst src) va_s0 /\ va_is_dst_dst_opr64 dst
va_s0 /\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ adx_enabled /\ Vale.X64.Decls.valid_of
(va_get_flags va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_eval_dst_opr64 va_sM dst == Vale.Bignum.Defs.add_lo (va_eval_dst_opr64 va_s0 dst)
(va_eval_opr64 va_s0 src) (flag_of (va_get_flags va_s0)) /\ update_of (va_get_flags va_sM)
(Vale.Bignum.Defs.add_hi (va_eval_dst_opr64 va_s0 dst) (va_eval_opr64 va_s0 src) (flag_of
(va_get_flags va_s0))) /\ maintain_cf (va_get_flags va_sM) (va_get_flags va_s0) /\ va_state_eq
va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_dst_opr64 dst va_sM
va_s0)))))
|
[] |
Vale.Bignum.X64.va_lemma_Adox_64
|
{
"file_name": "obj/Vale.Bignum.X64.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
dst: Vale.X64.Decls.va_operand_dst_opr64 ->
src: Vale.X64.Decls.va_operand_opr64
-> Prims.Ghost (Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel)
|
{
"end_col": 16,
"end_line": 91,
"start_col": 2,
"start_line": 82
}
|
Prims.Tot
|
val point_mul_g (a: qelem) : proj_point
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let point_mul_g (a:qelem) : proj_point = point_mul a g
|
val point_mul_g (a: qelem) : proj_point
let point_mul_g (a: qelem) : proj_point =
| false | null | false |
point_mul a g
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Spec.K256.PointOps.qelem",
"Spec.K256.point_mul",
"Spec.K256.PointOps.g",
"Spec.K256.PointOps.proj_point"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
let mk_k256_abelian_group : LE.abelian_group aff_point = {
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma;
}
let mk_to_k256_comm_monoid : SE.to_comm_monoid proj_point = {
SE.a_spec = aff_point;
SE.comm_monoid = mk_k256_comm_monoid;
SE.refl = to_aff_point;
}
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
let point_at_inf_c _ =
KL.to_aff_point_at_infinity_lemma ();
point_at_inf
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
let point_add_c p q =
KL.to_aff_point_add_lemma p q;
point_add p q
val point_double_c : SE.sqr_st proj_point mk_to_k256_comm_monoid
let point_double_c p =
KL.to_aff_point_double_lemma p;
point_double p
let mk_k256_concrete_ops : SE.concrete_ops proj_point = {
SE.to = mk_to_k256_comm_monoid;
SE.one = point_at_inf_c;
SE.mul = point_add_c;
SE.sqr = point_double_c;
}
// [a]P in affine coordinates
let aff_point_mul (a:nat) (p:aff_point) : aff_point =
LE.pow mk_k256_comm_monoid p a
// [a]P
let point_mul (a:qelem) (p:proj_point) : proj_point =
SE.exp_fw mk_k256_concrete_ops p 256 a 4
// [a1]P1 + [a2]P2
let point_mul_double (a1:qelem) (p1:proj_point) (a2:qelem) (p2:proj_point) : proj_point =
SE.exp_double_fw mk_k256_concrete_ops p1 256 a1 p2 a2 5
| false | true |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val point_mul_g (a: qelem) : proj_point
|
[] |
Spec.K256.point_mul_g
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
a: Spec.K256.PointOps.qelem -> Spec.K256.PointOps.proj_point
|
{
"end_col": 54,
"end_line": 78,
"start_col": 41,
"start_line": 78
}
|
Prims.Tot
|
val point_mul_double_g (a1 a2: qelem) (p: proj_point) : proj_point
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let point_mul_double_g (a1:qelem) (a2:qelem) (p:proj_point) : proj_point =
point_mul_double a1 g a2 p
|
val point_mul_double_g (a1 a2: qelem) (p: proj_point) : proj_point
let point_mul_double_g (a1 a2: qelem) (p: proj_point) : proj_point =
| false | null | false |
point_mul_double a1 g a2 p
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Spec.K256.PointOps.qelem",
"Spec.K256.PointOps.proj_point",
"Spec.K256.point_mul_double",
"Spec.K256.PointOps.g"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
let mk_k256_abelian_group : LE.abelian_group aff_point = {
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma;
}
let mk_to_k256_comm_monoid : SE.to_comm_monoid proj_point = {
SE.a_spec = aff_point;
SE.comm_monoid = mk_k256_comm_monoid;
SE.refl = to_aff_point;
}
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
let point_at_inf_c _ =
KL.to_aff_point_at_infinity_lemma ();
point_at_inf
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
let point_add_c p q =
KL.to_aff_point_add_lemma p q;
point_add p q
val point_double_c : SE.sqr_st proj_point mk_to_k256_comm_monoid
let point_double_c p =
KL.to_aff_point_double_lemma p;
point_double p
let mk_k256_concrete_ops : SE.concrete_ops proj_point = {
SE.to = mk_to_k256_comm_monoid;
SE.one = point_at_inf_c;
SE.mul = point_add_c;
SE.sqr = point_double_c;
}
// [a]P in affine coordinates
let aff_point_mul (a:nat) (p:aff_point) : aff_point =
LE.pow mk_k256_comm_monoid p a
// [a]P
let point_mul (a:qelem) (p:proj_point) : proj_point =
SE.exp_fw mk_k256_concrete_ops p 256 a 4
// [a1]P1 + [a2]P2
let point_mul_double (a1:qelem) (p1:proj_point) (a2:qelem) (p2:proj_point) : proj_point =
SE.exp_double_fw mk_k256_concrete_ops p1 256 a1 p2 a2 5
// [a]G
let point_mul_g (a:qelem) : proj_point = point_mul a g
// [a1]G + [a2]P
| false | true |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val point_mul_double_g (a1 a2: qelem) (p: proj_point) : proj_point
|
[] |
Spec.K256.point_mul_double_g
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
a1: Spec.K256.PointOps.qelem -> a2: Spec.K256.PointOps.qelem -> p: Spec.K256.PointOps.proj_point
-> Spec.K256.PointOps.proj_point
|
{
"end_col": 28,
"end_line": 82,
"start_col": 2,
"start_line": 82
}
|
Prims.Tot
|
val aff_point_mul (a: nat) (p: aff_point) : aff_point
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let aff_point_mul (a:nat) (p:aff_point) : aff_point =
LE.pow mk_k256_comm_monoid p a
|
val aff_point_mul (a: nat) (p: aff_point) : aff_point
let aff_point_mul (a: nat) (p: aff_point) : aff_point =
| false | null | false |
LE.pow mk_k256_comm_monoid p a
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Prims.nat",
"Spec.K256.PointOps.aff_point",
"Lib.Exponentiation.Definition.pow",
"Spec.K256.mk_k256_comm_monoid"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
let mk_k256_abelian_group : LE.abelian_group aff_point = {
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma;
}
let mk_to_k256_comm_monoid : SE.to_comm_monoid proj_point = {
SE.a_spec = aff_point;
SE.comm_monoid = mk_k256_comm_monoid;
SE.refl = to_aff_point;
}
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
let point_at_inf_c _ =
KL.to_aff_point_at_infinity_lemma ();
point_at_inf
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
let point_add_c p q =
KL.to_aff_point_add_lemma p q;
point_add p q
val point_double_c : SE.sqr_st proj_point mk_to_k256_comm_monoid
let point_double_c p =
KL.to_aff_point_double_lemma p;
point_double p
let mk_k256_concrete_ops : SE.concrete_ops proj_point = {
SE.to = mk_to_k256_comm_monoid;
SE.one = point_at_inf_c;
SE.mul = point_add_c;
SE.sqr = point_double_c;
}
// [a]P in affine coordinates
| false | true |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val aff_point_mul (a: nat) (p: aff_point) : aff_point
|
[] |
Spec.K256.aff_point_mul
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
a: Prims.nat -> p: Spec.K256.PointOps.aff_point -> Spec.K256.PointOps.aff_point
|
{
"end_col": 32,
"end_line": 67,
"start_col": 2,
"start_line": 67
}
|
Prims.Tot
|
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let point_add_c p q =
KL.to_aff_point_add_lemma p q;
point_add p q
|
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
let point_add_c p q =
| false | null | false |
KL.to_aff_point_add_lemma p q;
point_add p q
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Spec.K256.PointOps.proj_point",
"Spec.K256.PointOps.point_add",
"Prims.unit",
"Spec.K256.Lemmas.to_aff_point_add_lemma"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
let mk_k256_abelian_group : LE.abelian_group aff_point = {
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma;
}
let mk_to_k256_comm_monoid : SE.to_comm_monoid proj_point = {
SE.a_spec = aff_point;
SE.comm_monoid = mk_k256_comm_monoid;
SE.refl = to_aff_point;
}
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
let point_at_inf_c _ =
KL.to_aff_point_at_infinity_lemma ();
point_at_inf
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
| false | true |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
|
[] |
Spec.K256.point_add_c
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
Spec.Exponentiation.mul_st Spec.K256.PointOps.proj_point Spec.K256.mk_to_k256_comm_monoid
|
{
"end_col": 15,
"end_line": 51,
"start_col": 2,
"start_line": 50
}
|
Prims.Tot
|
val mk_k256_comm_monoid:LE.comm_monoid aff_point
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
|
val mk_k256_comm_monoid:LE.comm_monoid aff_point
let mk_k256_comm_monoid:LE.comm_monoid aff_point =
| false | null | false |
{
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma
}
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Lib.Exponentiation.Definition.Mkcomm_monoid",
"Spec.K256.PointOps.aff_point",
"Spec.K256.PointOps.aff_point_at_inf",
"Spec.K256.PointOps.aff_point_add",
"Spec.K256.Lemmas.aff_point_at_inf_lemma",
"Spec.K256.Lemmas.aff_point_add_assoc_lemma",
"Spec.K256.Lemmas.aff_point_add_comm_lemma"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
| false | true |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val mk_k256_comm_monoid:LE.comm_monoid aff_point
|
[] |
Spec.K256.mk_k256_comm_monoid
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
Lib.Exponentiation.Definition.comm_monoid Spec.K256.PointOps.aff_point
|
{
"end_col": 50,
"end_line": 28,
"start_col": 2,
"start_line": 24
}
|
Prims.Tot
|
val point_double_c : SE.sqr_st proj_point mk_to_k256_comm_monoid
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let point_double_c p =
KL.to_aff_point_double_lemma p;
point_double p
|
val point_double_c : SE.sqr_st proj_point mk_to_k256_comm_monoid
let point_double_c p =
| false | null | false |
KL.to_aff_point_double_lemma p;
point_double p
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Spec.K256.PointOps.proj_point",
"Spec.K256.PointOps.point_double",
"Prims.unit",
"Spec.K256.Lemmas.to_aff_point_double_lemma"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
let mk_k256_abelian_group : LE.abelian_group aff_point = {
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma;
}
let mk_to_k256_comm_monoid : SE.to_comm_monoid proj_point = {
SE.a_spec = aff_point;
SE.comm_monoid = mk_k256_comm_monoid;
SE.refl = to_aff_point;
}
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
let point_at_inf_c _ =
KL.to_aff_point_at_infinity_lemma ();
point_at_inf
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
let point_add_c p q =
KL.to_aff_point_add_lemma p q;
point_add p q
val point_double_c : SE.sqr_st proj_point mk_to_k256_comm_monoid
| false | true |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val point_double_c : SE.sqr_st proj_point mk_to_k256_comm_monoid
|
[] |
Spec.K256.point_double_c
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
Spec.Exponentiation.sqr_st Spec.K256.PointOps.proj_point Spec.K256.mk_to_k256_comm_monoid
|
{
"end_col": 16,
"end_line": 56,
"start_col": 2,
"start_line": 55
}
|
Prims.Tot
|
val point_mul_double (a1: qelem) (p1: proj_point) (a2: qelem) (p2: proj_point) : proj_point
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let point_mul_double (a1:qelem) (p1:proj_point) (a2:qelem) (p2:proj_point) : proj_point =
SE.exp_double_fw mk_k256_concrete_ops p1 256 a1 p2 a2 5
|
val point_mul_double (a1: qelem) (p1: proj_point) (a2: qelem) (p2: proj_point) : proj_point
let point_mul_double (a1: qelem) (p1: proj_point) (a2: qelem) (p2: proj_point) : proj_point =
| false | null | false |
SE.exp_double_fw mk_k256_concrete_ops p1 256 a1 p2 a2 5
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Spec.K256.PointOps.qelem",
"Spec.K256.PointOps.proj_point",
"Spec.Exponentiation.exp_double_fw",
"Spec.K256.mk_k256_concrete_ops"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
let mk_k256_abelian_group : LE.abelian_group aff_point = {
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma;
}
let mk_to_k256_comm_monoid : SE.to_comm_monoid proj_point = {
SE.a_spec = aff_point;
SE.comm_monoid = mk_k256_comm_monoid;
SE.refl = to_aff_point;
}
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
let point_at_inf_c _ =
KL.to_aff_point_at_infinity_lemma ();
point_at_inf
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
let point_add_c p q =
KL.to_aff_point_add_lemma p q;
point_add p q
val point_double_c : SE.sqr_st proj_point mk_to_k256_comm_monoid
let point_double_c p =
KL.to_aff_point_double_lemma p;
point_double p
let mk_k256_concrete_ops : SE.concrete_ops proj_point = {
SE.to = mk_to_k256_comm_monoid;
SE.one = point_at_inf_c;
SE.mul = point_add_c;
SE.sqr = point_double_c;
}
// [a]P in affine coordinates
let aff_point_mul (a:nat) (p:aff_point) : aff_point =
LE.pow mk_k256_comm_monoid p a
// [a]P
let point_mul (a:qelem) (p:proj_point) : proj_point =
SE.exp_fw mk_k256_concrete_ops p 256 a 4
// [a1]P1 + [a2]P2
| false | true |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val point_mul_double (a1: qelem) (p1: proj_point) (a2: qelem) (p2: proj_point) : proj_point
|
[] |
Spec.K256.point_mul_double
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
a1: Spec.K256.PointOps.qelem ->
p1: Spec.K256.PointOps.proj_point ->
a2: Spec.K256.PointOps.qelem ->
p2: Spec.K256.PointOps.proj_point
-> Spec.K256.PointOps.proj_point
|
{
"end_col": 57,
"end_line": 75,
"start_col": 2,
"start_line": 75
}
|
Prims.Tot
|
val mk_k256_abelian_group:LE.abelian_group aff_point
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let mk_k256_abelian_group : LE.abelian_group aff_point = {
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma;
}
|
val mk_k256_abelian_group:LE.abelian_group aff_point
let mk_k256_abelian_group:LE.abelian_group aff_point =
| false | null | false |
{
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma
}
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Lib.Exponentiation.Definition.Mkabelian_group",
"Spec.K256.PointOps.aff_point",
"Spec.K256.mk_k256_comm_monoid",
"Spec.K256.PointOps.aff_point_negate",
"Spec.K256.Lemmas.aff_point_negate_lemma"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
| false | true |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val mk_k256_abelian_group:LE.abelian_group aff_point
|
[] |
Spec.K256.mk_k256_abelian_group
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
Lib.Exponentiation.Definition.abelian_group Spec.K256.PointOps.aff_point
|
{
"end_col": 47,
"end_line": 34,
"start_col": 2,
"start_line": 32
}
|
Prims.Tot
|
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let point_at_inf_c _ =
KL.to_aff_point_at_infinity_lemma ();
point_at_inf
|
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
let point_at_inf_c _ =
| false | null | false |
KL.to_aff_point_at_infinity_lemma ();
point_at_inf
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Prims.unit",
"Spec.K256.PointOps.point_at_inf",
"Spec.K256.Lemmas.to_aff_point_at_infinity_lemma",
"Spec.K256.PointOps.proj_point"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
let mk_k256_abelian_group : LE.abelian_group aff_point = {
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma;
}
let mk_to_k256_comm_monoid : SE.to_comm_monoid proj_point = {
SE.a_spec = aff_point;
SE.comm_monoid = mk_k256_comm_monoid;
SE.refl = to_aff_point;
}
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
| false | true |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
|
[] |
Spec.K256.point_at_inf_c
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
Spec.Exponentiation.one_st Spec.K256.PointOps.proj_point Spec.K256.mk_to_k256_comm_monoid
|
{
"end_col": 14,
"end_line": 46,
"start_col": 2,
"start_line": 45
}
|
Prims.Tot
|
val point_mul (a: qelem) (p: proj_point) : proj_point
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let point_mul (a:qelem) (p:proj_point) : proj_point =
SE.exp_fw mk_k256_concrete_ops p 256 a 4
|
val point_mul (a: qelem) (p: proj_point) : proj_point
let point_mul (a: qelem) (p: proj_point) : proj_point =
| false | null | false |
SE.exp_fw mk_k256_concrete_ops p 256 a 4
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Spec.K256.PointOps.qelem",
"Spec.K256.PointOps.proj_point",
"Spec.Exponentiation.exp_fw",
"Spec.K256.mk_k256_concrete_ops"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
let mk_k256_abelian_group : LE.abelian_group aff_point = {
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma;
}
let mk_to_k256_comm_monoid : SE.to_comm_monoid proj_point = {
SE.a_spec = aff_point;
SE.comm_monoid = mk_k256_comm_monoid;
SE.refl = to_aff_point;
}
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
let point_at_inf_c _ =
KL.to_aff_point_at_infinity_lemma ();
point_at_inf
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
let point_add_c p q =
KL.to_aff_point_add_lemma p q;
point_add p q
val point_double_c : SE.sqr_st proj_point mk_to_k256_comm_monoid
let point_double_c p =
KL.to_aff_point_double_lemma p;
point_double p
let mk_k256_concrete_ops : SE.concrete_ops proj_point = {
SE.to = mk_to_k256_comm_monoid;
SE.one = point_at_inf_c;
SE.mul = point_add_c;
SE.sqr = point_double_c;
}
// [a]P in affine coordinates
let aff_point_mul (a:nat) (p:aff_point) : aff_point =
LE.pow mk_k256_comm_monoid p a
// [a]P
| false | true |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val point_mul (a: qelem) (p: proj_point) : proj_point
|
[] |
Spec.K256.point_mul
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
a: Spec.K256.PointOps.qelem -> p: Spec.K256.PointOps.proj_point -> Spec.K256.PointOps.proj_point
|
{
"end_col": 42,
"end_line": 71,
"start_col": 2,
"start_line": 71
}
|
Prims.Tot
|
val secp256k1_ecdsa_verify_hashed_msg (msgHash: lbytes 32) (public_key signature: lbytes 64) : bool
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let secp256k1_ecdsa_verify_hashed_msg (msgHash:lbytes 32) (public_key signature:lbytes 64) : bool =
if not (secp256k1_ecdsa_is_signature_normalized signature) then false
else ecdsa_verify_hashed_msg msgHash public_key signature
|
val secp256k1_ecdsa_verify_hashed_msg (msgHash: lbytes 32) (public_key signature: lbytes 64) : bool
let secp256k1_ecdsa_verify_hashed_msg (msgHash: lbytes 32) (public_key signature: lbytes 64) : bool =
| false | null | false |
if not (secp256k1_ecdsa_is_signature_normalized signature)
then false
else ecdsa_verify_hashed_msg msgHash public_key signature
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Lib.ByteSequence.lbytes",
"Prims.op_Negation",
"Spec.K256.secp256k1_ecdsa_is_signature_normalized",
"Prims.bool",
"Spec.K256.ecdsa_verify_hashed_msg"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
let mk_k256_abelian_group : LE.abelian_group aff_point = {
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma;
}
let mk_to_k256_comm_monoid : SE.to_comm_monoid proj_point = {
SE.a_spec = aff_point;
SE.comm_monoid = mk_k256_comm_monoid;
SE.refl = to_aff_point;
}
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
let point_at_inf_c _ =
KL.to_aff_point_at_infinity_lemma ();
point_at_inf
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
let point_add_c p q =
KL.to_aff_point_add_lemma p q;
point_add p q
val point_double_c : SE.sqr_st proj_point mk_to_k256_comm_monoid
let point_double_c p =
KL.to_aff_point_double_lemma p;
point_double p
let mk_k256_concrete_ops : SE.concrete_ops proj_point = {
SE.to = mk_to_k256_comm_monoid;
SE.one = point_at_inf_c;
SE.mul = point_add_c;
SE.sqr = point_double_c;
}
// [a]P in affine coordinates
let aff_point_mul (a:nat) (p:aff_point) : aff_point =
LE.pow mk_k256_comm_monoid p a
// [a]P
let point_mul (a:qelem) (p:proj_point) : proj_point =
SE.exp_fw mk_k256_concrete_ops p 256 a 4
// [a1]P1 + [a2]P2
let point_mul_double (a1:qelem) (p1:proj_point) (a2:qelem) (p2:proj_point) : proj_point =
SE.exp_double_fw mk_k256_concrete_ops p1 256 a1 p2 a2 5
// [a]G
let point_mul_g (a:qelem) : proj_point = point_mul a g
// [a1]G + [a2]P
let point_mul_double_g (a1:qelem) (a2:qelem) (p:proj_point) : proj_point =
point_mul_double a1 g a2 p
/// ECDSA with a prehashed message
let ecdsa_sign_hashed_msg (msgHash private_key nonce:lbytes 32) : option (lbytes 64) =
let k_q = nat_from_bytes_be nonce in
let d_a = nat_from_bytes_be private_key in
let z = nat_from_bytes_be msgHash % q in
let is_privkey_valid = 0 < d_a && d_a < q in
let is_nonce_valid = 0 < k_q && k_q < q in
if not (is_privkey_valid && is_nonce_valid) then None
else begin
let _X, _Y, _Z = point_mul_g k_q in
let x = _X /% _Z in
let r = x % q in
let kinv = qinv k_q in
let s = kinv *^ (z +^ r *^ d_a) in
let rb = nat_to_bytes_be 32 r in
let sb = nat_to_bytes_be 32 s in
if r = 0 || s = 0 then None else Some (concat #_ #32 #32 rb sb) end
let ecdsa_verify_hashed_msg (msgHash:lbytes 32) (public_key signature:lbytes 64) : bool =
let pk = load_point public_key in
let r = nat_from_bytes_be (sub signature 0 32) in
let s = nat_from_bytes_be (sub signature 32 32) in
let z = nat_from_bytes_be msgHash % q in
let is_r_valid = 0 < r && r < q in
let is_s_valid = 0 < s && s < q in
if not (Some? pk && is_r_valid && is_s_valid) then false
else begin
assert_norm (q < pow2 256);
let sinv = qinv s in
let u1 = z *^ sinv in
let u2 = r *^ sinv in
let _X, _Y, _Z = point_mul_double_g u1 u2 (Some?.v pk) in
if is_proj_point_at_inf (_X, _Y, _Z) then false
else begin
let x = _X /% _Z in
x % q = r end
end
(*
_Z <> 0
q < prime < 2 * q
let x = _X /% _Z in x % q = r <==>
1. x = r <==> _X = r *% _Z
2. x - q = r <==> _X = (r + q) *% _Z
*)
/// ECDSA using SHA2-256
let _: squash(Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32) =
assert_norm (Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32)
let ecdsa_sign_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (private_key nonce:lbytes 32) : option (lbytes 64) =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_sign_hashed_msg msgHash private_key nonce
let ecdsa_verify_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (public_key signature:lbytes 64) : bool =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_verify_hashed_msg msgHash public_key signature
/// ECDH over the secp256k1 elliptic curve
let secret_to_public (private_key:lbytes 32) : option (lbytes 64) =
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if is_sk_valid then
let pk = point_mul_g sk in
Some (point_store pk)
else None
let ecdh (their_public_key:lbytes 64) (private_key:lbytes 32) : option (lbytes 64) =
let pk = load_point their_public_key in
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if Some? pk && is_sk_valid then
let ss = point_mul sk (Some?.v pk) in
Some (point_store ss)
else None
/// Parsing and Serializing public keys
// raw = [ x; y ], 64 bytes
// uncompressed = [ 0x04; x; y ], 65 bytes
// compressed = [ 0x02 for even `y` and 0x03 for odd `y`; x ], 33 bytes
let validate_public_key (pk:lbytes 64) : bool =
Some? (load_point pk)
let pk_uncompressed_to_raw (pk:lbytes 65) : option (lbytes 64) =
if Lib.RawIntTypes.u8_to_UInt8 pk.[0] <> 0x04uy then None else Some (sub pk 1 64)
let pk_uncompressed_from_raw (pk:lbytes 64) : lbytes 65 =
concat (create 1 (u8 0x04)) pk
let pk_compressed_to_raw (pk:lbytes 33) : option (lbytes 64) =
let pk_x = sub pk 1 32 in
match (aff_point_decompress pk) with
| Some (x, y) -> Some (concat #_ #32 #32 pk_x (nat_to_bytes_be 32 y))
| None -> None
let pk_compressed_from_raw (pk:lbytes 64) : lbytes 33 =
let pk_x = sub pk 0 32 in
let pk_y = sub pk 32 32 in
let is_pk_y_odd = nat_from_bytes_be pk_y % 2 = 1 in // <==> pk_y % 2 = 1
let pk0 = if is_pk_y_odd then u8 0x03 else u8 0x02 in
concat (create 1 pk0) pk_x
/// Low-S normalization
(**
https://en.bitcoin.it/wiki/BIP_0062
https://yondon.blog/2019/01/01/how-not-to-use-ecdsa/
https://eklitzke.org/bitcoin-transaction-malleability
*)
// The value S in signatures must be between 0x1 and q / 2 (inclusive).
// If S is too high, simply replace it by S' = q - S.
let secp256k1_ecdsa_signature_normalize (signature:lbytes 64) : option (lbytes 64) =
let sn = nat_from_bytes_be (sub signature 32 32) in
let is_sn_valid = 0 < sn && sn < q in
if is_sn_valid then begin
let sn = if sn <= q / 2 then sn else (q - sn) % q in
let sgnt = update_sub signature 32 32 (nat_to_bytes_be 32 sn) in
Some sgnt end
else None
let secp256k1_ecdsa_is_signature_normalized (signature:lbytes 64) : bool =
let sn = nat_from_bytes_be (sub signature 32 32) in
0 < sn && sn <= q / 2
let secp256k1_ecdsa_sign_hashed_msg (msgHash private_key nonce:lbytes 32) : option (lbytes 64) =
let signature = ecdsa_sign_hashed_msg msgHash private_key nonce in
match signature with
| Some x -> secp256k1_ecdsa_signature_normalize x
| None -> None
let secp256k1_ecdsa_sign_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (private_key nonce:lbytes 32) : option (lbytes 64) =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
secp256k1_ecdsa_sign_hashed_msg msgHash private_key nonce
| false | false |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val secp256k1_ecdsa_verify_hashed_msg (msgHash: lbytes 32) (public_key signature: lbytes 64) : bool
|
[] |
Spec.K256.secp256k1_ecdsa_verify_hashed_msg
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
msgHash: Lib.ByteSequence.lbytes 32 ->
public_key: Lib.ByteSequence.lbytes 64 ->
signature: Lib.ByteSequence.lbytes 64
-> Prims.bool
|
{
"end_col": 59,
"end_line": 247,
"start_col": 2,
"start_line": 246
}
|
Prims.Tot
|
val validate_public_key (pk: lbytes 64) : bool
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let validate_public_key (pk:lbytes 64) : bool =
Some? (load_point pk)
|
val validate_public_key (pk: lbytes 64) : bool
let validate_public_key (pk: lbytes 64) : bool =
| false | null | false |
Some? (load_point pk)
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Lib.ByteSequence.lbytes",
"FStar.Pervasives.Native.uu___is_Some",
"Spec.K256.PointOps.proj_point",
"Spec.K256.PointOps.load_point",
"Prims.bool"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
let mk_k256_abelian_group : LE.abelian_group aff_point = {
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma;
}
let mk_to_k256_comm_monoid : SE.to_comm_monoid proj_point = {
SE.a_spec = aff_point;
SE.comm_monoid = mk_k256_comm_monoid;
SE.refl = to_aff_point;
}
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
let point_at_inf_c _ =
KL.to_aff_point_at_infinity_lemma ();
point_at_inf
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
let point_add_c p q =
KL.to_aff_point_add_lemma p q;
point_add p q
val point_double_c : SE.sqr_st proj_point mk_to_k256_comm_monoid
let point_double_c p =
KL.to_aff_point_double_lemma p;
point_double p
let mk_k256_concrete_ops : SE.concrete_ops proj_point = {
SE.to = mk_to_k256_comm_monoid;
SE.one = point_at_inf_c;
SE.mul = point_add_c;
SE.sqr = point_double_c;
}
// [a]P in affine coordinates
let aff_point_mul (a:nat) (p:aff_point) : aff_point =
LE.pow mk_k256_comm_monoid p a
// [a]P
let point_mul (a:qelem) (p:proj_point) : proj_point =
SE.exp_fw mk_k256_concrete_ops p 256 a 4
// [a1]P1 + [a2]P2
let point_mul_double (a1:qelem) (p1:proj_point) (a2:qelem) (p2:proj_point) : proj_point =
SE.exp_double_fw mk_k256_concrete_ops p1 256 a1 p2 a2 5
// [a]G
let point_mul_g (a:qelem) : proj_point = point_mul a g
// [a1]G + [a2]P
let point_mul_double_g (a1:qelem) (a2:qelem) (p:proj_point) : proj_point =
point_mul_double a1 g a2 p
/// ECDSA with a prehashed message
let ecdsa_sign_hashed_msg (msgHash private_key nonce:lbytes 32) : option (lbytes 64) =
let k_q = nat_from_bytes_be nonce in
let d_a = nat_from_bytes_be private_key in
let z = nat_from_bytes_be msgHash % q in
let is_privkey_valid = 0 < d_a && d_a < q in
let is_nonce_valid = 0 < k_q && k_q < q in
if not (is_privkey_valid && is_nonce_valid) then None
else begin
let _X, _Y, _Z = point_mul_g k_q in
let x = _X /% _Z in
let r = x % q in
let kinv = qinv k_q in
let s = kinv *^ (z +^ r *^ d_a) in
let rb = nat_to_bytes_be 32 r in
let sb = nat_to_bytes_be 32 s in
if r = 0 || s = 0 then None else Some (concat #_ #32 #32 rb sb) end
let ecdsa_verify_hashed_msg (msgHash:lbytes 32) (public_key signature:lbytes 64) : bool =
let pk = load_point public_key in
let r = nat_from_bytes_be (sub signature 0 32) in
let s = nat_from_bytes_be (sub signature 32 32) in
let z = nat_from_bytes_be msgHash % q in
let is_r_valid = 0 < r && r < q in
let is_s_valid = 0 < s && s < q in
if not (Some? pk && is_r_valid && is_s_valid) then false
else begin
assert_norm (q < pow2 256);
let sinv = qinv s in
let u1 = z *^ sinv in
let u2 = r *^ sinv in
let _X, _Y, _Z = point_mul_double_g u1 u2 (Some?.v pk) in
if is_proj_point_at_inf (_X, _Y, _Z) then false
else begin
let x = _X /% _Z in
x % q = r end
end
(*
_Z <> 0
q < prime < 2 * q
let x = _X /% _Z in x % q = r <==>
1. x = r <==> _X = r *% _Z
2. x - q = r <==> _X = (r + q) *% _Z
*)
/// ECDSA using SHA2-256
let _: squash(Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32) =
assert_norm (Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32)
let ecdsa_sign_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (private_key nonce:lbytes 32) : option (lbytes 64) =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_sign_hashed_msg msgHash private_key nonce
let ecdsa_verify_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (public_key signature:lbytes 64) : bool =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_verify_hashed_msg msgHash public_key signature
/// ECDH over the secp256k1 elliptic curve
let secret_to_public (private_key:lbytes 32) : option (lbytes 64) =
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if is_sk_valid then
let pk = point_mul_g sk in
Some (point_store pk)
else None
let ecdh (their_public_key:lbytes 64) (private_key:lbytes 32) : option (lbytes 64) =
let pk = load_point their_public_key in
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if Some? pk && is_sk_valid then
let ss = point_mul sk (Some?.v pk) in
Some (point_store ss)
else None
/// Parsing and Serializing public keys
// raw = [ x; y ], 64 bytes
// uncompressed = [ 0x04; x; y ], 65 bytes
// compressed = [ 0x02 for even `y` and 0x03 for odd `y`; x ], 33 bytes
| false | false |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val validate_public_key (pk: lbytes 64) : bool
|
[] |
Spec.K256.validate_public_key
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
pk: Lib.ByteSequence.lbytes 64 -> Prims.bool
|
{
"end_col": 23,
"end_line": 184,
"start_col": 2,
"start_line": 184
}
|
Prims.Tot
|
val ecdsa_verify_sha256 (msg_len: size_nat) (msg: lbytes msg_len) (public_key signature: lbytes 64)
: bool
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let ecdsa_verify_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (public_key signature:lbytes 64) : bool =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_verify_hashed_msg msgHash public_key signature
|
val ecdsa_verify_sha256 (msg_len: size_nat) (msg: lbytes msg_len) (public_key signature: lbytes 64)
: bool
let ecdsa_verify_sha256 (msg_len: size_nat) (msg: lbytes msg_len) (public_key signature: lbytes 64)
: bool =
| false | null | false |
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_verify_hashed_msg msgHash public_key signature
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Lib.IntTypes.size_nat",
"Lib.ByteSequence.lbytes",
"Spec.K256.ecdsa_verify_hashed_msg",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.Hash.Definitions.hash_length'",
"Spec.Hash.Definitions.SHA2_256",
"Spec.Agile.Hash.hash",
"Prims.bool"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
let mk_k256_abelian_group : LE.abelian_group aff_point = {
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma;
}
let mk_to_k256_comm_monoid : SE.to_comm_monoid proj_point = {
SE.a_spec = aff_point;
SE.comm_monoid = mk_k256_comm_monoid;
SE.refl = to_aff_point;
}
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
let point_at_inf_c _ =
KL.to_aff_point_at_infinity_lemma ();
point_at_inf
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
let point_add_c p q =
KL.to_aff_point_add_lemma p q;
point_add p q
val point_double_c : SE.sqr_st proj_point mk_to_k256_comm_monoid
let point_double_c p =
KL.to_aff_point_double_lemma p;
point_double p
let mk_k256_concrete_ops : SE.concrete_ops proj_point = {
SE.to = mk_to_k256_comm_monoid;
SE.one = point_at_inf_c;
SE.mul = point_add_c;
SE.sqr = point_double_c;
}
// [a]P in affine coordinates
let aff_point_mul (a:nat) (p:aff_point) : aff_point =
LE.pow mk_k256_comm_monoid p a
// [a]P
let point_mul (a:qelem) (p:proj_point) : proj_point =
SE.exp_fw mk_k256_concrete_ops p 256 a 4
// [a1]P1 + [a2]P2
let point_mul_double (a1:qelem) (p1:proj_point) (a2:qelem) (p2:proj_point) : proj_point =
SE.exp_double_fw mk_k256_concrete_ops p1 256 a1 p2 a2 5
// [a]G
let point_mul_g (a:qelem) : proj_point = point_mul a g
// [a1]G + [a2]P
let point_mul_double_g (a1:qelem) (a2:qelem) (p:proj_point) : proj_point =
point_mul_double a1 g a2 p
/// ECDSA with a prehashed message
let ecdsa_sign_hashed_msg (msgHash private_key nonce:lbytes 32) : option (lbytes 64) =
let k_q = nat_from_bytes_be nonce in
let d_a = nat_from_bytes_be private_key in
let z = nat_from_bytes_be msgHash % q in
let is_privkey_valid = 0 < d_a && d_a < q in
let is_nonce_valid = 0 < k_q && k_q < q in
if not (is_privkey_valid && is_nonce_valid) then None
else begin
let _X, _Y, _Z = point_mul_g k_q in
let x = _X /% _Z in
let r = x % q in
let kinv = qinv k_q in
let s = kinv *^ (z +^ r *^ d_a) in
let rb = nat_to_bytes_be 32 r in
let sb = nat_to_bytes_be 32 s in
if r = 0 || s = 0 then None else Some (concat #_ #32 #32 rb sb) end
let ecdsa_verify_hashed_msg (msgHash:lbytes 32) (public_key signature:lbytes 64) : bool =
let pk = load_point public_key in
let r = nat_from_bytes_be (sub signature 0 32) in
let s = nat_from_bytes_be (sub signature 32 32) in
let z = nat_from_bytes_be msgHash % q in
let is_r_valid = 0 < r && r < q in
let is_s_valid = 0 < s && s < q in
if not (Some? pk && is_r_valid && is_s_valid) then false
else begin
assert_norm (q < pow2 256);
let sinv = qinv s in
let u1 = z *^ sinv in
let u2 = r *^ sinv in
let _X, _Y, _Z = point_mul_double_g u1 u2 (Some?.v pk) in
if is_proj_point_at_inf (_X, _Y, _Z) then false
else begin
let x = _X /% _Z in
x % q = r end
end
(*
_Z <> 0
q < prime < 2 * q
let x = _X /% _Z in x % q = r <==>
1. x = r <==> _X = r *% _Z
2. x - q = r <==> _X = (r + q) *% _Z
*)
/// ECDSA using SHA2-256
let _: squash(Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32) =
assert_norm (Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32)
let ecdsa_sign_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (private_key nonce:lbytes 32) : option (lbytes 64) =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_sign_hashed_msg msgHash private_key nonce
| false | false |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val ecdsa_verify_sha256 (msg_len: size_nat) (msg: lbytes msg_len) (public_key signature: lbytes 64)
: bool
|
[] |
Spec.K256.ecdsa_verify_sha256
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
msg_len: Lib.IntTypes.size_nat ->
msg: Lib.ByteSequence.lbytes msg_len ->
public_key: Lib.ByteSequence.lbytes 64 ->
signature: Lib.ByteSequence.lbytes 64
-> Prims.bool
|
{
"end_col": 54,
"end_line": 153,
"start_col": 105,
"start_line": 151
}
|
Prims.Tot
|
val secret_to_public (private_key: lbytes 32) : option (lbytes 64)
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let secret_to_public (private_key:lbytes 32) : option (lbytes 64) =
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if is_sk_valid then
let pk = point_mul_g sk in
Some (point_store pk)
else None
|
val secret_to_public (private_key: lbytes 32) : option (lbytes 64)
let secret_to_public (private_key: lbytes 32) : option (lbytes 64) =
| false | null | false |
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if is_sk_valid
then
let pk = point_mul_g sk in
Some (point_store pk)
else None
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Lib.ByteSequence.lbytes",
"FStar.Pervasives.Native.Some",
"Spec.K256.PointOps.point_store",
"Spec.K256.PointOps.proj_point",
"Spec.K256.point_mul_g",
"Prims.bool",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"Spec.K256.PointOps.q",
"Prims.nat",
"Prims.b2t",
"Prims.pow2",
"Prims.op_Multiply",
"Lib.Sequence.length",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.ByteSequence.nat_from_bytes_be"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
let mk_k256_abelian_group : LE.abelian_group aff_point = {
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma;
}
let mk_to_k256_comm_monoid : SE.to_comm_monoid proj_point = {
SE.a_spec = aff_point;
SE.comm_monoid = mk_k256_comm_monoid;
SE.refl = to_aff_point;
}
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
let point_at_inf_c _ =
KL.to_aff_point_at_infinity_lemma ();
point_at_inf
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
let point_add_c p q =
KL.to_aff_point_add_lemma p q;
point_add p q
val point_double_c : SE.sqr_st proj_point mk_to_k256_comm_monoid
let point_double_c p =
KL.to_aff_point_double_lemma p;
point_double p
let mk_k256_concrete_ops : SE.concrete_ops proj_point = {
SE.to = mk_to_k256_comm_monoid;
SE.one = point_at_inf_c;
SE.mul = point_add_c;
SE.sqr = point_double_c;
}
// [a]P in affine coordinates
let aff_point_mul (a:nat) (p:aff_point) : aff_point =
LE.pow mk_k256_comm_monoid p a
// [a]P
let point_mul (a:qelem) (p:proj_point) : proj_point =
SE.exp_fw mk_k256_concrete_ops p 256 a 4
// [a1]P1 + [a2]P2
let point_mul_double (a1:qelem) (p1:proj_point) (a2:qelem) (p2:proj_point) : proj_point =
SE.exp_double_fw mk_k256_concrete_ops p1 256 a1 p2 a2 5
// [a]G
let point_mul_g (a:qelem) : proj_point = point_mul a g
// [a1]G + [a2]P
let point_mul_double_g (a1:qelem) (a2:qelem) (p:proj_point) : proj_point =
point_mul_double a1 g a2 p
/// ECDSA with a prehashed message
let ecdsa_sign_hashed_msg (msgHash private_key nonce:lbytes 32) : option (lbytes 64) =
let k_q = nat_from_bytes_be nonce in
let d_a = nat_from_bytes_be private_key in
let z = nat_from_bytes_be msgHash % q in
let is_privkey_valid = 0 < d_a && d_a < q in
let is_nonce_valid = 0 < k_q && k_q < q in
if not (is_privkey_valid && is_nonce_valid) then None
else begin
let _X, _Y, _Z = point_mul_g k_q in
let x = _X /% _Z in
let r = x % q in
let kinv = qinv k_q in
let s = kinv *^ (z +^ r *^ d_a) in
let rb = nat_to_bytes_be 32 r in
let sb = nat_to_bytes_be 32 s in
if r = 0 || s = 0 then None else Some (concat #_ #32 #32 rb sb) end
let ecdsa_verify_hashed_msg (msgHash:lbytes 32) (public_key signature:lbytes 64) : bool =
let pk = load_point public_key in
let r = nat_from_bytes_be (sub signature 0 32) in
let s = nat_from_bytes_be (sub signature 32 32) in
let z = nat_from_bytes_be msgHash % q in
let is_r_valid = 0 < r && r < q in
let is_s_valid = 0 < s && s < q in
if not (Some? pk && is_r_valid && is_s_valid) then false
else begin
assert_norm (q < pow2 256);
let sinv = qinv s in
let u1 = z *^ sinv in
let u2 = r *^ sinv in
let _X, _Y, _Z = point_mul_double_g u1 u2 (Some?.v pk) in
if is_proj_point_at_inf (_X, _Y, _Z) then false
else begin
let x = _X /% _Z in
x % q = r end
end
(*
_Z <> 0
q < prime < 2 * q
let x = _X /% _Z in x % q = r <==>
1. x = r <==> _X = r *% _Z
2. x - q = r <==> _X = (r + q) *% _Z
*)
/// ECDSA using SHA2-256
let _: squash(Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32) =
assert_norm (Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32)
let ecdsa_sign_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (private_key nonce:lbytes 32) : option (lbytes 64) =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_sign_hashed_msg msgHash private_key nonce
let ecdsa_verify_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (public_key signature:lbytes 64) : bool =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_verify_hashed_msg msgHash public_key signature
/// ECDH over the secp256k1 elliptic curve
| false | false |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val secret_to_public (private_key: lbytes 32) : option (lbytes 64)
|
[] |
Spec.K256.secret_to_public
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
private_key: Lib.ByteSequence.lbytes 32
-> FStar.Pervasives.Native.option (Lib.ByteSequence.lbytes 64)
|
{
"end_col": 11,
"end_line": 164,
"start_col": 67,
"start_line": 158
}
|
Prims.Tot
|
val ecdh (their_public_key: lbytes 64) (private_key: lbytes 32) : option (lbytes 64)
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let ecdh (their_public_key:lbytes 64) (private_key:lbytes 32) : option (lbytes 64) =
let pk = load_point their_public_key in
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if Some? pk && is_sk_valid then
let ss = point_mul sk (Some?.v pk) in
Some (point_store ss)
else None
|
val ecdh (their_public_key: lbytes 64) (private_key: lbytes 32) : option (lbytes 64)
let ecdh (their_public_key: lbytes 64) (private_key: lbytes 32) : option (lbytes 64) =
| false | null | false |
let pk = load_point their_public_key in
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if Some? pk && is_sk_valid
then
let ss = point_mul sk (Some?.v pk) in
Some (point_store ss)
else None
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Lib.ByteSequence.lbytes",
"Prims.op_AmpAmp",
"FStar.Pervasives.Native.uu___is_Some",
"Spec.K256.PointOps.proj_point",
"FStar.Pervasives.Native.Some",
"Spec.K256.PointOps.point_store",
"Spec.K256.point_mul",
"FStar.Pervasives.Native.__proj__Some__item__v",
"Prims.bool",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option",
"Prims.op_LessThan",
"Spec.K256.PointOps.q",
"Prims.nat",
"Prims.b2t",
"Prims.pow2",
"Prims.op_Multiply",
"Lib.Sequence.length",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.ByteSequence.nat_from_bytes_be",
"Spec.K256.PointOps.load_point"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
let mk_k256_abelian_group : LE.abelian_group aff_point = {
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma;
}
let mk_to_k256_comm_monoid : SE.to_comm_monoid proj_point = {
SE.a_spec = aff_point;
SE.comm_monoid = mk_k256_comm_monoid;
SE.refl = to_aff_point;
}
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
let point_at_inf_c _ =
KL.to_aff_point_at_infinity_lemma ();
point_at_inf
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
let point_add_c p q =
KL.to_aff_point_add_lemma p q;
point_add p q
val point_double_c : SE.sqr_st proj_point mk_to_k256_comm_monoid
let point_double_c p =
KL.to_aff_point_double_lemma p;
point_double p
let mk_k256_concrete_ops : SE.concrete_ops proj_point = {
SE.to = mk_to_k256_comm_monoid;
SE.one = point_at_inf_c;
SE.mul = point_add_c;
SE.sqr = point_double_c;
}
// [a]P in affine coordinates
let aff_point_mul (a:nat) (p:aff_point) : aff_point =
LE.pow mk_k256_comm_monoid p a
// [a]P
let point_mul (a:qelem) (p:proj_point) : proj_point =
SE.exp_fw mk_k256_concrete_ops p 256 a 4
// [a1]P1 + [a2]P2
let point_mul_double (a1:qelem) (p1:proj_point) (a2:qelem) (p2:proj_point) : proj_point =
SE.exp_double_fw mk_k256_concrete_ops p1 256 a1 p2 a2 5
// [a]G
let point_mul_g (a:qelem) : proj_point = point_mul a g
// [a1]G + [a2]P
let point_mul_double_g (a1:qelem) (a2:qelem) (p:proj_point) : proj_point =
point_mul_double a1 g a2 p
/// ECDSA with a prehashed message
let ecdsa_sign_hashed_msg (msgHash private_key nonce:lbytes 32) : option (lbytes 64) =
let k_q = nat_from_bytes_be nonce in
let d_a = nat_from_bytes_be private_key in
let z = nat_from_bytes_be msgHash % q in
let is_privkey_valid = 0 < d_a && d_a < q in
let is_nonce_valid = 0 < k_q && k_q < q in
if not (is_privkey_valid && is_nonce_valid) then None
else begin
let _X, _Y, _Z = point_mul_g k_q in
let x = _X /% _Z in
let r = x % q in
let kinv = qinv k_q in
let s = kinv *^ (z +^ r *^ d_a) in
let rb = nat_to_bytes_be 32 r in
let sb = nat_to_bytes_be 32 s in
if r = 0 || s = 0 then None else Some (concat #_ #32 #32 rb sb) end
let ecdsa_verify_hashed_msg (msgHash:lbytes 32) (public_key signature:lbytes 64) : bool =
let pk = load_point public_key in
let r = nat_from_bytes_be (sub signature 0 32) in
let s = nat_from_bytes_be (sub signature 32 32) in
let z = nat_from_bytes_be msgHash % q in
let is_r_valid = 0 < r && r < q in
let is_s_valid = 0 < s && s < q in
if not (Some? pk && is_r_valid && is_s_valid) then false
else begin
assert_norm (q < pow2 256);
let sinv = qinv s in
let u1 = z *^ sinv in
let u2 = r *^ sinv in
let _X, _Y, _Z = point_mul_double_g u1 u2 (Some?.v pk) in
if is_proj_point_at_inf (_X, _Y, _Z) then false
else begin
let x = _X /% _Z in
x % q = r end
end
(*
_Z <> 0
q < prime < 2 * q
let x = _X /% _Z in x % q = r <==>
1. x = r <==> _X = r *% _Z
2. x - q = r <==> _X = (r + q) *% _Z
*)
/// ECDSA using SHA2-256
let _: squash(Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32) =
assert_norm (Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32)
let ecdsa_sign_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (private_key nonce:lbytes 32) : option (lbytes 64) =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_sign_hashed_msg msgHash private_key nonce
let ecdsa_verify_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (public_key signature:lbytes 64) : bool =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_verify_hashed_msg msgHash public_key signature
/// ECDH over the secp256k1 elliptic curve
let secret_to_public (private_key:lbytes 32) : option (lbytes 64) =
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if is_sk_valid then
let pk = point_mul_g sk in
Some (point_store pk)
else None
| false | false |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val ecdh (their_public_key: lbytes 64) (private_key: lbytes 32) : option (lbytes 64)
|
[] |
Spec.K256.ecdh
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
their_public_key: Lib.ByteSequence.lbytes 64 -> private_key: Lib.ByteSequence.lbytes 32
-> FStar.Pervasives.Native.option (Lib.ByteSequence.lbytes 64)
|
{
"end_col": 11,
"end_line": 174,
"start_col": 84,
"start_line": 167
}
|
Prims.Tot
|
val ecdsa_sign_sha256 (msg_len: size_nat) (msg: lbytes msg_len) (private_key nonce: lbytes 32)
: option (lbytes 64)
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let ecdsa_sign_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (private_key nonce:lbytes 32) : option (lbytes 64) =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_sign_hashed_msg msgHash private_key nonce
|
val ecdsa_sign_sha256 (msg_len: size_nat) (msg: lbytes msg_len) (private_key nonce: lbytes 32)
: option (lbytes 64)
let ecdsa_sign_sha256 (msg_len: size_nat) (msg: lbytes msg_len) (private_key nonce: lbytes 32)
: option (lbytes 64) =
| false | null | false |
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_sign_hashed_msg msgHash private_key nonce
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Lib.IntTypes.size_nat",
"Lib.ByteSequence.lbytes",
"Spec.K256.ecdsa_sign_hashed_msg",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.Hash.Definitions.hash_length'",
"Spec.Hash.Definitions.SHA2_256",
"Spec.Agile.Hash.hash",
"FStar.Pervasives.Native.option"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
let mk_k256_abelian_group : LE.abelian_group aff_point = {
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma;
}
let mk_to_k256_comm_monoid : SE.to_comm_monoid proj_point = {
SE.a_spec = aff_point;
SE.comm_monoid = mk_k256_comm_monoid;
SE.refl = to_aff_point;
}
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
let point_at_inf_c _ =
KL.to_aff_point_at_infinity_lemma ();
point_at_inf
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
let point_add_c p q =
KL.to_aff_point_add_lemma p q;
point_add p q
val point_double_c : SE.sqr_st proj_point mk_to_k256_comm_monoid
let point_double_c p =
KL.to_aff_point_double_lemma p;
point_double p
let mk_k256_concrete_ops : SE.concrete_ops proj_point = {
SE.to = mk_to_k256_comm_monoid;
SE.one = point_at_inf_c;
SE.mul = point_add_c;
SE.sqr = point_double_c;
}
// [a]P in affine coordinates
let aff_point_mul (a:nat) (p:aff_point) : aff_point =
LE.pow mk_k256_comm_monoid p a
// [a]P
let point_mul (a:qelem) (p:proj_point) : proj_point =
SE.exp_fw mk_k256_concrete_ops p 256 a 4
// [a1]P1 + [a2]P2
let point_mul_double (a1:qelem) (p1:proj_point) (a2:qelem) (p2:proj_point) : proj_point =
SE.exp_double_fw mk_k256_concrete_ops p1 256 a1 p2 a2 5
// [a]G
let point_mul_g (a:qelem) : proj_point = point_mul a g
// [a1]G + [a2]P
let point_mul_double_g (a1:qelem) (a2:qelem) (p:proj_point) : proj_point =
point_mul_double a1 g a2 p
/// ECDSA with a prehashed message
let ecdsa_sign_hashed_msg (msgHash private_key nonce:lbytes 32) : option (lbytes 64) =
let k_q = nat_from_bytes_be nonce in
let d_a = nat_from_bytes_be private_key in
let z = nat_from_bytes_be msgHash % q in
let is_privkey_valid = 0 < d_a && d_a < q in
let is_nonce_valid = 0 < k_q && k_q < q in
if not (is_privkey_valid && is_nonce_valid) then None
else begin
let _X, _Y, _Z = point_mul_g k_q in
let x = _X /% _Z in
let r = x % q in
let kinv = qinv k_q in
let s = kinv *^ (z +^ r *^ d_a) in
let rb = nat_to_bytes_be 32 r in
let sb = nat_to_bytes_be 32 s in
if r = 0 || s = 0 then None else Some (concat #_ #32 #32 rb sb) end
let ecdsa_verify_hashed_msg (msgHash:lbytes 32) (public_key signature:lbytes 64) : bool =
let pk = load_point public_key in
let r = nat_from_bytes_be (sub signature 0 32) in
let s = nat_from_bytes_be (sub signature 32 32) in
let z = nat_from_bytes_be msgHash % q in
let is_r_valid = 0 < r && r < q in
let is_s_valid = 0 < s && s < q in
if not (Some? pk && is_r_valid && is_s_valid) then false
else begin
assert_norm (q < pow2 256);
let sinv = qinv s in
let u1 = z *^ sinv in
let u2 = r *^ sinv in
let _X, _Y, _Z = point_mul_double_g u1 u2 (Some?.v pk) in
if is_proj_point_at_inf (_X, _Y, _Z) then false
else begin
let x = _X /% _Z in
x % q = r end
end
(*
_Z <> 0
q < prime < 2 * q
let x = _X /% _Z in x % q = r <==>
1. x = r <==> _X = r *% _Z
2. x - q = r <==> _X = (r + q) *% _Z
*)
/// ECDSA using SHA2-256
let _: squash(Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32) =
assert_norm (Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32)
| false | false |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val ecdsa_sign_sha256 (msg_len: size_nat) (msg: lbytes msg_len) (private_key nonce: lbytes 32)
: option (lbytes 64)
|
[] |
Spec.K256.ecdsa_sign_sha256
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
msg_len: Lib.IntTypes.size_nat ->
msg: Lib.ByteSequence.lbytes msg_len ->
private_key: Lib.ByteSequence.lbytes 32 ->
nonce: Lib.ByteSequence.lbytes 32
-> FStar.Pervasives.Native.option (Lib.ByteSequence.lbytes 64)
|
{
"end_col": 49,
"end_line": 148,
"start_col": 114,
"start_line": 146
}
|
Prims.Tot
|
val secp256k1_ecdsa_verify_sha256
(msg_len: size_nat)
(msg: lbytes msg_len)
(public_key signature: lbytes 64)
: bool
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let secp256k1_ecdsa_verify_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (public_key signature:lbytes 64) : bool =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
secp256k1_ecdsa_verify_hashed_msg msgHash public_key signature
|
val secp256k1_ecdsa_verify_sha256
(msg_len: size_nat)
(msg: lbytes msg_len)
(public_key signature: lbytes 64)
: bool
let secp256k1_ecdsa_verify_sha256
(msg_len: size_nat)
(msg: lbytes msg_len)
(public_key signature: lbytes 64)
: bool =
| false | null | false |
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
secp256k1_ecdsa_verify_hashed_msg msgHash public_key signature
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Lib.IntTypes.size_nat",
"Lib.ByteSequence.lbytes",
"Spec.K256.secp256k1_ecdsa_verify_hashed_msg",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.Hash.Definitions.hash_length'",
"Spec.Hash.Definitions.SHA2_256",
"Spec.Agile.Hash.hash",
"Prims.bool"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
let mk_k256_abelian_group : LE.abelian_group aff_point = {
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma;
}
let mk_to_k256_comm_monoid : SE.to_comm_monoid proj_point = {
SE.a_spec = aff_point;
SE.comm_monoid = mk_k256_comm_monoid;
SE.refl = to_aff_point;
}
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
let point_at_inf_c _ =
KL.to_aff_point_at_infinity_lemma ();
point_at_inf
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
let point_add_c p q =
KL.to_aff_point_add_lemma p q;
point_add p q
val point_double_c : SE.sqr_st proj_point mk_to_k256_comm_monoid
let point_double_c p =
KL.to_aff_point_double_lemma p;
point_double p
let mk_k256_concrete_ops : SE.concrete_ops proj_point = {
SE.to = mk_to_k256_comm_monoid;
SE.one = point_at_inf_c;
SE.mul = point_add_c;
SE.sqr = point_double_c;
}
// [a]P in affine coordinates
let aff_point_mul (a:nat) (p:aff_point) : aff_point =
LE.pow mk_k256_comm_monoid p a
// [a]P
let point_mul (a:qelem) (p:proj_point) : proj_point =
SE.exp_fw mk_k256_concrete_ops p 256 a 4
// [a1]P1 + [a2]P2
let point_mul_double (a1:qelem) (p1:proj_point) (a2:qelem) (p2:proj_point) : proj_point =
SE.exp_double_fw mk_k256_concrete_ops p1 256 a1 p2 a2 5
// [a]G
let point_mul_g (a:qelem) : proj_point = point_mul a g
// [a1]G + [a2]P
let point_mul_double_g (a1:qelem) (a2:qelem) (p:proj_point) : proj_point =
point_mul_double a1 g a2 p
/// ECDSA with a prehashed message
let ecdsa_sign_hashed_msg (msgHash private_key nonce:lbytes 32) : option (lbytes 64) =
let k_q = nat_from_bytes_be nonce in
let d_a = nat_from_bytes_be private_key in
let z = nat_from_bytes_be msgHash % q in
let is_privkey_valid = 0 < d_a && d_a < q in
let is_nonce_valid = 0 < k_q && k_q < q in
if not (is_privkey_valid && is_nonce_valid) then None
else begin
let _X, _Y, _Z = point_mul_g k_q in
let x = _X /% _Z in
let r = x % q in
let kinv = qinv k_q in
let s = kinv *^ (z +^ r *^ d_a) in
let rb = nat_to_bytes_be 32 r in
let sb = nat_to_bytes_be 32 s in
if r = 0 || s = 0 then None else Some (concat #_ #32 #32 rb sb) end
let ecdsa_verify_hashed_msg (msgHash:lbytes 32) (public_key signature:lbytes 64) : bool =
let pk = load_point public_key in
let r = nat_from_bytes_be (sub signature 0 32) in
let s = nat_from_bytes_be (sub signature 32 32) in
let z = nat_from_bytes_be msgHash % q in
let is_r_valid = 0 < r && r < q in
let is_s_valid = 0 < s && s < q in
if not (Some? pk && is_r_valid && is_s_valid) then false
else begin
assert_norm (q < pow2 256);
let sinv = qinv s in
let u1 = z *^ sinv in
let u2 = r *^ sinv in
let _X, _Y, _Z = point_mul_double_g u1 u2 (Some?.v pk) in
if is_proj_point_at_inf (_X, _Y, _Z) then false
else begin
let x = _X /% _Z in
x % q = r end
end
(*
_Z <> 0
q < prime < 2 * q
let x = _X /% _Z in x % q = r <==>
1. x = r <==> _X = r *% _Z
2. x - q = r <==> _X = (r + q) *% _Z
*)
/// ECDSA using SHA2-256
let _: squash(Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32) =
assert_norm (Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32)
let ecdsa_sign_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (private_key nonce:lbytes 32) : option (lbytes 64) =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_sign_hashed_msg msgHash private_key nonce
let ecdsa_verify_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (public_key signature:lbytes 64) : bool =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_verify_hashed_msg msgHash public_key signature
/// ECDH over the secp256k1 elliptic curve
let secret_to_public (private_key:lbytes 32) : option (lbytes 64) =
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if is_sk_valid then
let pk = point_mul_g sk in
Some (point_store pk)
else None
let ecdh (their_public_key:lbytes 64) (private_key:lbytes 32) : option (lbytes 64) =
let pk = load_point their_public_key in
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if Some? pk && is_sk_valid then
let ss = point_mul sk (Some?.v pk) in
Some (point_store ss)
else None
/// Parsing and Serializing public keys
// raw = [ x; y ], 64 bytes
// uncompressed = [ 0x04; x; y ], 65 bytes
// compressed = [ 0x02 for even `y` and 0x03 for odd `y`; x ], 33 bytes
let validate_public_key (pk:lbytes 64) : bool =
Some? (load_point pk)
let pk_uncompressed_to_raw (pk:lbytes 65) : option (lbytes 64) =
if Lib.RawIntTypes.u8_to_UInt8 pk.[0] <> 0x04uy then None else Some (sub pk 1 64)
let pk_uncompressed_from_raw (pk:lbytes 64) : lbytes 65 =
concat (create 1 (u8 0x04)) pk
let pk_compressed_to_raw (pk:lbytes 33) : option (lbytes 64) =
let pk_x = sub pk 1 32 in
match (aff_point_decompress pk) with
| Some (x, y) -> Some (concat #_ #32 #32 pk_x (nat_to_bytes_be 32 y))
| None -> None
let pk_compressed_from_raw (pk:lbytes 64) : lbytes 33 =
let pk_x = sub pk 0 32 in
let pk_y = sub pk 32 32 in
let is_pk_y_odd = nat_from_bytes_be pk_y % 2 = 1 in // <==> pk_y % 2 = 1
let pk0 = if is_pk_y_odd then u8 0x03 else u8 0x02 in
concat (create 1 pk0) pk_x
/// Low-S normalization
(**
https://en.bitcoin.it/wiki/BIP_0062
https://yondon.blog/2019/01/01/how-not-to-use-ecdsa/
https://eklitzke.org/bitcoin-transaction-malleability
*)
// The value S in signatures must be between 0x1 and q / 2 (inclusive).
// If S is too high, simply replace it by S' = q - S.
let secp256k1_ecdsa_signature_normalize (signature:lbytes 64) : option (lbytes 64) =
let sn = nat_from_bytes_be (sub signature 32 32) in
let is_sn_valid = 0 < sn && sn < q in
if is_sn_valid then begin
let sn = if sn <= q / 2 then sn else (q - sn) % q in
let sgnt = update_sub signature 32 32 (nat_to_bytes_be 32 sn) in
Some sgnt end
else None
let secp256k1_ecdsa_is_signature_normalized (signature:lbytes 64) : bool =
let sn = nat_from_bytes_be (sub signature 32 32) in
0 < sn && sn <= q / 2
let secp256k1_ecdsa_sign_hashed_msg (msgHash private_key nonce:lbytes 32) : option (lbytes 64) =
let signature = ecdsa_sign_hashed_msg msgHash private_key nonce in
match signature with
| Some x -> secp256k1_ecdsa_signature_normalize x
| None -> None
let secp256k1_ecdsa_sign_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (private_key nonce:lbytes 32) : option (lbytes 64) =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
secp256k1_ecdsa_sign_hashed_msg msgHash private_key nonce
let secp256k1_ecdsa_verify_hashed_msg (msgHash:lbytes 32) (public_key signature:lbytes 64) : bool =
if not (secp256k1_ecdsa_is_signature_normalized signature) then false
else ecdsa_verify_hashed_msg msgHash public_key signature
| false | false |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val secp256k1_ecdsa_verify_sha256
(msg_len: size_nat)
(msg: lbytes msg_len)
(public_key signature: lbytes 64)
: bool
|
[] |
Spec.K256.secp256k1_ecdsa_verify_sha256
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
msg_len: Lib.IntTypes.size_nat ->
msg: Lib.ByteSequence.lbytes msg_len ->
public_key: Lib.ByteSequence.lbytes 64 ->
signature: Lib.ByteSequence.lbytes 64
-> Prims.bool
|
{
"end_col": 64,
"end_line": 252,
"start_col": 115,
"start_line": 250
}
|
Prims.Tot
|
val pk_compressed_to_raw (pk: lbytes 33) : option (lbytes 64)
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let pk_compressed_to_raw (pk:lbytes 33) : option (lbytes 64) =
let pk_x = sub pk 1 32 in
match (aff_point_decompress pk) with
| Some (x, y) -> Some (concat #_ #32 #32 pk_x (nat_to_bytes_be 32 y))
| None -> None
|
val pk_compressed_to_raw (pk: lbytes 33) : option (lbytes 64)
let pk_compressed_to_raw (pk: lbytes 33) : option (lbytes 64) =
| false | null | false |
let pk_x = sub pk 1 32 in
match (aff_point_decompress pk) with
| Some (x, y) -> Some (concat #_ #32 #32 pk_x (nat_to_bytes_be 32 y))
| None -> None
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Lib.ByteSequence.lbytes",
"Spec.K256.PointOps.aff_point_decompress",
"Spec.K256.PointOps.felem",
"FStar.Pervasives.Native.Some",
"Lib.Sequence.concat",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.ByteSequence.nat_to_bytes_be",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"Prims.l_Forall",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.Sequence.sub"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
let mk_k256_abelian_group : LE.abelian_group aff_point = {
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma;
}
let mk_to_k256_comm_monoid : SE.to_comm_monoid proj_point = {
SE.a_spec = aff_point;
SE.comm_monoid = mk_k256_comm_monoid;
SE.refl = to_aff_point;
}
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
let point_at_inf_c _ =
KL.to_aff_point_at_infinity_lemma ();
point_at_inf
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
let point_add_c p q =
KL.to_aff_point_add_lemma p q;
point_add p q
val point_double_c : SE.sqr_st proj_point mk_to_k256_comm_monoid
let point_double_c p =
KL.to_aff_point_double_lemma p;
point_double p
let mk_k256_concrete_ops : SE.concrete_ops proj_point = {
SE.to = mk_to_k256_comm_monoid;
SE.one = point_at_inf_c;
SE.mul = point_add_c;
SE.sqr = point_double_c;
}
// [a]P in affine coordinates
let aff_point_mul (a:nat) (p:aff_point) : aff_point =
LE.pow mk_k256_comm_monoid p a
// [a]P
let point_mul (a:qelem) (p:proj_point) : proj_point =
SE.exp_fw mk_k256_concrete_ops p 256 a 4
// [a1]P1 + [a2]P2
let point_mul_double (a1:qelem) (p1:proj_point) (a2:qelem) (p2:proj_point) : proj_point =
SE.exp_double_fw mk_k256_concrete_ops p1 256 a1 p2 a2 5
// [a]G
let point_mul_g (a:qelem) : proj_point = point_mul a g
// [a1]G + [a2]P
let point_mul_double_g (a1:qelem) (a2:qelem) (p:proj_point) : proj_point =
point_mul_double a1 g a2 p
/// ECDSA with a prehashed message
let ecdsa_sign_hashed_msg (msgHash private_key nonce:lbytes 32) : option (lbytes 64) =
let k_q = nat_from_bytes_be nonce in
let d_a = nat_from_bytes_be private_key in
let z = nat_from_bytes_be msgHash % q in
let is_privkey_valid = 0 < d_a && d_a < q in
let is_nonce_valid = 0 < k_q && k_q < q in
if not (is_privkey_valid && is_nonce_valid) then None
else begin
let _X, _Y, _Z = point_mul_g k_q in
let x = _X /% _Z in
let r = x % q in
let kinv = qinv k_q in
let s = kinv *^ (z +^ r *^ d_a) in
let rb = nat_to_bytes_be 32 r in
let sb = nat_to_bytes_be 32 s in
if r = 0 || s = 0 then None else Some (concat #_ #32 #32 rb sb) end
let ecdsa_verify_hashed_msg (msgHash:lbytes 32) (public_key signature:lbytes 64) : bool =
let pk = load_point public_key in
let r = nat_from_bytes_be (sub signature 0 32) in
let s = nat_from_bytes_be (sub signature 32 32) in
let z = nat_from_bytes_be msgHash % q in
let is_r_valid = 0 < r && r < q in
let is_s_valid = 0 < s && s < q in
if not (Some? pk && is_r_valid && is_s_valid) then false
else begin
assert_norm (q < pow2 256);
let sinv = qinv s in
let u1 = z *^ sinv in
let u2 = r *^ sinv in
let _X, _Y, _Z = point_mul_double_g u1 u2 (Some?.v pk) in
if is_proj_point_at_inf (_X, _Y, _Z) then false
else begin
let x = _X /% _Z in
x % q = r end
end
(*
_Z <> 0
q < prime < 2 * q
let x = _X /% _Z in x % q = r <==>
1. x = r <==> _X = r *% _Z
2. x - q = r <==> _X = (r + q) *% _Z
*)
/// ECDSA using SHA2-256
let _: squash(Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32) =
assert_norm (Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32)
let ecdsa_sign_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (private_key nonce:lbytes 32) : option (lbytes 64) =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_sign_hashed_msg msgHash private_key nonce
let ecdsa_verify_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (public_key signature:lbytes 64) : bool =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_verify_hashed_msg msgHash public_key signature
/// ECDH over the secp256k1 elliptic curve
let secret_to_public (private_key:lbytes 32) : option (lbytes 64) =
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if is_sk_valid then
let pk = point_mul_g sk in
Some (point_store pk)
else None
let ecdh (their_public_key:lbytes 64) (private_key:lbytes 32) : option (lbytes 64) =
let pk = load_point their_public_key in
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if Some? pk && is_sk_valid then
let ss = point_mul sk (Some?.v pk) in
Some (point_store ss)
else None
/// Parsing and Serializing public keys
// raw = [ x; y ], 64 bytes
// uncompressed = [ 0x04; x; y ], 65 bytes
// compressed = [ 0x02 for even `y` and 0x03 for odd `y`; x ], 33 bytes
let validate_public_key (pk:lbytes 64) : bool =
Some? (load_point pk)
let pk_uncompressed_to_raw (pk:lbytes 65) : option (lbytes 64) =
if Lib.RawIntTypes.u8_to_UInt8 pk.[0] <> 0x04uy then None else Some (sub pk 1 64)
let pk_uncompressed_from_raw (pk:lbytes 64) : lbytes 65 =
concat (create 1 (u8 0x04)) pk
| false | false |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val pk_compressed_to_raw (pk: lbytes 33) : option (lbytes 64)
|
[] |
Spec.K256.pk_compressed_to_raw
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
pk: Lib.ByteSequence.lbytes 33 -> FStar.Pervasives.Native.option (Lib.ByteSequence.lbytes 64)
|
{
"end_col": 16,
"end_line": 196,
"start_col": 62,
"start_line": 192
}
|
Prims.Tot
|
val secp256k1_ecdsa_sign_sha256
(msg_len: size_nat)
(msg: lbytes msg_len)
(private_key nonce: lbytes 32)
: option (lbytes 64)
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let secp256k1_ecdsa_sign_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (private_key nonce:lbytes 32) : option (lbytes 64) =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
secp256k1_ecdsa_sign_hashed_msg msgHash private_key nonce
|
val secp256k1_ecdsa_sign_sha256
(msg_len: size_nat)
(msg: lbytes msg_len)
(private_key nonce: lbytes 32)
: option (lbytes 64)
let secp256k1_ecdsa_sign_sha256
(msg_len: size_nat)
(msg: lbytes msg_len)
(private_key nonce: lbytes 32)
: option (lbytes 64) =
| false | null | false |
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
secp256k1_ecdsa_sign_hashed_msg msgHash private_key nonce
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Lib.IntTypes.size_nat",
"Lib.ByteSequence.lbytes",
"Spec.K256.secp256k1_ecdsa_sign_hashed_msg",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.Hash.Definitions.hash_length'",
"Spec.Hash.Definitions.SHA2_256",
"Spec.Agile.Hash.hash",
"FStar.Pervasives.Native.option"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
let mk_k256_abelian_group : LE.abelian_group aff_point = {
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma;
}
let mk_to_k256_comm_monoid : SE.to_comm_monoid proj_point = {
SE.a_spec = aff_point;
SE.comm_monoid = mk_k256_comm_monoid;
SE.refl = to_aff_point;
}
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
let point_at_inf_c _ =
KL.to_aff_point_at_infinity_lemma ();
point_at_inf
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
let point_add_c p q =
KL.to_aff_point_add_lemma p q;
point_add p q
val point_double_c : SE.sqr_st proj_point mk_to_k256_comm_monoid
let point_double_c p =
KL.to_aff_point_double_lemma p;
point_double p
let mk_k256_concrete_ops : SE.concrete_ops proj_point = {
SE.to = mk_to_k256_comm_monoid;
SE.one = point_at_inf_c;
SE.mul = point_add_c;
SE.sqr = point_double_c;
}
// [a]P in affine coordinates
let aff_point_mul (a:nat) (p:aff_point) : aff_point =
LE.pow mk_k256_comm_monoid p a
// [a]P
let point_mul (a:qelem) (p:proj_point) : proj_point =
SE.exp_fw mk_k256_concrete_ops p 256 a 4
// [a1]P1 + [a2]P2
let point_mul_double (a1:qelem) (p1:proj_point) (a2:qelem) (p2:proj_point) : proj_point =
SE.exp_double_fw mk_k256_concrete_ops p1 256 a1 p2 a2 5
// [a]G
let point_mul_g (a:qelem) : proj_point = point_mul a g
// [a1]G + [a2]P
let point_mul_double_g (a1:qelem) (a2:qelem) (p:proj_point) : proj_point =
point_mul_double a1 g a2 p
/// ECDSA with a prehashed message
let ecdsa_sign_hashed_msg (msgHash private_key nonce:lbytes 32) : option (lbytes 64) =
let k_q = nat_from_bytes_be nonce in
let d_a = nat_from_bytes_be private_key in
let z = nat_from_bytes_be msgHash % q in
let is_privkey_valid = 0 < d_a && d_a < q in
let is_nonce_valid = 0 < k_q && k_q < q in
if not (is_privkey_valid && is_nonce_valid) then None
else begin
let _X, _Y, _Z = point_mul_g k_q in
let x = _X /% _Z in
let r = x % q in
let kinv = qinv k_q in
let s = kinv *^ (z +^ r *^ d_a) in
let rb = nat_to_bytes_be 32 r in
let sb = nat_to_bytes_be 32 s in
if r = 0 || s = 0 then None else Some (concat #_ #32 #32 rb sb) end
let ecdsa_verify_hashed_msg (msgHash:lbytes 32) (public_key signature:lbytes 64) : bool =
let pk = load_point public_key in
let r = nat_from_bytes_be (sub signature 0 32) in
let s = nat_from_bytes_be (sub signature 32 32) in
let z = nat_from_bytes_be msgHash % q in
let is_r_valid = 0 < r && r < q in
let is_s_valid = 0 < s && s < q in
if not (Some? pk && is_r_valid && is_s_valid) then false
else begin
assert_norm (q < pow2 256);
let sinv = qinv s in
let u1 = z *^ sinv in
let u2 = r *^ sinv in
let _X, _Y, _Z = point_mul_double_g u1 u2 (Some?.v pk) in
if is_proj_point_at_inf (_X, _Y, _Z) then false
else begin
let x = _X /% _Z in
x % q = r end
end
(*
_Z <> 0
q < prime < 2 * q
let x = _X /% _Z in x % q = r <==>
1. x = r <==> _X = r *% _Z
2. x - q = r <==> _X = (r + q) *% _Z
*)
/// ECDSA using SHA2-256
let _: squash(Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32) =
assert_norm (Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32)
let ecdsa_sign_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (private_key nonce:lbytes 32) : option (lbytes 64) =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_sign_hashed_msg msgHash private_key nonce
let ecdsa_verify_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (public_key signature:lbytes 64) : bool =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_verify_hashed_msg msgHash public_key signature
/// ECDH over the secp256k1 elliptic curve
let secret_to_public (private_key:lbytes 32) : option (lbytes 64) =
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if is_sk_valid then
let pk = point_mul_g sk in
Some (point_store pk)
else None
let ecdh (their_public_key:lbytes 64) (private_key:lbytes 32) : option (lbytes 64) =
let pk = load_point their_public_key in
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if Some? pk && is_sk_valid then
let ss = point_mul sk (Some?.v pk) in
Some (point_store ss)
else None
/// Parsing and Serializing public keys
// raw = [ x; y ], 64 bytes
// uncompressed = [ 0x04; x; y ], 65 bytes
// compressed = [ 0x02 for even `y` and 0x03 for odd `y`; x ], 33 bytes
let validate_public_key (pk:lbytes 64) : bool =
Some? (load_point pk)
let pk_uncompressed_to_raw (pk:lbytes 65) : option (lbytes 64) =
if Lib.RawIntTypes.u8_to_UInt8 pk.[0] <> 0x04uy then None else Some (sub pk 1 64)
let pk_uncompressed_from_raw (pk:lbytes 64) : lbytes 65 =
concat (create 1 (u8 0x04)) pk
let pk_compressed_to_raw (pk:lbytes 33) : option (lbytes 64) =
let pk_x = sub pk 1 32 in
match (aff_point_decompress pk) with
| Some (x, y) -> Some (concat #_ #32 #32 pk_x (nat_to_bytes_be 32 y))
| None -> None
let pk_compressed_from_raw (pk:lbytes 64) : lbytes 33 =
let pk_x = sub pk 0 32 in
let pk_y = sub pk 32 32 in
let is_pk_y_odd = nat_from_bytes_be pk_y % 2 = 1 in // <==> pk_y % 2 = 1
let pk0 = if is_pk_y_odd then u8 0x03 else u8 0x02 in
concat (create 1 pk0) pk_x
/// Low-S normalization
(**
https://en.bitcoin.it/wiki/BIP_0062
https://yondon.blog/2019/01/01/how-not-to-use-ecdsa/
https://eklitzke.org/bitcoin-transaction-malleability
*)
// The value S in signatures must be between 0x1 and q / 2 (inclusive).
// If S is too high, simply replace it by S' = q - S.
let secp256k1_ecdsa_signature_normalize (signature:lbytes 64) : option (lbytes 64) =
let sn = nat_from_bytes_be (sub signature 32 32) in
let is_sn_valid = 0 < sn && sn < q in
if is_sn_valid then begin
let sn = if sn <= q / 2 then sn else (q - sn) % q in
let sgnt = update_sub signature 32 32 (nat_to_bytes_be 32 sn) in
Some sgnt end
else None
let secp256k1_ecdsa_is_signature_normalized (signature:lbytes 64) : bool =
let sn = nat_from_bytes_be (sub signature 32 32) in
0 < sn && sn <= q / 2
let secp256k1_ecdsa_sign_hashed_msg (msgHash private_key nonce:lbytes 32) : option (lbytes 64) =
let signature = ecdsa_sign_hashed_msg msgHash private_key nonce in
match signature with
| Some x -> secp256k1_ecdsa_signature_normalize x
| None -> None
| false | false |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val secp256k1_ecdsa_sign_sha256
(msg_len: size_nat)
(msg: lbytes msg_len)
(private_key nonce: lbytes 32)
: option (lbytes 64)
|
[] |
Spec.K256.secp256k1_ecdsa_sign_sha256
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
msg_len: Lib.IntTypes.size_nat ->
msg: Lib.ByteSequence.lbytes msg_len ->
private_key: Lib.ByteSequence.lbytes 32 ->
nonce: Lib.ByteSequence.lbytes 32
-> FStar.Pervasives.Native.option (Lib.ByteSequence.lbytes 64)
|
{
"end_col": 59,
"end_line": 242,
"start_col": 124,
"start_line": 240
}
|
Prims.Tot
|
val pk_uncompressed_from_raw (pk: lbytes 64) : lbytes 65
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let pk_uncompressed_from_raw (pk:lbytes 64) : lbytes 65 =
concat (create 1 (u8 0x04)) pk
|
val pk_uncompressed_from_raw (pk: lbytes 64) : lbytes 65
let pk_uncompressed_from_raw (pk: lbytes 64) : lbytes 65 =
| false | null | false |
concat (create 1 (u8 0x04)) pk
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Lib.ByteSequence.lbytes",
"Lib.Sequence.concat",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.Sequence.create",
"Lib.IntTypes.u8"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
let mk_k256_abelian_group : LE.abelian_group aff_point = {
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma;
}
let mk_to_k256_comm_monoid : SE.to_comm_monoid proj_point = {
SE.a_spec = aff_point;
SE.comm_monoid = mk_k256_comm_monoid;
SE.refl = to_aff_point;
}
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
let point_at_inf_c _ =
KL.to_aff_point_at_infinity_lemma ();
point_at_inf
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
let point_add_c p q =
KL.to_aff_point_add_lemma p q;
point_add p q
val point_double_c : SE.sqr_st proj_point mk_to_k256_comm_monoid
let point_double_c p =
KL.to_aff_point_double_lemma p;
point_double p
let mk_k256_concrete_ops : SE.concrete_ops proj_point = {
SE.to = mk_to_k256_comm_monoid;
SE.one = point_at_inf_c;
SE.mul = point_add_c;
SE.sqr = point_double_c;
}
// [a]P in affine coordinates
let aff_point_mul (a:nat) (p:aff_point) : aff_point =
LE.pow mk_k256_comm_monoid p a
// [a]P
let point_mul (a:qelem) (p:proj_point) : proj_point =
SE.exp_fw mk_k256_concrete_ops p 256 a 4
// [a1]P1 + [a2]P2
let point_mul_double (a1:qelem) (p1:proj_point) (a2:qelem) (p2:proj_point) : proj_point =
SE.exp_double_fw mk_k256_concrete_ops p1 256 a1 p2 a2 5
// [a]G
let point_mul_g (a:qelem) : proj_point = point_mul a g
// [a1]G + [a2]P
let point_mul_double_g (a1:qelem) (a2:qelem) (p:proj_point) : proj_point =
point_mul_double a1 g a2 p
/// ECDSA with a prehashed message
let ecdsa_sign_hashed_msg (msgHash private_key nonce:lbytes 32) : option (lbytes 64) =
let k_q = nat_from_bytes_be nonce in
let d_a = nat_from_bytes_be private_key in
let z = nat_from_bytes_be msgHash % q in
let is_privkey_valid = 0 < d_a && d_a < q in
let is_nonce_valid = 0 < k_q && k_q < q in
if not (is_privkey_valid && is_nonce_valid) then None
else begin
let _X, _Y, _Z = point_mul_g k_q in
let x = _X /% _Z in
let r = x % q in
let kinv = qinv k_q in
let s = kinv *^ (z +^ r *^ d_a) in
let rb = nat_to_bytes_be 32 r in
let sb = nat_to_bytes_be 32 s in
if r = 0 || s = 0 then None else Some (concat #_ #32 #32 rb sb) end
let ecdsa_verify_hashed_msg (msgHash:lbytes 32) (public_key signature:lbytes 64) : bool =
let pk = load_point public_key in
let r = nat_from_bytes_be (sub signature 0 32) in
let s = nat_from_bytes_be (sub signature 32 32) in
let z = nat_from_bytes_be msgHash % q in
let is_r_valid = 0 < r && r < q in
let is_s_valid = 0 < s && s < q in
if not (Some? pk && is_r_valid && is_s_valid) then false
else begin
assert_norm (q < pow2 256);
let sinv = qinv s in
let u1 = z *^ sinv in
let u2 = r *^ sinv in
let _X, _Y, _Z = point_mul_double_g u1 u2 (Some?.v pk) in
if is_proj_point_at_inf (_X, _Y, _Z) then false
else begin
let x = _X /% _Z in
x % q = r end
end
(*
_Z <> 0
q < prime < 2 * q
let x = _X /% _Z in x % q = r <==>
1. x = r <==> _X = r *% _Z
2. x - q = r <==> _X = (r + q) *% _Z
*)
/// ECDSA using SHA2-256
let _: squash(Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32) =
assert_norm (Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32)
let ecdsa_sign_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (private_key nonce:lbytes 32) : option (lbytes 64) =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_sign_hashed_msg msgHash private_key nonce
let ecdsa_verify_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (public_key signature:lbytes 64) : bool =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_verify_hashed_msg msgHash public_key signature
/// ECDH over the secp256k1 elliptic curve
let secret_to_public (private_key:lbytes 32) : option (lbytes 64) =
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if is_sk_valid then
let pk = point_mul_g sk in
Some (point_store pk)
else None
let ecdh (their_public_key:lbytes 64) (private_key:lbytes 32) : option (lbytes 64) =
let pk = load_point their_public_key in
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if Some? pk && is_sk_valid then
let ss = point_mul sk (Some?.v pk) in
Some (point_store ss)
else None
/// Parsing and Serializing public keys
// raw = [ x; y ], 64 bytes
// uncompressed = [ 0x04; x; y ], 65 bytes
// compressed = [ 0x02 for even `y` and 0x03 for odd `y`; x ], 33 bytes
let validate_public_key (pk:lbytes 64) : bool =
Some? (load_point pk)
let pk_uncompressed_to_raw (pk:lbytes 65) : option (lbytes 64) =
if Lib.RawIntTypes.u8_to_UInt8 pk.[0] <> 0x04uy then None else Some (sub pk 1 64)
| false | false |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val pk_uncompressed_from_raw (pk: lbytes 64) : lbytes 65
|
[] |
Spec.K256.pk_uncompressed_from_raw
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
pk: Lib.ByteSequence.lbytes 64 -> Lib.ByteSequence.lbytes 65
|
{
"end_col": 32,
"end_line": 190,
"start_col": 2,
"start_line": 190
}
|
Prims.Tot
|
val secp256k1_ecdsa_sign_hashed_msg (msgHash private_key nonce: lbytes 32) : option (lbytes 64)
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let secp256k1_ecdsa_sign_hashed_msg (msgHash private_key nonce:lbytes 32) : option (lbytes 64) =
let signature = ecdsa_sign_hashed_msg msgHash private_key nonce in
match signature with
| Some x -> secp256k1_ecdsa_signature_normalize x
| None -> None
|
val secp256k1_ecdsa_sign_hashed_msg (msgHash private_key nonce: lbytes 32) : option (lbytes 64)
let secp256k1_ecdsa_sign_hashed_msg (msgHash private_key nonce: lbytes 32) : option (lbytes 64) =
| false | null | false |
let signature = ecdsa_sign_hashed_msg msgHash private_key nonce in
match signature with
| Some x -> secp256k1_ecdsa_signature_normalize x
| None -> None
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Lib.ByteSequence.lbytes",
"Spec.K256.secp256k1_ecdsa_signature_normalize",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.K256.ecdsa_sign_hashed_msg"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
let mk_k256_abelian_group : LE.abelian_group aff_point = {
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma;
}
let mk_to_k256_comm_monoid : SE.to_comm_monoid proj_point = {
SE.a_spec = aff_point;
SE.comm_monoid = mk_k256_comm_monoid;
SE.refl = to_aff_point;
}
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
let point_at_inf_c _ =
KL.to_aff_point_at_infinity_lemma ();
point_at_inf
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
let point_add_c p q =
KL.to_aff_point_add_lemma p q;
point_add p q
val point_double_c : SE.sqr_st proj_point mk_to_k256_comm_monoid
let point_double_c p =
KL.to_aff_point_double_lemma p;
point_double p
let mk_k256_concrete_ops : SE.concrete_ops proj_point = {
SE.to = mk_to_k256_comm_monoid;
SE.one = point_at_inf_c;
SE.mul = point_add_c;
SE.sqr = point_double_c;
}
// [a]P in affine coordinates
let aff_point_mul (a:nat) (p:aff_point) : aff_point =
LE.pow mk_k256_comm_monoid p a
// [a]P
let point_mul (a:qelem) (p:proj_point) : proj_point =
SE.exp_fw mk_k256_concrete_ops p 256 a 4
// [a1]P1 + [a2]P2
let point_mul_double (a1:qelem) (p1:proj_point) (a2:qelem) (p2:proj_point) : proj_point =
SE.exp_double_fw mk_k256_concrete_ops p1 256 a1 p2 a2 5
// [a]G
let point_mul_g (a:qelem) : proj_point = point_mul a g
// [a1]G + [a2]P
let point_mul_double_g (a1:qelem) (a2:qelem) (p:proj_point) : proj_point =
point_mul_double a1 g a2 p
/// ECDSA with a prehashed message
let ecdsa_sign_hashed_msg (msgHash private_key nonce:lbytes 32) : option (lbytes 64) =
let k_q = nat_from_bytes_be nonce in
let d_a = nat_from_bytes_be private_key in
let z = nat_from_bytes_be msgHash % q in
let is_privkey_valid = 0 < d_a && d_a < q in
let is_nonce_valid = 0 < k_q && k_q < q in
if not (is_privkey_valid && is_nonce_valid) then None
else begin
let _X, _Y, _Z = point_mul_g k_q in
let x = _X /% _Z in
let r = x % q in
let kinv = qinv k_q in
let s = kinv *^ (z +^ r *^ d_a) in
let rb = nat_to_bytes_be 32 r in
let sb = nat_to_bytes_be 32 s in
if r = 0 || s = 0 then None else Some (concat #_ #32 #32 rb sb) end
let ecdsa_verify_hashed_msg (msgHash:lbytes 32) (public_key signature:lbytes 64) : bool =
let pk = load_point public_key in
let r = nat_from_bytes_be (sub signature 0 32) in
let s = nat_from_bytes_be (sub signature 32 32) in
let z = nat_from_bytes_be msgHash % q in
let is_r_valid = 0 < r && r < q in
let is_s_valid = 0 < s && s < q in
if not (Some? pk && is_r_valid && is_s_valid) then false
else begin
assert_norm (q < pow2 256);
let sinv = qinv s in
let u1 = z *^ sinv in
let u2 = r *^ sinv in
let _X, _Y, _Z = point_mul_double_g u1 u2 (Some?.v pk) in
if is_proj_point_at_inf (_X, _Y, _Z) then false
else begin
let x = _X /% _Z in
x % q = r end
end
(*
_Z <> 0
q < prime < 2 * q
let x = _X /% _Z in x % q = r <==>
1. x = r <==> _X = r *% _Z
2. x - q = r <==> _X = (r + q) *% _Z
*)
/// ECDSA using SHA2-256
let _: squash(Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32) =
assert_norm (Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32)
let ecdsa_sign_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (private_key nonce:lbytes 32) : option (lbytes 64) =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_sign_hashed_msg msgHash private_key nonce
let ecdsa_verify_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (public_key signature:lbytes 64) : bool =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_verify_hashed_msg msgHash public_key signature
/// ECDH over the secp256k1 elliptic curve
let secret_to_public (private_key:lbytes 32) : option (lbytes 64) =
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if is_sk_valid then
let pk = point_mul_g sk in
Some (point_store pk)
else None
let ecdh (their_public_key:lbytes 64) (private_key:lbytes 32) : option (lbytes 64) =
let pk = load_point their_public_key in
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if Some? pk && is_sk_valid then
let ss = point_mul sk (Some?.v pk) in
Some (point_store ss)
else None
/// Parsing and Serializing public keys
// raw = [ x; y ], 64 bytes
// uncompressed = [ 0x04; x; y ], 65 bytes
// compressed = [ 0x02 for even `y` and 0x03 for odd `y`; x ], 33 bytes
let validate_public_key (pk:lbytes 64) : bool =
Some? (load_point pk)
let pk_uncompressed_to_raw (pk:lbytes 65) : option (lbytes 64) =
if Lib.RawIntTypes.u8_to_UInt8 pk.[0] <> 0x04uy then None else Some (sub pk 1 64)
let pk_uncompressed_from_raw (pk:lbytes 64) : lbytes 65 =
concat (create 1 (u8 0x04)) pk
let pk_compressed_to_raw (pk:lbytes 33) : option (lbytes 64) =
let pk_x = sub pk 1 32 in
match (aff_point_decompress pk) with
| Some (x, y) -> Some (concat #_ #32 #32 pk_x (nat_to_bytes_be 32 y))
| None -> None
let pk_compressed_from_raw (pk:lbytes 64) : lbytes 33 =
let pk_x = sub pk 0 32 in
let pk_y = sub pk 32 32 in
let is_pk_y_odd = nat_from_bytes_be pk_y % 2 = 1 in // <==> pk_y % 2 = 1
let pk0 = if is_pk_y_odd then u8 0x03 else u8 0x02 in
concat (create 1 pk0) pk_x
/// Low-S normalization
(**
https://en.bitcoin.it/wiki/BIP_0062
https://yondon.blog/2019/01/01/how-not-to-use-ecdsa/
https://eklitzke.org/bitcoin-transaction-malleability
*)
// The value S in signatures must be between 0x1 and q / 2 (inclusive).
// If S is too high, simply replace it by S' = q - S.
let secp256k1_ecdsa_signature_normalize (signature:lbytes 64) : option (lbytes 64) =
let sn = nat_from_bytes_be (sub signature 32 32) in
let is_sn_valid = 0 < sn && sn < q in
if is_sn_valid then begin
let sn = if sn <= q / 2 then sn else (q - sn) % q in
let sgnt = update_sub signature 32 32 (nat_to_bytes_be 32 sn) in
Some sgnt end
else None
let secp256k1_ecdsa_is_signature_normalized (signature:lbytes 64) : bool =
let sn = nat_from_bytes_be (sub signature 32 32) in
0 < sn && sn <= q / 2
| false | false |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val secp256k1_ecdsa_sign_hashed_msg (msgHash private_key nonce: lbytes 32) : option (lbytes 64)
|
[] |
Spec.K256.secp256k1_ecdsa_sign_hashed_msg
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
msgHash: Lib.ByteSequence.lbytes 32 ->
private_key: Lib.ByteSequence.lbytes 32 ->
nonce: Lib.ByteSequence.lbytes 32
-> FStar.Pervasives.Native.option (Lib.ByteSequence.lbytes 64)
|
{
"end_col": 16,
"end_line": 237,
"start_col": 96,
"start_line": 233
}
|
Prims.Tot
|
val pk_uncompressed_to_raw (pk: lbytes 65) : option (lbytes 64)
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let pk_uncompressed_to_raw (pk:lbytes 65) : option (lbytes 64) =
if Lib.RawIntTypes.u8_to_UInt8 pk.[0] <> 0x04uy then None else Some (sub pk 1 64)
|
val pk_uncompressed_to_raw (pk: lbytes 65) : option (lbytes 64)
let pk_uncompressed_to_raw (pk: lbytes 65) : option (lbytes 64) =
| false | null | false |
if Lib.RawIntTypes.u8_to_UInt8 pk.[ 0 ] <> 0x04uy then None else Some (sub pk 1 64)
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Lib.ByteSequence.lbytes",
"Prims.op_disEquality",
"FStar.UInt8.t",
"Lib.RawIntTypes.u8_to_UInt8",
"Lib.Sequence.op_String_Access",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"FStar.UInt8.__uint_to_t",
"FStar.Pervasives.Native.None",
"Prims.bool",
"FStar.Pervasives.Native.Some",
"Lib.Sequence.sub",
"FStar.Pervasives.Native.option"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
let mk_k256_abelian_group : LE.abelian_group aff_point = {
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma;
}
let mk_to_k256_comm_monoid : SE.to_comm_monoid proj_point = {
SE.a_spec = aff_point;
SE.comm_monoid = mk_k256_comm_monoid;
SE.refl = to_aff_point;
}
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
let point_at_inf_c _ =
KL.to_aff_point_at_infinity_lemma ();
point_at_inf
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
let point_add_c p q =
KL.to_aff_point_add_lemma p q;
point_add p q
val point_double_c : SE.sqr_st proj_point mk_to_k256_comm_monoid
let point_double_c p =
KL.to_aff_point_double_lemma p;
point_double p
let mk_k256_concrete_ops : SE.concrete_ops proj_point = {
SE.to = mk_to_k256_comm_monoid;
SE.one = point_at_inf_c;
SE.mul = point_add_c;
SE.sqr = point_double_c;
}
// [a]P in affine coordinates
let aff_point_mul (a:nat) (p:aff_point) : aff_point =
LE.pow mk_k256_comm_monoid p a
// [a]P
let point_mul (a:qelem) (p:proj_point) : proj_point =
SE.exp_fw mk_k256_concrete_ops p 256 a 4
// [a1]P1 + [a2]P2
let point_mul_double (a1:qelem) (p1:proj_point) (a2:qelem) (p2:proj_point) : proj_point =
SE.exp_double_fw mk_k256_concrete_ops p1 256 a1 p2 a2 5
// [a]G
let point_mul_g (a:qelem) : proj_point = point_mul a g
// [a1]G + [a2]P
let point_mul_double_g (a1:qelem) (a2:qelem) (p:proj_point) : proj_point =
point_mul_double a1 g a2 p
/// ECDSA with a prehashed message
let ecdsa_sign_hashed_msg (msgHash private_key nonce:lbytes 32) : option (lbytes 64) =
let k_q = nat_from_bytes_be nonce in
let d_a = nat_from_bytes_be private_key in
let z = nat_from_bytes_be msgHash % q in
let is_privkey_valid = 0 < d_a && d_a < q in
let is_nonce_valid = 0 < k_q && k_q < q in
if not (is_privkey_valid && is_nonce_valid) then None
else begin
let _X, _Y, _Z = point_mul_g k_q in
let x = _X /% _Z in
let r = x % q in
let kinv = qinv k_q in
let s = kinv *^ (z +^ r *^ d_a) in
let rb = nat_to_bytes_be 32 r in
let sb = nat_to_bytes_be 32 s in
if r = 0 || s = 0 then None else Some (concat #_ #32 #32 rb sb) end
let ecdsa_verify_hashed_msg (msgHash:lbytes 32) (public_key signature:lbytes 64) : bool =
let pk = load_point public_key in
let r = nat_from_bytes_be (sub signature 0 32) in
let s = nat_from_bytes_be (sub signature 32 32) in
let z = nat_from_bytes_be msgHash % q in
let is_r_valid = 0 < r && r < q in
let is_s_valid = 0 < s && s < q in
if not (Some? pk && is_r_valid && is_s_valid) then false
else begin
assert_norm (q < pow2 256);
let sinv = qinv s in
let u1 = z *^ sinv in
let u2 = r *^ sinv in
let _X, _Y, _Z = point_mul_double_g u1 u2 (Some?.v pk) in
if is_proj_point_at_inf (_X, _Y, _Z) then false
else begin
let x = _X /% _Z in
x % q = r end
end
(*
_Z <> 0
q < prime < 2 * q
let x = _X /% _Z in x % q = r <==>
1. x = r <==> _X = r *% _Z
2. x - q = r <==> _X = (r + q) *% _Z
*)
/// ECDSA using SHA2-256
let _: squash(Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32) =
assert_norm (Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32)
let ecdsa_sign_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (private_key nonce:lbytes 32) : option (lbytes 64) =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_sign_hashed_msg msgHash private_key nonce
let ecdsa_verify_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (public_key signature:lbytes 64) : bool =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_verify_hashed_msg msgHash public_key signature
/// ECDH over the secp256k1 elliptic curve
let secret_to_public (private_key:lbytes 32) : option (lbytes 64) =
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if is_sk_valid then
let pk = point_mul_g sk in
Some (point_store pk)
else None
let ecdh (their_public_key:lbytes 64) (private_key:lbytes 32) : option (lbytes 64) =
let pk = load_point their_public_key in
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if Some? pk && is_sk_valid then
let ss = point_mul sk (Some?.v pk) in
Some (point_store ss)
else None
/// Parsing and Serializing public keys
// raw = [ x; y ], 64 bytes
// uncompressed = [ 0x04; x; y ], 65 bytes
// compressed = [ 0x02 for even `y` and 0x03 for odd `y`; x ], 33 bytes
let validate_public_key (pk:lbytes 64) : bool =
Some? (load_point pk)
| false | false |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val pk_uncompressed_to_raw (pk: lbytes 65) : option (lbytes 64)
|
[] |
Spec.K256.pk_uncompressed_to_raw
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
pk: Lib.ByteSequence.lbytes 65 -> FStar.Pervasives.Native.option (Lib.ByteSequence.lbytes 64)
|
{
"end_col": 83,
"end_line": 187,
"start_col": 2,
"start_line": 187
}
|
Prims.Tot
|
val ecdsa_verify_hashed_msg (msgHash: lbytes 32) (public_key signature: lbytes 64) : bool
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let ecdsa_verify_hashed_msg (msgHash:lbytes 32) (public_key signature:lbytes 64) : bool =
let pk = load_point public_key in
let r = nat_from_bytes_be (sub signature 0 32) in
let s = nat_from_bytes_be (sub signature 32 32) in
let z = nat_from_bytes_be msgHash % q in
let is_r_valid = 0 < r && r < q in
let is_s_valid = 0 < s && s < q in
if not (Some? pk && is_r_valid && is_s_valid) then false
else begin
assert_norm (q < pow2 256);
let sinv = qinv s in
let u1 = z *^ sinv in
let u2 = r *^ sinv in
let _X, _Y, _Z = point_mul_double_g u1 u2 (Some?.v pk) in
if is_proj_point_at_inf (_X, _Y, _Z) then false
else begin
let x = _X /% _Z in
x % q = r end
end
|
val ecdsa_verify_hashed_msg (msgHash: lbytes 32) (public_key signature: lbytes 64) : bool
let ecdsa_verify_hashed_msg (msgHash: lbytes 32) (public_key signature: lbytes 64) : bool =
| false | null | false |
let pk = load_point public_key in
let r = nat_from_bytes_be (sub signature 0 32) in
let s = nat_from_bytes_be (sub signature 32 32) in
let z = nat_from_bytes_be msgHash % q in
let is_r_valid = 0 < r && r < q in
let is_s_valid = 0 < s && s < q in
if not (Some? pk && is_r_valid && is_s_valid)
then false
else
(assert_norm (q < pow2 256);
let sinv = qinv s in
let u1 = z *^ sinv in
let u2 = r *^ sinv in
let _X, _Y, _Z = point_mul_double_g u1 u2 (Some?.v pk) in
if is_proj_point_at_inf (_X, _Y, _Z)
then false
else
let x = _X /% _Z in
x % q = r)
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Lib.ByteSequence.lbytes",
"Prims.op_Negation",
"Prims.op_AmpAmp",
"FStar.Pervasives.Native.uu___is_Some",
"Spec.K256.PointOps.proj_point",
"Prims.bool",
"Spec.K256.PointOps.felem",
"Spec.K256.PointOps.is_proj_point_at_inf",
"FStar.Pervasives.Native.Mktuple3",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Spec.K256.PointOps.q",
"Spec.K256.PointOps.op_Slash_Percent",
"Spec.K256.point_mul_double_g",
"FStar.Pervasives.Native.__proj__Some__item__v",
"Spec.K256.PointOps.qelem",
"Spec.K256.PointOps.op_Star_Hat",
"Spec.K256.PointOps.qinv",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Lib.ByteSequence.nat_from_bytes_be",
"Lib.IntTypes.SEC",
"Prims.nat",
"Prims.op_Multiply",
"Lib.Sequence.length",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.Sequence.sub",
"Lib.IntTypes.uint_t",
"FStar.Pervasives.Native.option",
"Spec.K256.PointOps.load_point"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
let mk_k256_abelian_group : LE.abelian_group aff_point = {
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma;
}
let mk_to_k256_comm_monoid : SE.to_comm_monoid proj_point = {
SE.a_spec = aff_point;
SE.comm_monoid = mk_k256_comm_monoid;
SE.refl = to_aff_point;
}
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
let point_at_inf_c _ =
KL.to_aff_point_at_infinity_lemma ();
point_at_inf
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
let point_add_c p q =
KL.to_aff_point_add_lemma p q;
point_add p q
val point_double_c : SE.sqr_st proj_point mk_to_k256_comm_monoid
let point_double_c p =
KL.to_aff_point_double_lemma p;
point_double p
let mk_k256_concrete_ops : SE.concrete_ops proj_point = {
SE.to = mk_to_k256_comm_monoid;
SE.one = point_at_inf_c;
SE.mul = point_add_c;
SE.sqr = point_double_c;
}
// [a]P in affine coordinates
let aff_point_mul (a:nat) (p:aff_point) : aff_point =
LE.pow mk_k256_comm_monoid p a
// [a]P
let point_mul (a:qelem) (p:proj_point) : proj_point =
SE.exp_fw mk_k256_concrete_ops p 256 a 4
// [a1]P1 + [a2]P2
let point_mul_double (a1:qelem) (p1:proj_point) (a2:qelem) (p2:proj_point) : proj_point =
SE.exp_double_fw mk_k256_concrete_ops p1 256 a1 p2 a2 5
// [a]G
let point_mul_g (a:qelem) : proj_point = point_mul a g
// [a1]G + [a2]P
let point_mul_double_g (a1:qelem) (a2:qelem) (p:proj_point) : proj_point =
point_mul_double a1 g a2 p
/// ECDSA with a prehashed message
let ecdsa_sign_hashed_msg (msgHash private_key nonce:lbytes 32) : option (lbytes 64) =
let k_q = nat_from_bytes_be nonce in
let d_a = nat_from_bytes_be private_key in
let z = nat_from_bytes_be msgHash % q in
let is_privkey_valid = 0 < d_a && d_a < q in
let is_nonce_valid = 0 < k_q && k_q < q in
if not (is_privkey_valid && is_nonce_valid) then None
else begin
let _X, _Y, _Z = point_mul_g k_q in
let x = _X /% _Z in
let r = x % q in
let kinv = qinv k_q in
let s = kinv *^ (z +^ r *^ d_a) in
let rb = nat_to_bytes_be 32 r in
let sb = nat_to_bytes_be 32 s in
if r = 0 || s = 0 then None else Some (concat #_ #32 #32 rb sb) end
| false | false |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val ecdsa_verify_hashed_msg (msgHash: lbytes 32) (public_key signature: lbytes 64) : bool
|
[] |
Spec.K256.ecdsa_verify_hashed_msg
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
msgHash: Lib.ByteSequence.lbytes 32 ->
public_key: Lib.ByteSequence.lbytes 64 ->
signature: Lib.ByteSequence.lbytes 64
-> Prims.bool
|
{
"end_col": 5,
"end_line": 130,
"start_col": 89,
"start_line": 109
}
|
Prims.Tot
|
val pk_compressed_from_raw (pk: lbytes 64) : lbytes 33
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let pk_compressed_from_raw (pk:lbytes 64) : lbytes 33 =
let pk_x = sub pk 0 32 in
let pk_y = sub pk 32 32 in
let is_pk_y_odd = nat_from_bytes_be pk_y % 2 = 1 in // <==> pk_y % 2 = 1
let pk0 = if is_pk_y_odd then u8 0x03 else u8 0x02 in
concat (create 1 pk0) pk_x
|
val pk_compressed_from_raw (pk: lbytes 64) : lbytes 33
let pk_compressed_from_raw (pk: lbytes 64) : lbytes 33 =
| false | null | false |
let pk_x = sub pk 0 32 in
let pk_y = sub pk 32 32 in
let is_pk_y_odd = nat_from_bytes_be pk_y % 2 = 1 in
let pk0 = if is_pk_y_odd then u8 0x03 else u8 0x02 in
concat (create 1 pk0) pk_x
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Lib.ByteSequence.lbytes",
"Lib.Sequence.concat",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.Sequence.create",
"Lib.IntTypes.int_t",
"Lib.IntTypes.u8",
"Prims.bool",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Lib.ByteSequence.nat_from_bytes_be",
"Lib.Sequence.lseq",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"Prims.l_Forall",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.Sequence.sub"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
let mk_k256_abelian_group : LE.abelian_group aff_point = {
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma;
}
let mk_to_k256_comm_monoid : SE.to_comm_monoid proj_point = {
SE.a_spec = aff_point;
SE.comm_monoid = mk_k256_comm_monoid;
SE.refl = to_aff_point;
}
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
let point_at_inf_c _ =
KL.to_aff_point_at_infinity_lemma ();
point_at_inf
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
let point_add_c p q =
KL.to_aff_point_add_lemma p q;
point_add p q
val point_double_c : SE.sqr_st proj_point mk_to_k256_comm_monoid
let point_double_c p =
KL.to_aff_point_double_lemma p;
point_double p
let mk_k256_concrete_ops : SE.concrete_ops proj_point = {
SE.to = mk_to_k256_comm_monoid;
SE.one = point_at_inf_c;
SE.mul = point_add_c;
SE.sqr = point_double_c;
}
// [a]P in affine coordinates
let aff_point_mul (a:nat) (p:aff_point) : aff_point =
LE.pow mk_k256_comm_monoid p a
// [a]P
let point_mul (a:qelem) (p:proj_point) : proj_point =
SE.exp_fw mk_k256_concrete_ops p 256 a 4
// [a1]P1 + [a2]P2
let point_mul_double (a1:qelem) (p1:proj_point) (a2:qelem) (p2:proj_point) : proj_point =
SE.exp_double_fw mk_k256_concrete_ops p1 256 a1 p2 a2 5
// [a]G
let point_mul_g (a:qelem) : proj_point = point_mul a g
// [a1]G + [a2]P
let point_mul_double_g (a1:qelem) (a2:qelem) (p:proj_point) : proj_point =
point_mul_double a1 g a2 p
/// ECDSA with a prehashed message
let ecdsa_sign_hashed_msg (msgHash private_key nonce:lbytes 32) : option (lbytes 64) =
let k_q = nat_from_bytes_be nonce in
let d_a = nat_from_bytes_be private_key in
let z = nat_from_bytes_be msgHash % q in
let is_privkey_valid = 0 < d_a && d_a < q in
let is_nonce_valid = 0 < k_q && k_q < q in
if not (is_privkey_valid && is_nonce_valid) then None
else begin
let _X, _Y, _Z = point_mul_g k_q in
let x = _X /% _Z in
let r = x % q in
let kinv = qinv k_q in
let s = kinv *^ (z +^ r *^ d_a) in
let rb = nat_to_bytes_be 32 r in
let sb = nat_to_bytes_be 32 s in
if r = 0 || s = 0 then None else Some (concat #_ #32 #32 rb sb) end
let ecdsa_verify_hashed_msg (msgHash:lbytes 32) (public_key signature:lbytes 64) : bool =
let pk = load_point public_key in
let r = nat_from_bytes_be (sub signature 0 32) in
let s = nat_from_bytes_be (sub signature 32 32) in
let z = nat_from_bytes_be msgHash % q in
let is_r_valid = 0 < r && r < q in
let is_s_valid = 0 < s && s < q in
if not (Some? pk && is_r_valid && is_s_valid) then false
else begin
assert_norm (q < pow2 256);
let sinv = qinv s in
let u1 = z *^ sinv in
let u2 = r *^ sinv in
let _X, _Y, _Z = point_mul_double_g u1 u2 (Some?.v pk) in
if is_proj_point_at_inf (_X, _Y, _Z) then false
else begin
let x = _X /% _Z in
x % q = r end
end
(*
_Z <> 0
q < prime < 2 * q
let x = _X /% _Z in x % q = r <==>
1. x = r <==> _X = r *% _Z
2. x - q = r <==> _X = (r + q) *% _Z
*)
/// ECDSA using SHA2-256
let _: squash(Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32) =
assert_norm (Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32)
let ecdsa_sign_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (private_key nonce:lbytes 32) : option (lbytes 64) =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_sign_hashed_msg msgHash private_key nonce
let ecdsa_verify_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (public_key signature:lbytes 64) : bool =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_verify_hashed_msg msgHash public_key signature
/// ECDH over the secp256k1 elliptic curve
let secret_to_public (private_key:lbytes 32) : option (lbytes 64) =
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if is_sk_valid then
let pk = point_mul_g sk in
Some (point_store pk)
else None
let ecdh (their_public_key:lbytes 64) (private_key:lbytes 32) : option (lbytes 64) =
let pk = load_point their_public_key in
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if Some? pk && is_sk_valid then
let ss = point_mul sk (Some?.v pk) in
Some (point_store ss)
else None
/// Parsing and Serializing public keys
// raw = [ x; y ], 64 bytes
// uncompressed = [ 0x04; x; y ], 65 bytes
// compressed = [ 0x02 for even `y` and 0x03 for odd `y`; x ], 33 bytes
let validate_public_key (pk:lbytes 64) : bool =
Some? (load_point pk)
let pk_uncompressed_to_raw (pk:lbytes 65) : option (lbytes 64) =
if Lib.RawIntTypes.u8_to_UInt8 pk.[0] <> 0x04uy then None else Some (sub pk 1 64)
let pk_uncompressed_from_raw (pk:lbytes 64) : lbytes 65 =
concat (create 1 (u8 0x04)) pk
let pk_compressed_to_raw (pk:lbytes 33) : option (lbytes 64) =
let pk_x = sub pk 1 32 in
match (aff_point_decompress pk) with
| Some (x, y) -> Some (concat #_ #32 #32 pk_x (nat_to_bytes_be 32 y))
| None -> None
| false | false |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val pk_compressed_from_raw (pk: lbytes 64) : lbytes 33
|
[] |
Spec.K256.pk_compressed_from_raw
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
pk: Lib.ByteSequence.lbytes 64 -> Lib.ByteSequence.lbytes 33
|
{
"end_col": 28,
"end_line": 204,
"start_col": 55,
"start_line": 199
}
|
Prims.Tot
|
val secp256k1_ecdsa_is_signature_normalized (signature: lbytes 64) : bool
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let secp256k1_ecdsa_is_signature_normalized (signature:lbytes 64) : bool =
let sn = nat_from_bytes_be (sub signature 32 32) in
0 < sn && sn <= q / 2
|
val secp256k1_ecdsa_is_signature_normalized (signature: lbytes 64) : bool
let secp256k1_ecdsa_is_signature_normalized (signature: lbytes 64) : bool =
| false | null | false |
let sn = nat_from_bytes_be (sub signature 32 32) in
0 < sn && sn <= q / 2
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Lib.ByteSequence.lbytes",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"Prims.op_Division",
"Spec.K256.PointOps.q",
"Prims.nat",
"Prims.b2t",
"Prims.pow2",
"Prims.op_Multiply",
"Lib.Sequence.length",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.Sequence.sub",
"Lib.ByteSequence.nat_from_bytes_be",
"Lib.IntTypes.uint_t",
"Prims.bool"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
let mk_k256_abelian_group : LE.abelian_group aff_point = {
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma;
}
let mk_to_k256_comm_monoid : SE.to_comm_monoid proj_point = {
SE.a_spec = aff_point;
SE.comm_monoid = mk_k256_comm_monoid;
SE.refl = to_aff_point;
}
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
let point_at_inf_c _ =
KL.to_aff_point_at_infinity_lemma ();
point_at_inf
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
let point_add_c p q =
KL.to_aff_point_add_lemma p q;
point_add p q
val point_double_c : SE.sqr_st proj_point mk_to_k256_comm_monoid
let point_double_c p =
KL.to_aff_point_double_lemma p;
point_double p
let mk_k256_concrete_ops : SE.concrete_ops proj_point = {
SE.to = mk_to_k256_comm_monoid;
SE.one = point_at_inf_c;
SE.mul = point_add_c;
SE.sqr = point_double_c;
}
// [a]P in affine coordinates
let aff_point_mul (a:nat) (p:aff_point) : aff_point =
LE.pow mk_k256_comm_monoid p a
// [a]P
let point_mul (a:qelem) (p:proj_point) : proj_point =
SE.exp_fw mk_k256_concrete_ops p 256 a 4
// [a1]P1 + [a2]P2
let point_mul_double (a1:qelem) (p1:proj_point) (a2:qelem) (p2:proj_point) : proj_point =
SE.exp_double_fw mk_k256_concrete_ops p1 256 a1 p2 a2 5
// [a]G
let point_mul_g (a:qelem) : proj_point = point_mul a g
// [a1]G + [a2]P
let point_mul_double_g (a1:qelem) (a2:qelem) (p:proj_point) : proj_point =
point_mul_double a1 g a2 p
/// ECDSA with a prehashed message
let ecdsa_sign_hashed_msg (msgHash private_key nonce:lbytes 32) : option (lbytes 64) =
let k_q = nat_from_bytes_be nonce in
let d_a = nat_from_bytes_be private_key in
let z = nat_from_bytes_be msgHash % q in
let is_privkey_valid = 0 < d_a && d_a < q in
let is_nonce_valid = 0 < k_q && k_q < q in
if not (is_privkey_valid && is_nonce_valid) then None
else begin
let _X, _Y, _Z = point_mul_g k_q in
let x = _X /% _Z in
let r = x % q in
let kinv = qinv k_q in
let s = kinv *^ (z +^ r *^ d_a) in
let rb = nat_to_bytes_be 32 r in
let sb = nat_to_bytes_be 32 s in
if r = 0 || s = 0 then None else Some (concat #_ #32 #32 rb sb) end
let ecdsa_verify_hashed_msg (msgHash:lbytes 32) (public_key signature:lbytes 64) : bool =
let pk = load_point public_key in
let r = nat_from_bytes_be (sub signature 0 32) in
let s = nat_from_bytes_be (sub signature 32 32) in
let z = nat_from_bytes_be msgHash % q in
let is_r_valid = 0 < r && r < q in
let is_s_valid = 0 < s && s < q in
if not (Some? pk && is_r_valid && is_s_valid) then false
else begin
assert_norm (q < pow2 256);
let sinv = qinv s in
let u1 = z *^ sinv in
let u2 = r *^ sinv in
let _X, _Y, _Z = point_mul_double_g u1 u2 (Some?.v pk) in
if is_proj_point_at_inf (_X, _Y, _Z) then false
else begin
let x = _X /% _Z in
x % q = r end
end
(*
_Z <> 0
q < prime < 2 * q
let x = _X /% _Z in x % q = r <==>
1. x = r <==> _X = r *% _Z
2. x - q = r <==> _X = (r + q) *% _Z
*)
/// ECDSA using SHA2-256
let _: squash(Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32) =
assert_norm (Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32)
let ecdsa_sign_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (private_key nonce:lbytes 32) : option (lbytes 64) =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_sign_hashed_msg msgHash private_key nonce
let ecdsa_verify_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (public_key signature:lbytes 64) : bool =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_verify_hashed_msg msgHash public_key signature
/// ECDH over the secp256k1 elliptic curve
let secret_to_public (private_key:lbytes 32) : option (lbytes 64) =
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if is_sk_valid then
let pk = point_mul_g sk in
Some (point_store pk)
else None
let ecdh (their_public_key:lbytes 64) (private_key:lbytes 32) : option (lbytes 64) =
let pk = load_point their_public_key in
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if Some? pk && is_sk_valid then
let ss = point_mul sk (Some?.v pk) in
Some (point_store ss)
else None
/// Parsing and Serializing public keys
// raw = [ x; y ], 64 bytes
// uncompressed = [ 0x04; x; y ], 65 bytes
// compressed = [ 0x02 for even `y` and 0x03 for odd `y`; x ], 33 bytes
let validate_public_key (pk:lbytes 64) : bool =
Some? (load_point pk)
let pk_uncompressed_to_raw (pk:lbytes 65) : option (lbytes 64) =
if Lib.RawIntTypes.u8_to_UInt8 pk.[0] <> 0x04uy then None else Some (sub pk 1 64)
let pk_uncompressed_from_raw (pk:lbytes 64) : lbytes 65 =
concat (create 1 (u8 0x04)) pk
let pk_compressed_to_raw (pk:lbytes 33) : option (lbytes 64) =
let pk_x = sub pk 1 32 in
match (aff_point_decompress pk) with
| Some (x, y) -> Some (concat #_ #32 #32 pk_x (nat_to_bytes_be 32 y))
| None -> None
let pk_compressed_from_raw (pk:lbytes 64) : lbytes 33 =
let pk_x = sub pk 0 32 in
let pk_y = sub pk 32 32 in
let is_pk_y_odd = nat_from_bytes_be pk_y % 2 = 1 in // <==> pk_y % 2 = 1
let pk0 = if is_pk_y_odd then u8 0x03 else u8 0x02 in
concat (create 1 pk0) pk_x
/// Low-S normalization
(**
https://en.bitcoin.it/wiki/BIP_0062
https://yondon.blog/2019/01/01/how-not-to-use-ecdsa/
https://eklitzke.org/bitcoin-transaction-malleability
*)
// The value S in signatures must be between 0x1 and q / 2 (inclusive).
// If S is too high, simply replace it by S' = q - S.
let secp256k1_ecdsa_signature_normalize (signature:lbytes 64) : option (lbytes 64) =
let sn = nat_from_bytes_be (sub signature 32 32) in
let is_sn_valid = 0 < sn && sn < q in
if is_sn_valid then begin
let sn = if sn <= q / 2 then sn else (q - sn) % q in
let sgnt = update_sub signature 32 32 (nat_to_bytes_be 32 sn) in
Some sgnt end
else None
| false | false |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val secp256k1_ecdsa_is_signature_normalized (signature: lbytes 64) : bool
|
[] |
Spec.K256.secp256k1_ecdsa_is_signature_normalized
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
signature: Lib.ByteSequence.lbytes 64 -> Prims.bool
|
{
"end_col": 23,
"end_line": 230,
"start_col": 74,
"start_line": 228
}
|
Prims.Tot
|
val ecdsa_sign_hashed_msg (msgHash private_key nonce: lbytes 32) : option (lbytes 64)
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let ecdsa_sign_hashed_msg (msgHash private_key nonce:lbytes 32) : option (lbytes 64) =
let k_q = nat_from_bytes_be nonce in
let d_a = nat_from_bytes_be private_key in
let z = nat_from_bytes_be msgHash % q in
let is_privkey_valid = 0 < d_a && d_a < q in
let is_nonce_valid = 0 < k_q && k_q < q in
if not (is_privkey_valid && is_nonce_valid) then None
else begin
let _X, _Y, _Z = point_mul_g k_q in
let x = _X /% _Z in
let r = x % q in
let kinv = qinv k_q in
let s = kinv *^ (z +^ r *^ d_a) in
let rb = nat_to_bytes_be 32 r in
let sb = nat_to_bytes_be 32 s in
if r = 0 || s = 0 then None else Some (concat #_ #32 #32 rb sb) end
|
val ecdsa_sign_hashed_msg (msgHash private_key nonce: lbytes 32) : option (lbytes 64)
let ecdsa_sign_hashed_msg (msgHash private_key nonce: lbytes 32) : option (lbytes 64) =
| false | null | false |
let k_q = nat_from_bytes_be nonce in
let d_a = nat_from_bytes_be private_key in
let z = nat_from_bytes_be msgHash % q in
let is_privkey_valid = 0 < d_a && d_a < q in
let is_nonce_valid = 0 < k_q && k_q < q in
if not (is_privkey_valid && is_nonce_valid)
then None
else
let _X, _Y, _Z = point_mul_g k_q in
let x = _X /% _Z in
let r = x % q in
let kinv = qinv k_q in
let s = kinv *^ (z +^ r *^ d_a) in
let rb = nat_to_bytes_be 32 r in
let sb = nat_to_bytes_be 32 s in
if r = 0 || s = 0 then None else Some (concat #_ #32 #32 rb sb)
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Lib.ByteSequence.lbytes",
"Prims.op_Negation",
"Prims.op_AmpAmp",
"FStar.Pervasives.Native.None",
"Prims.bool",
"Spec.K256.PointOps.felem",
"Prims.op_BarBar",
"Prims.op_Equality",
"Prims.int",
"FStar.Pervasives.Native.Some",
"Lib.Sequence.concat",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"FStar.Pervasives.Native.option",
"Lib.Sequence.seq",
"Lib.IntTypes.int_t",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"Lib.Sequence.length",
"Prims.l_or",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_Multiply",
"Lib.ByteSequence.nat_from_intseq_be",
"Lib.ByteSequence.nat_to_bytes_be",
"Spec.K256.PointOps.qelem",
"Spec.K256.PointOps.op_Star_Hat",
"Spec.K256.PointOps.op_Plus_Hat",
"Spec.K256.PointOps.qinv",
"Prims.op_Modulus",
"Spec.K256.PointOps.q",
"Spec.K256.PointOps.op_Slash_Percent",
"Spec.K256.PointOps.proj_point",
"Spec.K256.point_mul_g",
"Lib.ByteSequence.nat_from_bytes_be"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
let mk_k256_abelian_group : LE.abelian_group aff_point = {
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma;
}
let mk_to_k256_comm_monoid : SE.to_comm_monoid proj_point = {
SE.a_spec = aff_point;
SE.comm_monoid = mk_k256_comm_monoid;
SE.refl = to_aff_point;
}
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
let point_at_inf_c _ =
KL.to_aff_point_at_infinity_lemma ();
point_at_inf
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
let point_add_c p q =
KL.to_aff_point_add_lemma p q;
point_add p q
val point_double_c : SE.sqr_st proj_point mk_to_k256_comm_monoid
let point_double_c p =
KL.to_aff_point_double_lemma p;
point_double p
let mk_k256_concrete_ops : SE.concrete_ops proj_point = {
SE.to = mk_to_k256_comm_monoid;
SE.one = point_at_inf_c;
SE.mul = point_add_c;
SE.sqr = point_double_c;
}
// [a]P in affine coordinates
let aff_point_mul (a:nat) (p:aff_point) : aff_point =
LE.pow mk_k256_comm_monoid p a
// [a]P
let point_mul (a:qelem) (p:proj_point) : proj_point =
SE.exp_fw mk_k256_concrete_ops p 256 a 4
// [a1]P1 + [a2]P2
let point_mul_double (a1:qelem) (p1:proj_point) (a2:qelem) (p2:proj_point) : proj_point =
SE.exp_double_fw mk_k256_concrete_ops p1 256 a1 p2 a2 5
// [a]G
let point_mul_g (a:qelem) : proj_point = point_mul a g
// [a1]G + [a2]P
let point_mul_double_g (a1:qelem) (a2:qelem) (p:proj_point) : proj_point =
point_mul_double a1 g a2 p
/// ECDSA with a prehashed message
| false | false |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val ecdsa_sign_hashed_msg (msgHash private_key nonce: lbytes 32) : option (lbytes 64)
|
[] |
Spec.K256.ecdsa_sign_hashed_msg
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
msgHash: Lib.ByteSequence.lbytes 32 ->
private_key: Lib.ByteSequence.lbytes 32 ->
nonce: Lib.ByteSequence.lbytes 32
-> FStar.Pervasives.Native.option (Lib.ByteSequence.lbytes 64)
|
{
"end_col": 71,
"end_line": 106,
"start_col": 86,
"start_line": 86
}
|
Prims.Tot
|
val secp256k1_ecdsa_signature_normalize (signature: lbytes 64) : option (lbytes 64)
|
[
{
"abbrev": false,
"full_module": "Spec.K256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256.Lemmas",
"short_module": "KL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"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": "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
}
] | false |
let secp256k1_ecdsa_signature_normalize (signature:lbytes 64) : option (lbytes 64) =
let sn = nat_from_bytes_be (sub signature 32 32) in
let is_sn_valid = 0 < sn && sn < q in
if is_sn_valid then begin
let sn = if sn <= q / 2 then sn else (q - sn) % q in
let sgnt = update_sub signature 32 32 (nat_to_bytes_be 32 sn) in
Some sgnt end
else None
|
val secp256k1_ecdsa_signature_normalize (signature: lbytes 64) : option (lbytes 64)
let secp256k1_ecdsa_signature_normalize (signature: lbytes 64) : option (lbytes 64) =
| false | null | false |
let sn = nat_from_bytes_be (sub signature 32 32) in
let is_sn_valid = 0 < sn && sn < q in
if is_sn_valid
then
let sn = if sn <= q / 2 then sn else (q - sn) % q in
let sgnt = update_sub signature 32 32 (nat_to_bytes_be 32 sn) in
Some sgnt
else None
|
{
"checked_file": "Spec.K256.fst.checked",
"dependencies": [
"Spec.K256.PointOps.fst.checked",
"Spec.K256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.K256.fst"
}
|
[
"total"
] |
[
"Lib.ByteSequence.lbytes",
"FStar.Pervasives.Native.Some",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.l_and",
"Prims.eq2",
"Lib.Sequence.sub",
"Lib.ByteSequence.nat_to_bytes_be",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_or",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.op_Addition",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.index",
"Lib.Sequence.update_sub",
"Lib.IntTypes.uint_t",
"Prims.pow2",
"Prims.op_Multiply",
"Prims.op_Division",
"Spec.K256.PointOps.q",
"Prims.bool",
"Prims.op_Modulus",
"Prims.op_Subtraction",
"FStar.Mul.op_Star",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option",
"Prims.op_AmpAmp",
"Lib.Sequence.length",
"Lib.ByteSequence.nat_from_bytes_be"
] |
[] |
module Spec.K256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module KL = Spec.K256.Lemmas
include Spec.K256.PointOps
#set-options "--z3rlimit 30 --fuel 0 --ifuel 0"
(**
K256: https://en.bitcoin.it/wiki/Secp256k1
ECDSA: https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
https://www.hyperelliptic.org/EFD/g1p/auto-shortw.html
*)
let mk_k256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = KL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = KL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = KL.aff_point_add_comm_lemma;
}
let mk_k256_abelian_group : LE.abelian_group aff_point = {
LE.cm = mk_k256_comm_monoid;
LE.inverse = aff_point_negate;
LE.lemma_inverse = KL.aff_point_negate_lemma;
}
let mk_to_k256_comm_monoid : SE.to_comm_monoid proj_point = {
SE.a_spec = aff_point;
SE.comm_monoid = mk_k256_comm_monoid;
SE.refl = to_aff_point;
}
val point_at_inf_c: SE.one_st proj_point mk_to_k256_comm_monoid
let point_at_inf_c _ =
KL.to_aff_point_at_infinity_lemma ();
point_at_inf
val point_add_c : SE.mul_st proj_point mk_to_k256_comm_monoid
let point_add_c p q =
KL.to_aff_point_add_lemma p q;
point_add p q
val point_double_c : SE.sqr_st proj_point mk_to_k256_comm_monoid
let point_double_c p =
KL.to_aff_point_double_lemma p;
point_double p
let mk_k256_concrete_ops : SE.concrete_ops proj_point = {
SE.to = mk_to_k256_comm_monoid;
SE.one = point_at_inf_c;
SE.mul = point_add_c;
SE.sqr = point_double_c;
}
// [a]P in affine coordinates
let aff_point_mul (a:nat) (p:aff_point) : aff_point =
LE.pow mk_k256_comm_monoid p a
// [a]P
let point_mul (a:qelem) (p:proj_point) : proj_point =
SE.exp_fw mk_k256_concrete_ops p 256 a 4
// [a1]P1 + [a2]P2
let point_mul_double (a1:qelem) (p1:proj_point) (a2:qelem) (p2:proj_point) : proj_point =
SE.exp_double_fw mk_k256_concrete_ops p1 256 a1 p2 a2 5
// [a]G
let point_mul_g (a:qelem) : proj_point = point_mul a g
// [a1]G + [a2]P
let point_mul_double_g (a1:qelem) (a2:qelem) (p:proj_point) : proj_point =
point_mul_double a1 g a2 p
/// ECDSA with a prehashed message
let ecdsa_sign_hashed_msg (msgHash private_key nonce:lbytes 32) : option (lbytes 64) =
let k_q = nat_from_bytes_be nonce in
let d_a = nat_from_bytes_be private_key in
let z = nat_from_bytes_be msgHash % q in
let is_privkey_valid = 0 < d_a && d_a < q in
let is_nonce_valid = 0 < k_q && k_q < q in
if not (is_privkey_valid && is_nonce_valid) then None
else begin
let _X, _Y, _Z = point_mul_g k_q in
let x = _X /% _Z in
let r = x % q in
let kinv = qinv k_q in
let s = kinv *^ (z +^ r *^ d_a) in
let rb = nat_to_bytes_be 32 r in
let sb = nat_to_bytes_be 32 s in
if r = 0 || s = 0 then None else Some (concat #_ #32 #32 rb sb) end
let ecdsa_verify_hashed_msg (msgHash:lbytes 32) (public_key signature:lbytes 64) : bool =
let pk = load_point public_key in
let r = nat_from_bytes_be (sub signature 0 32) in
let s = nat_from_bytes_be (sub signature 32 32) in
let z = nat_from_bytes_be msgHash % q in
let is_r_valid = 0 < r && r < q in
let is_s_valid = 0 < s && s < q in
if not (Some? pk && is_r_valid && is_s_valid) then false
else begin
assert_norm (q < pow2 256);
let sinv = qinv s in
let u1 = z *^ sinv in
let u2 = r *^ sinv in
let _X, _Y, _Z = point_mul_double_g u1 u2 (Some?.v pk) in
if is_proj_point_at_inf (_X, _Y, _Z) then false
else begin
let x = _X /% _Z in
x % q = r end
end
(*
_Z <> 0
q < prime < 2 * q
let x = _X /% _Z in x % q = r <==>
1. x = r <==> _X = r *% _Z
2. x - q = r <==> _X = (r + q) *% _Z
*)
/// ECDSA using SHA2-256
let _: squash(Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32) =
assert_norm (Some?.v (Spec.Hash.Definitions.max_input_length Spec.Hash.Definitions.SHA2_256) > pow2 32)
let ecdsa_sign_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (private_key nonce:lbytes 32) : option (lbytes 64) =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_sign_hashed_msg msgHash private_key nonce
let ecdsa_verify_sha256 (msg_len:size_nat) (msg:lbytes msg_len) (public_key signature:lbytes 64) : bool =
let msgHash = Spec.Agile.Hash.hash Spec.Hash.Definitions.SHA2_256 msg in
ecdsa_verify_hashed_msg msgHash public_key signature
/// ECDH over the secp256k1 elliptic curve
let secret_to_public (private_key:lbytes 32) : option (lbytes 64) =
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if is_sk_valid then
let pk = point_mul_g sk in
Some (point_store pk)
else None
let ecdh (their_public_key:lbytes 64) (private_key:lbytes 32) : option (lbytes 64) =
let pk = load_point their_public_key in
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < q in
if Some? pk && is_sk_valid then
let ss = point_mul sk (Some?.v pk) in
Some (point_store ss)
else None
/// Parsing and Serializing public keys
// raw = [ x; y ], 64 bytes
// uncompressed = [ 0x04; x; y ], 65 bytes
// compressed = [ 0x02 for even `y` and 0x03 for odd `y`; x ], 33 bytes
let validate_public_key (pk:lbytes 64) : bool =
Some? (load_point pk)
let pk_uncompressed_to_raw (pk:lbytes 65) : option (lbytes 64) =
if Lib.RawIntTypes.u8_to_UInt8 pk.[0] <> 0x04uy then None else Some (sub pk 1 64)
let pk_uncompressed_from_raw (pk:lbytes 64) : lbytes 65 =
concat (create 1 (u8 0x04)) pk
let pk_compressed_to_raw (pk:lbytes 33) : option (lbytes 64) =
let pk_x = sub pk 1 32 in
match (aff_point_decompress pk) with
| Some (x, y) -> Some (concat #_ #32 #32 pk_x (nat_to_bytes_be 32 y))
| None -> None
let pk_compressed_from_raw (pk:lbytes 64) : lbytes 33 =
let pk_x = sub pk 0 32 in
let pk_y = sub pk 32 32 in
let is_pk_y_odd = nat_from_bytes_be pk_y % 2 = 1 in // <==> pk_y % 2 = 1
let pk0 = if is_pk_y_odd then u8 0x03 else u8 0x02 in
concat (create 1 pk0) pk_x
/// Low-S normalization
(**
https://en.bitcoin.it/wiki/BIP_0062
https://yondon.blog/2019/01/01/how-not-to-use-ecdsa/
https://eklitzke.org/bitcoin-transaction-malleability
*)
// The value S in signatures must be between 0x1 and q / 2 (inclusive).
| false | false |
Spec.K256.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val secp256k1_ecdsa_signature_normalize (signature: lbytes 64) : option (lbytes 64)
|
[] |
Spec.K256.secp256k1_ecdsa_signature_normalize
|
{
"file_name": "specs/Spec.K256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
signature: Lib.ByteSequence.lbytes 64 -> FStar.Pervasives.Native.option (Lib.ByteSequence.lbytes 64)
|
{
"end_col": 11,
"end_line": 225,
"start_col": 84,
"start_line": 217
}
|
Prims.Tot
|
val binding_to_namedv (b: binding) : Tot namedv
|
[
{
"abbrev": false,
"full_module": "FStar.Sealed",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let binding_to_namedv (b : binding) : Tot namedv =
{
ppname = b.ppname;
sort = seal b.sort;
uniq = b.uniq
}
|
val binding_to_namedv (b: binding) : Tot namedv
let binding_to_namedv (b: binding) : Tot namedv =
| false | null | false |
{ ppname = b.ppname; sort = seal b.sort; uniq = b.uniq }
|
{
"checked_file": "FStar.Tactics.V2.SyntaxCoercions.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.NamedView.fsti.checked",
"FStar.Tactics.Builtins.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.V2.SyntaxCoercions.fst"
}
|
[
"total"
] |
[
"FStar.Tactics.NamedView.binding",
"FStar.Reflection.V2.Data.Mknamedv_view",
"FStar.Reflection.V2.Data.__proj__Mkbinding__item__uniq",
"FStar.Sealed.seal",
"FStar.Reflection.Types.typ",
"FStar.Reflection.V2.Data.__proj__Mkbinding__item__sort",
"FStar.Reflection.V2.Data.__proj__Mkbinding__item__ppname",
"FStar.Tactics.NamedView.namedv"
] |
[] |
module FStar.Tactics.V2.SyntaxCoercions
open FStar.Tactics.Builtins
open FStar.Tactics.NamedView
open FStar.Sealed
[@@coercion]
let namedv_to_term (x : namedv) : Tot term =
pack (Tv_Var x)
[@@coercion]
let binder_to_namedv (b : binder) : Tot namedv =
{
ppname = b.ppname;
uniq = b.uniq;
sort = seal b.sort;
}
[@@coercion]
let binder_to_term (b : binder) : Tot term =
pack (Tv_Var (binder_to_namedv b))
[@@coercion]
let binding_to_namedv (b : binding) : Tot namedv =
| false | true |
FStar.Tactics.V2.SyntaxCoercions.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val binding_to_namedv (b: binding) : Tot namedv
|
[] |
FStar.Tactics.V2.SyntaxCoercions.binding_to_namedv
|
{
"file_name": "ulib/FStar.Tactics.V2.SyntaxCoercions.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
}
|
b: FStar.Tactics.NamedView.binding -> FStar.Tactics.NamedView.namedv
|
{
"end_col": 19,
"end_line": 28,
"start_col": 4,
"start_line": 26
}
|
Prims.Tot
|
val binder_to_term (b: binder) : Tot term
|
[
{
"abbrev": false,
"full_module": "FStar.Sealed",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let binder_to_term (b : binder) : Tot term =
pack (Tv_Var (binder_to_namedv b))
|
val binder_to_term (b: binder) : Tot term
let binder_to_term (b: binder) : Tot term =
| false | null | false |
pack (Tv_Var (binder_to_namedv b))
|
{
"checked_file": "FStar.Tactics.V2.SyntaxCoercions.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.NamedView.fsti.checked",
"FStar.Tactics.Builtins.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.V2.SyntaxCoercions.fst"
}
|
[
"total"
] |
[
"FStar.Tactics.NamedView.binder",
"FStar.Tactics.NamedView.pack",
"FStar.Tactics.NamedView.Tv_Var",
"FStar.Tactics.V2.SyntaxCoercions.binder_to_namedv",
"FStar.Tactics.NamedView.term"
] |
[] |
module FStar.Tactics.V2.SyntaxCoercions
open FStar.Tactics.Builtins
open FStar.Tactics.NamedView
open FStar.Sealed
[@@coercion]
let namedv_to_term (x : namedv) : Tot term =
pack (Tv_Var x)
[@@coercion]
let binder_to_namedv (b : binder) : Tot namedv =
{
ppname = b.ppname;
uniq = b.uniq;
sort = seal b.sort;
}
[@@coercion]
| false | true |
FStar.Tactics.V2.SyntaxCoercions.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val binder_to_term (b: binder) : Tot term
|
[] |
FStar.Tactics.V2.SyntaxCoercions.binder_to_term
|
{
"file_name": "ulib/FStar.Tactics.V2.SyntaxCoercions.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
}
|
b: FStar.Tactics.NamedView.binder -> FStar.Tactics.NamedView.term
|
{
"end_col": 36,
"end_line": 21,
"start_col": 2,
"start_line": 21
}
|
Prims.Tot
|
val binder_to_namedv (b: binder) : Tot namedv
|
[
{
"abbrev": false,
"full_module": "FStar.Sealed",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let binder_to_namedv (b : binder) : Tot namedv =
{
ppname = b.ppname;
uniq = b.uniq;
sort = seal b.sort;
}
|
val binder_to_namedv (b: binder) : Tot namedv
let binder_to_namedv (b: binder) : Tot namedv =
| false | null | false |
{ ppname = b.ppname; uniq = b.uniq; sort = seal b.sort }
|
{
"checked_file": "FStar.Tactics.V2.SyntaxCoercions.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.NamedView.fsti.checked",
"FStar.Tactics.Builtins.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.V2.SyntaxCoercions.fst"
}
|
[
"total"
] |
[
"FStar.Tactics.NamedView.binder",
"FStar.Reflection.V2.Data.Mknamedv_view",
"FStar.Tactics.NamedView.__proj__Mkbinder__item__uniq",
"FStar.Sealed.seal",
"FStar.Reflection.Types.typ",
"FStar.Tactics.NamedView.__proj__Mkbinder__item__sort",
"FStar.Tactics.NamedView.__proj__Mkbinder__item__ppname",
"FStar.Tactics.NamedView.namedv"
] |
[] |
module FStar.Tactics.V2.SyntaxCoercions
open FStar.Tactics.Builtins
open FStar.Tactics.NamedView
open FStar.Sealed
[@@coercion]
let namedv_to_term (x : namedv) : Tot term =
pack (Tv_Var x)
[@@coercion]
let binder_to_namedv (b : binder) : Tot namedv =
| false | true |
FStar.Tactics.V2.SyntaxCoercions.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val binder_to_namedv (b: binder) : Tot namedv
|
[] |
FStar.Tactics.V2.SyntaxCoercions.binder_to_namedv
|
{
"file_name": "ulib/FStar.Tactics.V2.SyntaxCoercions.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
}
|
b: FStar.Tactics.NamedView.binder -> FStar.Tactics.NamedView.namedv
|
{
"end_col": 25,
"end_line": 16,
"start_col": 4,
"start_line": 14
}
|
Prims.Tot
|
val namedv_to_term (x: namedv) : Tot term
|
[
{
"abbrev": false,
"full_module": "FStar.Sealed",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let namedv_to_term (x : namedv) : Tot term =
pack (Tv_Var x)
|
val namedv_to_term (x: namedv) : Tot term
let namedv_to_term (x: namedv) : Tot term =
| false | null | false |
pack (Tv_Var x)
|
{
"checked_file": "FStar.Tactics.V2.SyntaxCoercions.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.NamedView.fsti.checked",
"FStar.Tactics.Builtins.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.V2.SyntaxCoercions.fst"
}
|
[
"total"
] |
[
"FStar.Tactics.NamedView.namedv",
"FStar.Tactics.NamedView.pack",
"FStar.Tactics.NamedView.Tv_Var",
"FStar.Tactics.NamedView.term"
] |
[] |
module FStar.Tactics.V2.SyntaxCoercions
open FStar.Tactics.Builtins
open FStar.Tactics.NamedView
open FStar.Sealed
[@@coercion]
| false | true |
FStar.Tactics.V2.SyntaxCoercions.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val namedv_to_term (x: namedv) : Tot term
|
[] |
FStar.Tactics.V2.SyntaxCoercions.namedv_to_term
|
{
"file_name": "ulib/FStar.Tactics.V2.SyntaxCoercions.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
}
|
x: FStar.Tactics.NamedView.namedv -> FStar.Tactics.NamedView.term
|
{
"end_col": 17,
"end_line": 9,
"start_col": 2,
"start_line": 9
}
|
Prims.Tot
|
val binding_to_term (x: binding) : Tot term
|
[
{
"abbrev": false,
"full_module": "FStar.Sealed",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let binding_to_term (x : binding) : Tot term =
namedv_to_term (binding_to_namedv x)
|
val binding_to_term (x: binding) : Tot term
let binding_to_term (x: binding) : Tot term =
| false | null | false |
namedv_to_term (binding_to_namedv x)
|
{
"checked_file": "FStar.Tactics.V2.SyntaxCoercions.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.NamedView.fsti.checked",
"FStar.Tactics.Builtins.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.V2.SyntaxCoercions.fst"
}
|
[
"total"
] |
[
"FStar.Tactics.NamedView.binding",
"FStar.Tactics.V2.SyntaxCoercions.namedv_to_term",
"FStar.Tactics.V2.SyntaxCoercions.binding_to_namedv",
"FStar.Tactics.NamedView.term"
] |
[] |
module FStar.Tactics.V2.SyntaxCoercions
open FStar.Tactics.Builtins
open FStar.Tactics.NamedView
open FStar.Sealed
[@@coercion]
let namedv_to_term (x : namedv) : Tot term =
pack (Tv_Var x)
[@@coercion]
let binder_to_namedv (b : binder) : Tot namedv =
{
ppname = b.ppname;
uniq = b.uniq;
sort = seal b.sort;
}
[@@coercion]
let binder_to_term (b : binder) : Tot term =
pack (Tv_Var (binder_to_namedv b))
[@@coercion]
let binding_to_namedv (b : binding) : Tot namedv =
{
ppname = b.ppname;
sort = seal b.sort;
uniq = b.uniq
}
[@@coercion]
| false | true |
FStar.Tactics.V2.SyntaxCoercions.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val binding_to_term (x: binding) : Tot term
|
[] |
FStar.Tactics.V2.SyntaxCoercions.binding_to_term
|
{
"file_name": "ulib/FStar.Tactics.V2.SyntaxCoercions.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
}
|
x: FStar.Tactics.NamedView.binding -> FStar.Tactics.NamedView.term
|
{
"end_col": 38,
"end_line": 33,
"start_col": 2,
"start_line": 33
}
|
Prims.Tot
|
val encryption_context (cs:ciphersuite) : Type0
|
[
{
"abbrev": true,
"full_module": "Spec.Agile.HKDF",
"short_module": "HKDF"
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"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": true,
"full_module": "Spec.Agile.HKDF",
"short_module": "HKDF"
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"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.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let encryption_context (cs:ciphersuite) = key_aead_s cs & nonce_aead_s cs & seq_aead_s cs & exporter_secret_s cs
|
val encryption_context (cs:ciphersuite) : Type0
let encryption_context (cs: ciphersuite) =
| false | null | false |
key_aead_s cs & nonce_aead_s cs & seq_aead_s cs & exporter_secret_s cs
|
{
"checked_file": "Spec.Agile.HPKE.fst.checked",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Loops.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"Spec.Agile.HKDF.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"Spec.Agile.DH.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Spec.Agile.HPKE.fst"
}
|
[
"total"
] |
[
"Spec.Agile.HPKE.ciphersuite",
"FStar.Pervasives.Native.tuple4",
"Spec.Agile.HPKE.key_aead_s",
"Spec.Agile.HPKE.nonce_aead_s",
"Spec.Agile.HPKE.seq_aead_s",
"Spec.Agile.HPKE.exporter_secret_s"
] |
[] |
module Spec.Agile.HPKE
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module DH = Spec.Agile.DH
module AEAD = Spec.Agile.AEAD
module Hash = Spec.Agile.Hash
module HKDF = Spec.Agile.HKDF
let pow2_61 : _:unit{pow2 61 == 2305843009213693952} = assert_norm(pow2 61 == 2305843009213693952)
let pow2_35_less_than_pow2_61 : _:unit{pow2 32 * pow2 3 <= pow2 61 - 1} = assert_norm(pow2 32 * pow2 3 <= pow2 61 - 1)
let pow2_35_less_than_pow2_125 : _:unit{pow2 32 * pow2 3 <= pow2 125 - 1} = assert_norm(pow2 32 * pow2 3 <= pow2 125 - 1)
#set-options "--z3rlimit 20 --fuel 0 --ifuel 1"
/// Types
val id_kem: cs:ciphersuite -> Tot (lbytes 2)
let id_kem cs = let kem_dh, kem_hash, _, _ = cs in
match kem_dh, kem_hash with
| DH.DH_P256, Hash.SHA2_256 -> create 1 (u8 0) @| create 1 (u8 16)
| DH.DH_Curve25519, Hash.SHA2_256 -> create 1 (u8 0) @| create 1 (u8 32)
val id_kdf: cs:ciphersuite -> Tot (lbytes 2)
let id_kdf cs = let _, _, _, h = cs in
match h with
| Hash.SHA2_256 -> create 1 (u8 0) @| create 1 (u8 1)
| Hash.SHA2_384 -> create 1 (u8 0) @| create 1 (u8 2)
| Hash.SHA2_512 -> create 1 (u8 0) @| create 1 (u8 3)
val id_aead: cs:ciphersuite -> Tot (lbytes 2)
let id_aead cs = let _, _, a, _ = cs in
match a with
| Seal AEAD.AES128_GCM -> create 1 (u8 0) @| create 1 (u8 1)
| Seal AEAD.AES256_GCM -> create 1 (u8 0) @| create 1 (u8 2)
| Seal AEAD.CHACHA20_POLY1305 -> create 1 (u8 0) @| create 1 (u8 3)
| ExportOnly -> create 1 (u8 255) @| create 1 (u8 255)
val suite_id_kem: cs:ciphersuite -> Tot (lbytes size_suite_id_kem)
let suite_id_kem cs =
Seq.append label_KEM (id_kem cs)
val suite_id_hpke: cs:ciphersuite -> Tot (lbytes size_suite_id_hpke)
let suite_id_hpke cs =
Seq.append label_HPKE (id_kem cs @| id_kdf cs @| id_aead cs)
val id_of_mode: m:mode -> Tot (lbytes size_mode_identifier)
let id_of_mode m =
match m with
| Base -> create 1 (u8 0)
| PSK -> create 1 (u8 1)
| Auth -> create 1 (u8 2)
| AuthPSK -> create 1 (u8 3)
val labeled_extract:
a:hash_algorithm
-> suite_id:bytes
-> salt:bytes
-> label:bytes
-> ikm:bytes ->
Pure (lbytes (Spec.Hash.Definitions.hash_length a))
(requires
Spec.Agile.HMAC.keysized a (Seq.length salt) /\
labeled_extract_ikm_length_pred a (Seq.length suite_id + Seq.length label + Seq.length ikm))
(ensures fun _ -> True)
let labeled_extract a suite_id salt label ikm =
let labeled_ikm1 = Seq.append label_version suite_id in
let labeled_ikm2 = Seq.append labeled_ikm1 label in
let labeled_ikm3 = Seq.append labeled_ikm2 ikm in
HKDF.extract a salt labeled_ikm3
val labeled_expand:
a:hash_algorithm
-> suite_id:bytes
-> prk:bytes
-> label:bytes
-> info:bytes
-> l:size_nat ->
Pure (lbytes l)
(requires
Spec.Hash.Definitions.hash_length a <= Seq.length prk /\
Spec.Agile.HMAC.keysized a (Seq.length prk) /\
labeled_expand_info_length_pred a (Seq.length suite_id + Seq.length label + Seq.length info) /\
HKDF.expand_output_length_pred a l)
(ensures fun _ -> True)
let labeled_expand a suite_id prk label info l =
let labeled_info1 = nat_to_bytes_be 2 l in
let labeled_info2 = Seq.append labeled_info1 label_version in
let labeled_info3 = Seq.append labeled_info2 suite_id in
let labeled_info4 = Seq.append labeled_info3 label in
let labeled_info5 = Seq.append labeled_info4 info in
HKDF.expand a prk labeled_info5 l
let extract_and_expand_dh_pred (cs:ciphersuite) (dh_length:nat) =
labeled_extract_ikm_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_eae_prk + dh_length)
let extract_and_expand_ctx_pred (cs:ciphersuite) (ctx_length:nat) =
labeled_expand_info_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_shared_secret + ctx_length)
val extract_and_expand:
cs:ciphersuite
-> dh:bytes
-> kem_context:bytes ->
Pure (key_kem_s cs)
(requires
extract_and_expand_dh_pred cs (Seq.length dh) /\
extract_and_expand_ctx_pred cs (Seq.length kem_context))
(ensures fun _ -> True)
let extract_and_expand cs dh kem_context =
let eae_prk = labeled_extract (kem_hash_of_cs cs) (suite_id_kem cs) lbytes_empty label_eae_prk dh in
labeled_expand (kem_hash_of_cs cs) (suite_id_kem cs) eae_prk label_shared_secret kem_context (size_kem_key cs)
let deserialize_public_key cs pk = match kem_dh_of_cs cs with
| DH.DH_Curve25519 -> pk
// Extract the point coordinates by removing the first representation byte
| DH.DH_P256 -> sub pk 1 64
let serialize_public_key cs pk = match kem_dh_of_cs cs with
| DH.DH_Curve25519 -> pk
// Add the first representation byte to the point coordinates
| DH.DH_P256 -> create 1 (u8 4) @| pk
val dkp_nist_p: cs:ciphersuite -> lbytes (size_kem_kdf cs) -> counter:uint8 -> Tot (option (key_dh_secret_s cs & key_dh_public_s cs)) (decreases 255 - v counter)
let rec dkp_nist_p cs dkp_prk counter =
let counterbyte = nat_to_intseq_be #U8 #SEC 1 (v counter) in
let bytes = labeled_expand (kem_hash_of_cs cs) (suite_id_kem cs) dkp_prk label_candidate counterbyte (size_dh_key cs) in
let bytes = Lib.Sequence.map2 (logand #U8 #SEC) bytes (Seq.create (size_dh_key cs) (u8 255)) in
let sk = nat_from_intseq_be #U8 #SEC bytes in
if sk = 0 || sk >= Spec.P256.prime then
if (v counter) = 255 then None
else dkp_nist_p cs dkp_prk (counter +! (u8 1))
else
match DH.secret_to_public (kem_dh_of_cs cs) bytes with
| Some pk -> Some (bytes, serialize_public_key cs pk)
| None ->
if (v counter) = 255 then None
else dkp_nist_p cs dkp_prk (counter +! (u8 1))
let derive_key_pair cs ikm =
match kem_dh_of_cs cs with
| DH.DH_Curve25519 -> begin
let dkp_prk = labeled_extract (kem_hash_of_cs cs) (suite_id_kem cs) lbytes_empty label_dkp_prk ikm in
let sk = labeled_expand (kem_hash_of_cs cs) (suite_id_kem cs) dkp_prk label_sk lbytes_empty (size_dh_key cs) in
match DH.secret_to_public (kem_dh_of_cs cs) sk with
| Some pk -> Some (sk, serialize_public_key cs pk)
end
| DH.DH_P256 ->
let dkp_prk = labeled_extract (kem_hash_of_cs cs) (suite_id_kem cs) lbytes_empty label_dkp_prk ikm in
dkp_nist_p cs dkp_prk (u8 0)
val prepare_dh: cs:ciphersuite -> DH.serialized_point (kem_dh_of_cs cs) -> Tot (lbytes 32)
let prepare_dh cs dh = match (kem_dh_of_cs cs) with
| DH.DH_Curve25519 -> serialize_public_key cs dh
| DH.DH_P256 -> sub dh 0 32
val encap:
cs:ciphersuite
-> skE:key_dh_secret_s cs
-> pkR:DH.serialized_point (kem_dh_of_cs cs) ->
Tot (option (key_kem_s cs & key_dh_public_s cs))
#restart-solver
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let encap cs skE pkR =
let _ = allow_inversion Spec.Agile.DH.algorithm in
match DH.secret_to_public (kem_dh_of_cs cs) skE with
| None -> None
| Some pkE ->
let enc = serialize_public_key cs pkE in
match DH.dh (kem_dh_of_cs cs) skE pkR with
| None -> None
| Some dh ->
let pkRm = serialize_public_key cs pkR in
let kem_context = concat enc pkRm in
let dhm = prepare_dh cs dh in
assert (Seq.length kem_context = 2*size_dh_public cs);
assert (extract_and_expand_ctx_pred cs (Seq.length kem_context));
let shared_secret:key_kem_s cs = extract_and_expand cs dhm kem_context in
Some (shared_secret, enc)
val decap:
cs: ciphersuite
-> enc: key_dh_public_s cs
-> skR: key_dh_secret_s cs ->
Tot (option (key_kem_s cs))
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let decap cs enc skR =
let _ = allow_inversion Spec.Agile.DH.algorithm in
let _ = allow_inversion Spec.Agile.Hash.hash_alg in
let pkE = deserialize_public_key cs enc in
match DH.dh (kem_dh_of_cs cs) skR pkE with
| None -> None
| Some dh ->
match DH.secret_to_public (kem_dh_of_cs cs) skR with
| None -> None
| Some pkR ->
let pkRm = serialize_public_key cs pkR in
let kem_context = concat enc pkRm in
let dhm = prepare_dh cs dh in
assert (Seq.length kem_context = 2*size_dh_public cs);
assert (extract_and_expand_ctx_pred cs (Seq.length kem_context));
let shared_secret = extract_and_expand cs dhm kem_context in
Some (shared_secret)
val auth_encap:
cs:ciphersuite
-> skE:key_dh_secret_s cs
-> pkR:DH.serialized_point (kem_dh_of_cs cs)
-> skS:key_dh_secret_s cs ->
Tot (option (key_kem_s cs & key_dh_public_s cs))
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let auth_encap cs skE pkR skS =
let _ = allow_inversion Spec.Agile.DH.algorithm in
match DH.secret_to_public (kem_dh_of_cs cs) skE with
| None -> None
| Some pkE ->
match DH.dh (kem_dh_of_cs cs) skE pkR with
| None -> None
| Some es ->
match DH.dh (kem_dh_of_cs cs) skS pkR with
| None -> None
| Some ss ->
let esm = prepare_dh cs es in
let ssm = prepare_dh cs ss in
// TODO Do not put 32 literally
let dh = concat #uint8 #32 #32 esm ssm in
let enc = serialize_public_key cs pkE in
match DH.secret_to_public (kem_dh_of_cs cs) skS with
| None -> None
| Some pkS ->
let pkSm = serialize_public_key cs pkS in
let pkRm = serialize_public_key cs pkR in
let kem_context = concat enc (concat pkRm pkSm) in
assert (Seq.length kem_context = 3*size_dh_public cs);
assert (labeled_expand_info_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_shared_secret + Seq.length kem_context));
assert (extract_and_expand_ctx_pred cs (Seq.length kem_context));
// TODO Do not put 64 literally
assert (Seq.length dh = 64);
assert (labeled_extract_ikm_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_eae_prk + Seq.length dh));
assert (extract_and_expand_dh_pred cs (Seq.length dh));
let shared_secret = extract_and_expand cs dh kem_context in
Some (shared_secret, enc)
#reset-options
val auth_decap:
cs: ciphersuite
-> enc: key_dh_public_s cs
-> skR: key_dh_secret_s cs
-> pkS: DH.serialized_point (kem_dh_of_cs cs) ->
Tot (option (key_kem_s cs))
#restart-solver
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let auth_decap cs enc skR pkS =
let _ = allow_inversion Spec.Agile.DH.algorithm in
let pkE = deserialize_public_key cs enc in
match DH.dh (kem_dh_of_cs cs) skR pkE with
| None -> None
| Some es ->
match DH.dh (kem_dh_of_cs cs) skR pkS with
| None -> None
| Some ss ->
let esm = prepare_dh cs es in
let ssm = prepare_dh cs ss in
let dh = concat #uint8 #32 #32 esm ssm in
match DH.secret_to_public (kem_dh_of_cs cs) skR with
| None -> None
| Some pkR ->
let pkRm = serialize_public_key cs pkR in
let pkSm = serialize_public_key cs pkS in
let kem_context = concat enc (concat pkRm pkSm) in
assert (Seq.length kem_context = 3*size_dh_public cs);
assert (labeled_expand_info_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_shared_secret + Seq.length kem_context));
assert (extract_and_expand_ctx_pred cs (Seq.length kem_context));
assert (Seq.length dh = 64);
assert (labeled_extract_ikm_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_eae_prk + Seq.length dh));
assert (extract_and_expand_dh_pred cs (Seq.length dh));
let shared_secret = extract_and_expand cs dh kem_context in
Some (shared_secret)
#reset-options
let default_psk = lbytes_empty
let default_psk_id = lbytes_empty
val build_context:
cs:ciphersuite
-> m:mode
-> psk_id_hash:lbytes (size_kdf cs)
-> info_hash:lbytes (size_kdf cs) ->
Tot (lbytes (size_ks_ctx cs))
let build_context cs m psk_id_hash info_hash =
let context = id_of_mode m in
let context = Seq.append context psk_id_hash in
let context = Seq.append context info_hash in
context
let verify_psk_inputs (cs:ciphersuite) (m:mode) (opsk:option(psk_s cs & psk_id_s cs)) : bool =
match (m, opsk) with
| Base, None -> true
| PSK, Some _ -> true
| Auth, None -> true
| AuthPSK, Some _ -> true
| _, _ -> false
| false | true |
Spec.Agile.HPKE.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val encryption_context (cs:ciphersuite) : Type0
|
[] |
Spec.Agile.HPKE.encryption_context
|
{
"file_name": "specs/Spec.Agile.HPKE.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
cs: Spec.Agile.HPKE.ciphersuite -> Type0
|
{
"end_col": 112,
"end_line": 331,
"start_col": 42,
"start_line": 331
}
|
Prims.Tot
|
val pow2_35_less_than_pow2_61:_: unit{pow2 32 * pow2 3 <= pow2 61 - 1}
|
[
{
"abbrev": true,
"full_module": "Spec.Agile.HKDF",
"short_module": "HKDF"
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"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": true,
"full_module": "Spec.Agile.HKDF",
"short_module": "HKDF"
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"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.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let pow2_35_less_than_pow2_61 : _:unit{pow2 32 * pow2 3 <= pow2 61 - 1} = assert_norm(pow2 32 * pow2 3 <= pow2 61 - 1)
|
val pow2_35_less_than_pow2_61:_: unit{pow2 32 * pow2 3 <= pow2 61 - 1}
let pow2_35_less_than_pow2_61:_: unit{pow2 32 * pow2 3 <= pow2 61 - 1} =
| false | null | false |
assert_norm (pow2 32 * pow2 3 <= pow2 61 - 1)
|
{
"checked_file": "Spec.Agile.HPKE.fst.checked",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Loops.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"Spec.Agile.HKDF.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"Spec.Agile.DH.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Spec.Agile.HPKE.fst"
}
|
[
"total"
] |
[
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.op_Subtraction"
] |
[] |
module Spec.Agile.HPKE
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module DH = Spec.Agile.DH
module AEAD = Spec.Agile.AEAD
module Hash = Spec.Agile.Hash
module HKDF = Spec.Agile.HKDF
| false | false |
Spec.Agile.HPKE.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val pow2_35_less_than_pow2_61:_: unit{pow2 32 * pow2 3 <= pow2 61 - 1}
|
[] |
Spec.Agile.HPKE.pow2_35_less_than_pow2_61
|
{
"file_name": "specs/Spec.Agile.HPKE.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
_: Prims.unit{Prims.pow2 32 * Prims.pow2 3 <= Prims.pow2 61 - 1}
|
{
"end_col": 118,
"end_line": 16,
"start_col": 74,
"start_line": 16
}
|
Prims.Tot
|
[
{
"abbrev": true,
"full_module": "Spec.Agile.HKDF",
"short_module": "HKDF"
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"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": true,
"full_module": "Spec.Agile.HKDF",
"short_module": "HKDF"
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"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.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let default_psk_id = lbytes_empty
|
let default_psk_id =
| false | null | false |
lbytes_empty
|
{
"checked_file": "Spec.Agile.HPKE.fst.checked",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Loops.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"Spec.Agile.HKDF.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"Spec.Agile.DH.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Spec.Agile.HPKE.fst"
}
|
[
"total"
] |
[
"Lib.ByteSequence.lbytes_empty"
] |
[] |
module Spec.Agile.HPKE
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module DH = Spec.Agile.DH
module AEAD = Spec.Agile.AEAD
module Hash = Spec.Agile.Hash
module HKDF = Spec.Agile.HKDF
let pow2_61 : _:unit{pow2 61 == 2305843009213693952} = assert_norm(pow2 61 == 2305843009213693952)
let pow2_35_less_than_pow2_61 : _:unit{pow2 32 * pow2 3 <= pow2 61 - 1} = assert_norm(pow2 32 * pow2 3 <= pow2 61 - 1)
let pow2_35_less_than_pow2_125 : _:unit{pow2 32 * pow2 3 <= pow2 125 - 1} = assert_norm(pow2 32 * pow2 3 <= pow2 125 - 1)
#set-options "--z3rlimit 20 --fuel 0 --ifuel 1"
/// Types
val id_kem: cs:ciphersuite -> Tot (lbytes 2)
let id_kem cs = let kem_dh, kem_hash, _, _ = cs in
match kem_dh, kem_hash with
| DH.DH_P256, Hash.SHA2_256 -> create 1 (u8 0) @| create 1 (u8 16)
| DH.DH_Curve25519, Hash.SHA2_256 -> create 1 (u8 0) @| create 1 (u8 32)
val id_kdf: cs:ciphersuite -> Tot (lbytes 2)
let id_kdf cs = let _, _, _, h = cs in
match h with
| Hash.SHA2_256 -> create 1 (u8 0) @| create 1 (u8 1)
| Hash.SHA2_384 -> create 1 (u8 0) @| create 1 (u8 2)
| Hash.SHA2_512 -> create 1 (u8 0) @| create 1 (u8 3)
val id_aead: cs:ciphersuite -> Tot (lbytes 2)
let id_aead cs = let _, _, a, _ = cs in
match a with
| Seal AEAD.AES128_GCM -> create 1 (u8 0) @| create 1 (u8 1)
| Seal AEAD.AES256_GCM -> create 1 (u8 0) @| create 1 (u8 2)
| Seal AEAD.CHACHA20_POLY1305 -> create 1 (u8 0) @| create 1 (u8 3)
| ExportOnly -> create 1 (u8 255) @| create 1 (u8 255)
val suite_id_kem: cs:ciphersuite -> Tot (lbytes size_suite_id_kem)
let suite_id_kem cs =
Seq.append label_KEM (id_kem cs)
val suite_id_hpke: cs:ciphersuite -> Tot (lbytes size_suite_id_hpke)
let suite_id_hpke cs =
Seq.append label_HPKE (id_kem cs @| id_kdf cs @| id_aead cs)
val id_of_mode: m:mode -> Tot (lbytes size_mode_identifier)
let id_of_mode m =
match m with
| Base -> create 1 (u8 0)
| PSK -> create 1 (u8 1)
| Auth -> create 1 (u8 2)
| AuthPSK -> create 1 (u8 3)
val labeled_extract:
a:hash_algorithm
-> suite_id:bytes
-> salt:bytes
-> label:bytes
-> ikm:bytes ->
Pure (lbytes (Spec.Hash.Definitions.hash_length a))
(requires
Spec.Agile.HMAC.keysized a (Seq.length salt) /\
labeled_extract_ikm_length_pred a (Seq.length suite_id + Seq.length label + Seq.length ikm))
(ensures fun _ -> True)
let labeled_extract a suite_id salt label ikm =
let labeled_ikm1 = Seq.append label_version suite_id in
let labeled_ikm2 = Seq.append labeled_ikm1 label in
let labeled_ikm3 = Seq.append labeled_ikm2 ikm in
HKDF.extract a salt labeled_ikm3
val labeled_expand:
a:hash_algorithm
-> suite_id:bytes
-> prk:bytes
-> label:bytes
-> info:bytes
-> l:size_nat ->
Pure (lbytes l)
(requires
Spec.Hash.Definitions.hash_length a <= Seq.length prk /\
Spec.Agile.HMAC.keysized a (Seq.length prk) /\
labeled_expand_info_length_pred a (Seq.length suite_id + Seq.length label + Seq.length info) /\
HKDF.expand_output_length_pred a l)
(ensures fun _ -> True)
let labeled_expand a suite_id prk label info l =
let labeled_info1 = nat_to_bytes_be 2 l in
let labeled_info2 = Seq.append labeled_info1 label_version in
let labeled_info3 = Seq.append labeled_info2 suite_id in
let labeled_info4 = Seq.append labeled_info3 label in
let labeled_info5 = Seq.append labeled_info4 info in
HKDF.expand a prk labeled_info5 l
let extract_and_expand_dh_pred (cs:ciphersuite) (dh_length:nat) =
labeled_extract_ikm_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_eae_prk + dh_length)
let extract_and_expand_ctx_pred (cs:ciphersuite) (ctx_length:nat) =
labeled_expand_info_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_shared_secret + ctx_length)
val extract_and_expand:
cs:ciphersuite
-> dh:bytes
-> kem_context:bytes ->
Pure (key_kem_s cs)
(requires
extract_and_expand_dh_pred cs (Seq.length dh) /\
extract_and_expand_ctx_pred cs (Seq.length kem_context))
(ensures fun _ -> True)
let extract_and_expand cs dh kem_context =
let eae_prk = labeled_extract (kem_hash_of_cs cs) (suite_id_kem cs) lbytes_empty label_eae_prk dh in
labeled_expand (kem_hash_of_cs cs) (suite_id_kem cs) eae_prk label_shared_secret kem_context (size_kem_key cs)
let deserialize_public_key cs pk = match kem_dh_of_cs cs with
| DH.DH_Curve25519 -> pk
// Extract the point coordinates by removing the first representation byte
| DH.DH_P256 -> sub pk 1 64
let serialize_public_key cs pk = match kem_dh_of_cs cs with
| DH.DH_Curve25519 -> pk
// Add the first representation byte to the point coordinates
| DH.DH_P256 -> create 1 (u8 4) @| pk
val dkp_nist_p: cs:ciphersuite -> lbytes (size_kem_kdf cs) -> counter:uint8 -> Tot (option (key_dh_secret_s cs & key_dh_public_s cs)) (decreases 255 - v counter)
let rec dkp_nist_p cs dkp_prk counter =
let counterbyte = nat_to_intseq_be #U8 #SEC 1 (v counter) in
let bytes = labeled_expand (kem_hash_of_cs cs) (suite_id_kem cs) dkp_prk label_candidate counterbyte (size_dh_key cs) in
let bytes = Lib.Sequence.map2 (logand #U8 #SEC) bytes (Seq.create (size_dh_key cs) (u8 255)) in
let sk = nat_from_intseq_be #U8 #SEC bytes in
if sk = 0 || sk >= Spec.P256.prime then
if (v counter) = 255 then None
else dkp_nist_p cs dkp_prk (counter +! (u8 1))
else
match DH.secret_to_public (kem_dh_of_cs cs) bytes with
| Some pk -> Some (bytes, serialize_public_key cs pk)
| None ->
if (v counter) = 255 then None
else dkp_nist_p cs dkp_prk (counter +! (u8 1))
let derive_key_pair cs ikm =
match kem_dh_of_cs cs with
| DH.DH_Curve25519 -> begin
let dkp_prk = labeled_extract (kem_hash_of_cs cs) (suite_id_kem cs) lbytes_empty label_dkp_prk ikm in
let sk = labeled_expand (kem_hash_of_cs cs) (suite_id_kem cs) dkp_prk label_sk lbytes_empty (size_dh_key cs) in
match DH.secret_to_public (kem_dh_of_cs cs) sk with
| Some pk -> Some (sk, serialize_public_key cs pk)
end
| DH.DH_P256 ->
let dkp_prk = labeled_extract (kem_hash_of_cs cs) (suite_id_kem cs) lbytes_empty label_dkp_prk ikm in
dkp_nist_p cs dkp_prk (u8 0)
val prepare_dh: cs:ciphersuite -> DH.serialized_point (kem_dh_of_cs cs) -> Tot (lbytes 32)
let prepare_dh cs dh = match (kem_dh_of_cs cs) with
| DH.DH_Curve25519 -> serialize_public_key cs dh
| DH.DH_P256 -> sub dh 0 32
val encap:
cs:ciphersuite
-> skE:key_dh_secret_s cs
-> pkR:DH.serialized_point (kem_dh_of_cs cs) ->
Tot (option (key_kem_s cs & key_dh_public_s cs))
#restart-solver
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let encap cs skE pkR =
let _ = allow_inversion Spec.Agile.DH.algorithm in
match DH.secret_to_public (kem_dh_of_cs cs) skE with
| None -> None
| Some pkE ->
let enc = serialize_public_key cs pkE in
match DH.dh (kem_dh_of_cs cs) skE pkR with
| None -> None
| Some dh ->
let pkRm = serialize_public_key cs pkR in
let kem_context = concat enc pkRm in
let dhm = prepare_dh cs dh in
assert (Seq.length kem_context = 2*size_dh_public cs);
assert (extract_and_expand_ctx_pred cs (Seq.length kem_context));
let shared_secret:key_kem_s cs = extract_and_expand cs dhm kem_context in
Some (shared_secret, enc)
val decap:
cs: ciphersuite
-> enc: key_dh_public_s cs
-> skR: key_dh_secret_s cs ->
Tot (option (key_kem_s cs))
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let decap cs enc skR =
let _ = allow_inversion Spec.Agile.DH.algorithm in
let _ = allow_inversion Spec.Agile.Hash.hash_alg in
let pkE = deserialize_public_key cs enc in
match DH.dh (kem_dh_of_cs cs) skR pkE with
| None -> None
| Some dh ->
match DH.secret_to_public (kem_dh_of_cs cs) skR with
| None -> None
| Some pkR ->
let pkRm = serialize_public_key cs pkR in
let kem_context = concat enc pkRm in
let dhm = prepare_dh cs dh in
assert (Seq.length kem_context = 2*size_dh_public cs);
assert (extract_and_expand_ctx_pred cs (Seq.length kem_context));
let shared_secret = extract_and_expand cs dhm kem_context in
Some (shared_secret)
val auth_encap:
cs:ciphersuite
-> skE:key_dh_secret_s cs
-> pkR:DH.serialized_point (kem_dh_of_cs cs)
-> skS:key_dh_secret_s cs ->
Tot (option (key_kem_s cs & key_dh_public_s cs))
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let auth_encap cs skE pkR skS =
let _ = allow_inversion Spec.Agile.DH.algorithm in
match DH.secret_to_public (kem_dh_of_cs cs) skE with
| None -> None
| Some pkE ->
match DH.dh (kem_dh_of_cs cs) skE pkR with
| None -> None
| Some es ->
match DH.dh (kem_dh_of_cs cs) skS pkR with
| None -> None
| Some ss ->
let esm = prepare_dh cs es in
let ssm = prepare_dh cs ss in
// TODO Do not put 32 literally
let dh = concat #uint8 #32 #32 esm ssm in
let enc = serialize_public_key cs pkE in
match DH.secret_to_public (kem_dh_of_cs cs) skS with
| None -> None
| Some pkS ->
let pkSm = serialize_public_key cs pkS in
let pkRm = serialize_public_key cs pkR in
let kem_context = concat enc (concat pkRm pkSm) in
assert (Seq.length kem_context = 3*size_dh_public cs);
assert (labeled_expand_info_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_shared_secret + Seq.length kem_context));
assert (extract_and_expand_ctx_pred cs (Seq.length kem_context));
// TODO Do not put 64 literally
assert (Seq.length dh = 64);
assert (labeled_extract_ikm_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_eae_prk + Seq.length dh));
assert (extract_and_expand_dh_pred cs (Seq.length dh));
let shared_secret = extract_and_expand cs dh kem_context in
Some (shared_secret, enc)
#reset-options
val auth_decap:
cs: ciphersuite
-> enc: key_dh_public_s cs
-> skR: key_dh_secret_s cs
-> pkS: DH.serialized_point (kem_dh_of_cs cs) ->
Tot (option (key_kem_s cs))
#restart-solver
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let auth_decap cs enc skR pkS =
let _ = allow_inversion Spec.Agile.DH.algorithm in
let pkE = deserialize_public_key cs enc in
match DH.dh (kem_dh_of_cs cs) skR pkE with
| None -> None
| Some es ->
match DH.dh (kem_dh_of_cs cs) skR pkS with
| None -> None
| Some ss ->
let esm = prepare_dh cs es in
let ssm = prepare_dh cs ss in
let dh = concat #uint8 #32 #32 esm ssm in
match DH.secret_to_public (kem_dh_of_cs cs) skR with
| None -> None
| Some pkR ->
let pkRm = serialize_public_key cs pkR in
let pkSm = serialize_public_key cs pkS in
let kem_context = concat enc (concat pkRm pkSm) in
assert (Seq.length kem_context = 3*size_dh_public cs);
assert (labeled_expand_info_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_shared_secret + Seq.length kem_context));
assert (extract_and_expand_ctx_pred cs (Seq.length kem_context));
assert (Seq.length dh = 64);
assert (labeled_extract_ikm_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_eae_prk + Seq.length dh));
assert (extract_and_expand_dh_pred cs (Seq.length dh));
let shared_secret = extract_and_expand cs dh kem_context in
Some (shared_secret)
#reset-options
| false | false |
Spec.Agile.HPKE.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val default_psk_id : Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.SEC) 0
|
[] |
Spec.Agile.HPKE.default_psk_id
|
{
"file_name": "specs/Spec.Agile.HPKE.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.SEC) 0
|
{
"end_col": 33,
"end_line": 307,
"start_col": 21,
"start_line": 307
}
|
|
Prims.Tot
|
[
{
"abbrev": true,
"full_module": "Spec.Agile.HKDF",
"short_module": "HKDF"
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"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": true,
"full_module": "Spec.Agile.HKDF",
"short_module": "HKDF"
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"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.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let set_seq (cs:ciphersuite) (ctx:encryption_context cs) (seq:seq_aead_s cs) =
let key, base_nonce, _, exp_sec = ctx in
(key, base_nonce, seq, exp_sec)
|
let set_seq (cs: ciphersuite) (ctx: encryption_context cs) (seq: seq_aead_s cs) =
| false | null | false |
let key, base_nonce, _, exp_sec = ctx in
(key, base_nonce, seq, exp_sec)
|
{
"checked_file": "Spec.Agile.HPKE.fst.checked",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Loops.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"Spec.Agile.HKDF.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"Spec.Agile.DH.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Spec.Agile.HPKE.fst"
}
|
[
"total"
] |
[
"Spec.Agile.HPKE.ciphersuite",
"Spec.Agile.HPKE.encryption_context",
"Spec.Agile.HPKE.seq_aead_s",
"Spec.Agile.HPKE.key_aead_s",
"Spec.Agile.HPKE.nonce_aead_s",
"Spec.Agile.HPKE.exporter_secret_s",
"FStar.Pervasives.Native.Mktuple4",
"FStar.Pervasives.Native.tuple4"
] |
[] |
module Spec.Agile.HPKE
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module DH = Spec.Agile.DH
module AEAD = Spec.Agile.AEAD
module Hash = Spec.Agile.Hash
module HKDF = Spec.Agile.HKDF
let pow2_61 : _:unit{pow2 61 == 2305843009213693952} = assert_norm(pow2 61 == 2305843009213693952)
let pow2_35_less_than_pow2_61 : _:unit{pow2 32 * pow2 3 <= pow2 61 - 1} = assert_norm(pow2 32 * pow2 3 <= pow2 61 - 1)
let pow2_35_less_than_pow2_125 : _:unit{pow2 32 * pow2 3 <= pow2 125 - 1} = assert_norm(pow2 32 * pow2 3 <= pow2 125 - 1)
#set-options "--z3rlimit 20 --fuel 0 --ifuel 1"
/// Types
val id_kem: cs:ciphersuite -> Tot (lbytes 2)
let id_kem cs = let kem_dh, kem_hash, _, _ = cs in
match kem_dh, kem_hash with
| DH.DH_P256, Hash.SHA2_256 -> create 1 (u8 0) @| create 1 (u8 16)
| DH.DH_Curve25519, Hash.SHA2_256 -> create 1 (u8 0) @| create 1 (u8 32)
val id_kdf: cs:ciphersuite -> Tot (lbytes 2)
let id_kdf cs = let _, _, _, h = cs in
match h with
| Hash.SHA2_256 -> create 1 (u8 0) @| create 1 (u8 1)
| Hash.SHA2_384 -> create 1 (u8 0) @| create 1 (u8 2)
| Hash.SHA2_512 -> create 1 (u8 0) @| create 1 (u8 3)
val id_aead: cs:ciphersuite -> Tot (lbytes 2)
let id_aead cs = let _, _, a, _ = cs in
match a with
| Seal AEAD.AES128_GCM -> create 1 (u8 0) @| create 1 (u8 1)
| Seal AEAD.AES256_GCM -> create 1 (u8 0) @| create 1 (u8 2)
| Seal AEAD.CHACHA20_POLY1305 -> create 1 (u8 0) @| create 1 (u8 3)
| ExportOnly -> create 1 (u8 255) @| create 1 (u8 255)
val suite_id_kem: cs:ciphersuite -> Tot (lbytes size_suite_id_kem)
let suite_id_kem cs =
Seq.append label_KEM (id_kem cs)
val suite_id_hpke: cs:ciphersuite -> Tot (lbytes size_suite_id_hpke)
let suite_id_hpke cs =
Seq.append label_HPKE (id_kem cs @| id_kdf cs @| id_aead cs)
val id_of_mode: m:mode -> Tot (lbytes size_mode_identifier)
let id_of_mode m =
match m with
| Base -> create 1 (u8 0)
| PSK -> create 1 (u8 1)
| Auth -> create 1 (u8 2)
| AuthPSK -> create 1 (u8 3)
val labeled_extract:
a:hash_algorithm
-> suite_id:bytes
-> salt:bytes
-> label:bytes
-> ikm:bytes ->
Pure (lbytes (Spec.Hash.Definitions.hash_length a))
(requires
Spec.Agile.HMAC.keysized a (Seq.length salt) /\
labeled_extract_ikm_length_pred a (Seq.length suite_id + Seq.length label + Seq.length ikm))
(ensures fun _ -> True)
let labeled_extract a suite_id salt label ikm =
let labeled_ikm1 = Seq.append label_version suite_id in
let labeled_ikm2 = Seq.append labeled_ikm1 label in
let labeled_ikm3 = Seq.append labeled_ikm2 ikm in
HKDF.extract a salt labeled_ikm3
val labeled_expand:
a:hash_algorithm
-> suite_id:bytes
-> prk:bytes
-> label:bytes
-> info:bytes
-> l:size_nat ->
Pure (lbytes l)
(requires
Spec.Hash.Definitions.hash_length a <= Seq.length prk /\
Spec.Agile.HMAC.keysized a (Seq.length prk) /\
labeled_expand_info_length_pred a (Seq.length suite_id + Seq.length label + Seq.length info) /\
HKDF.expand_output_length_pred a l)
(ensures fun _ -> True)
let labeled_expand a suite_id prk label info l =
let labeled_info1 = nat_to_bytes_be 2 l in
let labeled_info2 = Seq.append labeled_info1 label_version in
let labeled_info3 = Seq.append labeled_info2 suite_id in
let labeled_info4 = Seq.append labeled_info3 label in
let labeled_info5 = Seq.append labeled_info4 info in
HKDF.expand a prk labeled_info5 l
let extract_and_expand_dh_pred (cs:ciphersuite) (dh_length:nat) =
labeled_extract_ikm_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_eae_prk + dh_length)
let extract_and_expand_ctx_pred (cs:ciphersuite) (ctx_length:nat) =
labeled_expand_info_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_shared_secret + ctx_length)
val extract_and_expand:
cs:ciphersuite
-> dh:bytes
-> kem_context:bytes ->
Pure (key_kem_s cs)
(requires
extract_and_expand_dh_pred cs (Seq.length dh) /\
extract_and_expand_ctx_pred cs (Seq.length kem_context))
(ensures fun _ -> True)
let extract_and_expand cs dh kem_context =
let eae_prk = labeled_extract (kem_hash_of_cs cs) (suite_id_kem cs) lbytes_empty label_eae_prk dh in
labeled_expand (kem_hash_of_cs cs) (suite_id_kem cs) eae_prk label_shared_secret kem_context (size_kem_key cs)
let deserialize_public_key cs pk = match kem_dh_of_cs cs with
| DH.DH_Curve25519 -> pk
// Extract the point coordinates by removing the first representation byte
| DH.DH_P256 -> sub pk 1 64
let serialize_public_key cs pk = match kem_dh_of_cs cs with
| DH.DH_Curve25519 -> pk
// Add the first representation byte to the point coordinates
| DH.DH_P256 -> create 1 (u8 4) @| pk
val dkp_nist_p: cs:ciphersuite -> lbytes (size_kem_kdf cs) -> counter:uint8 -> Tot (option (key_dh_secret_s cs & key_dh_public_s cs)) (decreases 255 - v counter)
let rec dkp_nist_p cs dkp_prk counter =
let counterbyte = nat_to_intseq_be #U8 #SEC 1 (v counter) in
let bytes = labeled_expand (kem_hash_of_cs cs) (suite_id_kem cs) dkp_prk label_candidate counterbyte (size_dh_key cs) in
let bytes = Lib.Sequence.map2 (logand #U8 #SEC) bytes (Seq.create (size_dh_key cs) (u8 255)) in
let sk = nat_from_intseq_be #U8 #SEC bytes in
if sk = 0 || sk >= Spec.P256.prime then
if (v counter) = 255 then None
else dkp_nist_p cs dkp_prk (counter +! (u8 1))
else
match DH.secret_to_public (kem_dh_of_cs cs) bytes with
| Some pk -> Some (bytes, serialize_public_key cs pk)
| None ->
if (v counter) = 255 then None
else dkp_nist_p cs dkp_prk (counter +! (u8 1))
let derive_key_pair cs ikm =
match kem_dh_of_cs cs with
| DH.DH_Curve25519 -> begin
let dkp_prk = labeled_extract (kem_hash_of_cs cs) (suite_id_kem cs) lbytes_empty label_dkp_prk ikm in
let sk = labeled_expand (kem_hash_of_cs cs) (suite_id_kem cs) dkp_prk label_sk lbytes_empty (size_dh_key cs) in
match DH.secret_to_public (kem_dh_of_cs cs) sk with
| Some pk -> Some (sk, serialize_public_key cs pk)
end
| DH.DH_P256 ->
let dkp_prk = labeled_extract (kem_hash_of_cs cs) (suite_id_kem cs) lbytes_empty label_dkp_prk ikm in
dkp_nist_p cs dkp_prk (u8 0)
val prepare_dh: cs:ciphersuite -> DH.serialized_point (kem_dh_of_cs cs) -> Tot (lbytes 32)
let prepare_dh cs dh = match (kem_dh_of_cs cs) with
| DH.DH_Curve25519 -> serialize_public_key cs dh
| DH.DH_P256 -> sub dh 0 32
val encap:
cs:ciphersuite
-> skE:key_dh_secret_s cs
-> pkR:DH.serialized_point (kem_dh_of_cs cs) ->
Tot (option (key_kem_s cs & key_dh_public_s cs))
#restart-solver
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let encap cs skE pkR =
let _ = allow_inversion Spec.Agile.DH.algorithm in
match DH.secret_to_public (kem_dh_of_cs cs) skE with
| None -> None
| Some pkE ->
let enc = serialize_public_key cs pkE in
match DH.dh (kem_dh_of_cs cs) skE pkR with
| None -> None
| Some dh ->
let pkRm = serialize_public_key cs pkR in
let kem_context = concat enc pkRm in
let dhm = prepare_dh cs dh in
assert (Seq.length kem_context = 2*size_dh_public cs);
assert (extract_and_expand_ctx_pred cs (Seq.length kem_context));
let shared_secret:key_kem_s cs = extract_and_expand cs dhm kem_context in
Some (shared_secret, enc)
val decap:
cs: ciphersuite
-> enc: key_dh_public_s cs
-> skR: key_dh_secret_s cs ->
Tot (option (key_kem_s cs))
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let decap cs enc skR =
let _ = allow_inversion Spec.Agile.DH.algorithm in
let _ = allow_inversion Spec.Agile.Hash.hash_alg in
let pkE = deserialize_public_key cs enc in
match DH.dh (kem_dh_of_cs cs) skR pkE with
| None -> None
| Some dh ->
match DH.secret_to_public (kem_dh_of_cs cs) skR with
| None -> None
| Some pkR ->
let pkRm = serialize_public_key cs pkR in
let kem_context = concat enc pkRm in
let dhm = prepare_dh cs dh in
assert (Seq.length kem_context = 2*size_dh_public cs);
assert (extract_and_expand_ctx_pred cs (Seq.length kem_context));
let shared_secret = extract_and_expand cs dhm kem_context in
Some (shared_secret)
val auth_encap:
cs:ciphersuite
-> skE:key_dh_secret_s cs
-> pkR:DH.serialized_point (kem_dh_of_cs cs)
-> skS:key_dh_secret_s cs ->
Tot (option (key_kem_s cs & key_dh_public_s cs))
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let auth_encap cs skE pkR skS =
let _ = allow_inversion Spec.Agile.DH.algorithm in
match DH.secret_to_public (kem_dh_of_cs cs) skE with
| None -> None
| Some pkE ->
match DH.dh (kem_dh_of_cs cs) skE pkR with
| None -> None
| Some es ->
match DH.dh (kem_dh_of_cs cs) skS pkR with
| None -> None
| Some ss ->
let esm = prepare_dh cs es in
let ssm = prepare_dh cs ss in
// TODO Do not put 32 literally
let dh = concat #uint8 #32 #32 esm ssm in
let enc = serialize_public_key cs pkE in
match DH.secret_to_public (kem_dh_of_cs cs) skS with
| None -> None
| Some pkS ->
let pkSm = serialize_public_key cs pkS in
let pkRm = serialize_public_key cs pkR in
let kem_context = concat enc (concat pkRm pkSm) in
assert (Seq.length kem_context = 3*size_dh_public cs);
assert (labeled_expand_info_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_shared_secret + Seq.length kem_context));
assert (extract_and_expand_ctx_pred cs (Seq.length kem_context));
// TODO Do not put 64 literally
assert (Seq.length dh = 64);
assert (labeled_extract_ikm_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_eae_prk + Seq.length dh));
assert (extract_and_expand_dh_pred cs (Seq.length dh));
let shared_secret = extract_and_expand cs dh kem_context in
Some (shared_secret, enc)
#reset-options
val auth_decap:
cs: ciphersuite
-> enc: key_dh_public_s cs
-> skR: key_dh_secret_s cs
-> pkS: DH.serialized_point (kem_dh_of_cs cs) ->
Tot (option (key_kem_s cs))
#restart-solver
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let auth_decap cs enc skR pkS =
let _ = allow_inversion Spec.Agile.DH.algorithm in
let pkE = deserialize_public_key cs enc in
match DH.dh (kem_dh_of_cs cs) skR pkE with
| None -> None
| Some es ->
match DH.dh (kem_dh_of_cs cs) skR pkS with
| None -> None
| Some ss ->
let esm = prepare_dh cs es in
let ssm = prepare_dh cs ss in
let dh = concat #uint8 #32 #32 esm ssm in
match DH.secret_to_public (kem_dh_of_cs cs) skR with
| None -> None
| Some pkR ->
let pkRm = serialize_public_key cs pkR in
let pkSm = serialize_public_key cs pkS in
let kem_context = concat enc (concat pkRm pkSm) in
assert (Seq.length kem_context = 3*size_dh_public cs);
assert (labeled_expand_info_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_shared_secret + Seq.length kem_context));
assert (extract_and_expand_ctx_pred cs (Seq.length kem_context));
assert (Seq.length dh = 64);
assert (labeled_extract_ikm_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_eae_prk + Seq.length dh));
assert (extract_and_expand_dh_pred cs (Seq.length dh));
let shared_secret = extract_and_expand cs dh kem_context in
Some (shared_secret)
#reset-options
let default_psk = lbytes_empty
let default_psk_id = lbytes_empty
val build_context:
cs:ciphersuite
-> m:mode
-> psk_id_hash:lbytes (size_kdf cs)
-> info_hash:lbytes (size_kdf cs) ->
Tot (lbytes (size_ks_ctx cs))
let build_context cs m psk_id_hash info_hash =
let context = id_of_mode m in
let context = Seq.append context psk_id_hash in
let context = Seq.append context info_hash in
context
let verify_psk_inputs (cs:ciphersuite) (m:mode) (opsk:option(psk_s cs & psk_id_s cs)) : bool =
match (m, opsk) with
| Base, None -> true
| PSK, Some _ -> true
| Auth, None -> true
| AuthPSK, Some _ -> true
| _, _ -> false
// key and nonce are zero-length if AEAD is Export-Only
let encryption_context (cs:ciphersuite) = key_aead_s cs & nonce_aead_s cs & seq_aead_s cs & exporter_secret_s cs
val key_schedule:
cs:ciphersuite
-> m:mode
-> shared_secret:key_kem_s cs
-> info:info_s cs
-> opsk:option (psk_s cs & psk_id_s cs) ->
Pure (encryption_context cs)
(requires verify_psk_inputs cs m opsk)
(ensures fun _ -> True)
#set-options "--z3rlimit 500 --fuel 0 --ifuel 2"
let key_schedule_core
(cs:ciphersuite)
(m:mode)
(shared_secret:key_kem_s cs)
(info:info_s cs)
(opsk:option (psk_s cs & psk_id_s cs))
: (lbytes (size_ks_ctx cs) & exporter_secret_s cs & (lbytes (Spec.Hash.Definitions.hash_length (hash_of_cs cs)))) =
let (psk, psk_id) =
match opsk with
| None -> (default_psk, default_psk_id)
| Some (psk, psk_id) -> (psk, psk_id)
in
let psk_id_hash = labeled_extract (hash_of_cs cs) (suite_id_hpke cs) lbytes_empty label_psk_id_hash psk_id in
let info_hash = labeled_extract (hash_of_cs cs) (suite_id_hpke cs) lbytes_empty label_info_hash info in
let context = build_context cs m psk_id_hash info_hash in
let secret = labeled_extract (hash_of_cs cs) (suite_id_hpke cs) shared_secret label_secret psk in
let exporter_secret = labeled_expand (hash_of_cs cs) (suite_id_hpke cs) secret label_exp context (size_kdf cs) in
context, exporter_secret, secret
let key_schedule_end
(cs:ciphersuite)
(m:mode)
(context:lbytes (size_ks_ctx cs))
(exporter_secret:exporter_secret_s cs)
(secret:(lbytes (Spec.Hash.Definitions.hash_length (hash_of_cs cs))))
: encryption_context cs
=
if is_valid_not_export_only_ciphersuite cs then (
let key = labeled_expand (hash_of_cs cs) (suite_id_hpke cs) secret label_key context (size_aead_key cs) in
let base_nonce = labeled_expand (hash_of_cs cs) (suite_id_hpke cs) secret label_base_nonce context (size_aead_nonce cs) in
(key, base_nonce, 0, exporter_secret)
) else (
(* if AEAD is Export-Only, then skip computation of key and base_nonce *)
assert (size_aead_key cs = 0);
assert (size_aead_nonce cs = 0);
(lbytes_empty, lbytes_empty, 0, exporter_secret))
let key_schedule cs m shared_secret info opsk =
let context, exporter_secret, secret = key_schedule_core cs m shared_secret info opsk in
key_schedule_end cs m context exporter_secret secret
let key_of_ctx (cs:ciphersuite) (ctx:encryption_context cs) =
let key, _, _, _ = ctx in key
let base_nonce_of_ctx (cs:ciphersuite) (ctx:encryption_context cs) =
let _, base_nonce, _, _ = ctx in base_nonce
let seq_of_ctx (cs:ciphersuite) (ctx:encryption_context cs) =
let _, _, seq, _ = ctx in seq
let exp_sec_of_ctx (cs:ciphersuite) (ctx:encryption_context cs) =
let _, _, _, exp_sec = ctx in exp_sec
| false | false |
Spec.Agile.HPKE.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 2,
"max_fuel": 0,
"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": 500,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val set_seq : cs: Spec.Agile.HPKE.ciphersuite ->
ctx: Spec.Agile.HPKE.encryption_context cs ->
seq: Spec.Agile.HPKE.seq_aead_s cs
-> ((Spec.Agile.HPKE.key_aead_s cs * Spec.Agile.HPKE.nonce_aead_s cs) *
Spec.Agile.HPKE.seq_aead_s cs) *
Spec.Agile.HPKE.exporter_secret_s cs
|
[] |
Spec.Agile.HPKE.set_seq
|
{
"file_name": "specs/Spec.Agile.HPKE.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
cs: Spec.Agile.HPKE.ciphersuite ->
ctx: Spec.Agile.HPKE.encryption_context cs ->
seq: Spec.Agile.HPKE.seq_aead_s cs
-> ((Spec.Agile.HPKE.key_aead_s cs * Spec.Agile.HPKE.nonce_aead_s cs) *
Spec.Agile.HPKE.seq_aead_s cs) *
Spec.Agile.HPKE.exporter_secret_s cs
|
{
"end_col": 33,
"end_line": 401,
"start_col": 78,
"start_line": 399
}
|
|
Prims.Tot
|
[
{
"abbrev": true,
"full_module": "Spec.Agile.HKDF",
"short_module": "HKDF"
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"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": true,
"full_module": "Spec.Agile.HKDF",
"short_module": "HKDF"
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"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.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let seq_of_ctx (cs:ciphersuite) (ctx:encryption_context cs) =
let _, _, seq, _ = ctx in seq
|
let seq_of_ctx (cs: ciphersuite) (ctx: encryption_context cs) =
| false | null | false |
let _, _, seq, _ = ctx in
seq
|
{
"checked_file": "Spec.Agile.HPKE.fst.checked",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Loops.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"Spec.Agile.HKDF.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"Spec.Agile.DH.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Spec.Agile.HPKE.fst"
}
|
[
"total"
] |
[
"Spec.Agile.HPKE.ciphersuite",
"Spec.Agile.HPKE.encryption_context",
"Spec.Agile.HPKE.key_aead_s",
"Spec.Agile.HPKE.nonce_aead_s",
"Spec.Agile.HPKE.seq_aead_s",
"Spec.Agile.HPKE.exporter_secret_s"
] |
[] |
module Spec.Agile.HPKE
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module DH = Spec.Agile.DH
module AEAD = Spec.Agile.AEAD
module Hash = Spec.Agile.Hash
module HKDF = Spec.Agile.HKDF
let pow2_61 : _:unit{pow2 61 == 2305843009213693952} = assert_norm(pow2 61 == 2305843009213693952)
let pow2_35_less_than_pow2_61 : _:unit{pow2 32 * pow2 3 <= pow2 61 - 1} = assert_norm(pow2 32 * pow2 3 <= pow2 61 - 1)
let pow2_35_less_than_pow2_125 : _:unit{pow2 32 * pow2 3 <= pow2 125 - 1} = assert_norm(pow2 32 * pow2 3 <= pow2 125 - 1)
#set-options "--z3rlimit 20 --fuel 0 --ifuel 1"
/// Types
val id_kem: cs:ciphersuite -> Tot (lbytes 2)
let id_kem cs = let kem_dh, kem_hash, _, _ = cs in
match kem_dh, kem_hash with
| DH.DH_P256, Hash.SHA2_256 -> create 1 (u8 0) @| create 1 (u8 16)
| DH.DH_Curve25519, Hash.SHA2_256 -> create 1 (u8 0) @| create 1 (u8 32)
val id_kdf: cs:ciphersuite -> Tot (lbytes 2)
let id_kdf cs = let _, _, _, h = cs in
match h with
| Hash.SHA2_256 -> create 1 (u8 0) @| create 1 (u8 1)
| Hash.SHA2_384 -> create 1 (u8 0) @| create 1 (u8 2)
| Hash.SHA2_512 -> create 1 (u8 0) @| create 1 (u8 3)
val id_aead: cs:ciphersuite -> Tot (lbytes 2)
let id_aead cs = let _, _, a, _ = cs in
match a with
| Seal AEAD.AES128_GCM -> create 1 (u8 0) @| create 1 (u8 1)
| Seal AEAD.AES256_GCM -> create 1 (u8 0) @| create 1 (u8 2)
| Seal AEAD.CHACHA20_POLY1305 -> create 1 (u8 0) @| create 1 (u8 3)
| ExportOnly -> create 1 (u8 255) @| create 1 (u8 255)
val suite_id_kem: cs:ciphersuite -> Tot (lbytes size_suite_id_kem)
let suite_id_kem cs =
Seq.append label_KEM (id_kem cs)
val suite_id_hpke: cs:ciphersuite -> Tot (lbytes size_suite_id_hpke)
let suite_id_hpke cs =
Seq.append label_HPKE (id_kem cs @| id_kdf cs @| id_aead cs)
val id_of_mode: m:mode -> Tot (lbytes size_mode_identifier)
let id_of_mode m =
match m with
| Base -> create 1 (u8 0)
| PSK -> create 1 (u8 1)
| Auth -> create 1 (u8 2)
| AuthPSK -> create 1 (u8 3)
val labeled_extract:
a:hash_algorithm
-> suite_id:bytes
-> salt:bytes
-> label:bytes
-> ikm:bytes ->
Pure (lbytes (Spec.Hash.Definitions.hash_length a))
(requires
Spec.Agile.HMAC.keysized a (Seq.length salt) /\
labeled_extract_ikm_length_pred a (Seq.length suite_id + Seq.length label + Seq.length ikm))
(ensures fun _ -> True)
let labeled_extract a suite_id salt label ikm =
let labeled_ikm1 = Seq.append label_version suite_id in
let labeled_ikm2 = Seq.append labeled_ikm1 label in
let labeled_ikm3 = Seq.append labeled_ikm2 ikm in
HKDF.extract a salt labeled_ikm3
val labeled_expand:
a:hash_algorithm
-> suite_id:bytes
-> prk:bytes
-> label:bytes
-> info:bytes
-> l:size_nat ->
Pure (lbytes l)
(requires
Spec.Hash.Definitions.hash_length a <= Seq.length prk /\
Spec.Agile.HMAC.keysized a (Seq.length prk) /\
labeled_expand_info_length_pred a (Seq.length suite_id + Seq.length label + Seq.length info) /\
HKDF.expand_output_length_pred a l)
(ensures fun _ -> True)
let labeled_expand a suite_id prk label info l =
let labeled_info1 = nat_to_bytes_be 2 l in
let labeled_info2 = Seq.append labeled_info1 label_version in
let labeled_info3 = Seq.append labeled_info2 suite_id in
let labeled_info4 = Seq.append labeled_info3 label in
let labeled_info5 = Seq.append labeled_info4 info in
HKDF.expand a prk labeled_info5 l
let extract_and_expand_dh_pred (cs:ciphersuite) (dh_length:nat) =
labeled_extract_ikm_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_eae_prk + dh_length)
let extract_and_expand_ctx_pred (cs:ciphersuite) (ctx_length:nat) =
labeled_expand_info_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_shared_secret + ctx_length)
val extract_and_expand:
cs:ciphersuite
-> dh:bytes
-> kem_context:bytes ->
Pure (key_kem_s cs)
(requires
extract_and_expand_dh_pred cs (Seq.length dh) /\
extract_and_expand_ctx_pred cs (Seq.length kem_context))
(ensures fun _ -> True)
let extract_and_expand cs dh kem_context =
let eae_prk = labeled_extract (kem_hash_of_cs cs) (suite_id_kem cs) lbytes_empty label_eae_prk dh in
labeled_expand (kem_hash_of_cs cs) (suite_id_kem cs) eae_prk label_shared_secret kem_context (size_kem_key cs)
let deserialize_public_key cs pk = match kem_dh_of_cs cs with
| DH.DH_Curve25519 -> pk
// Extract the point coordinates by removing the first representation byte
| DH.DH_P256 -> sub pk 1 64
let serialize_public_key cs pk = match kem_dh_of_cs cs with
| DH.DH_Curve25519 -> pk
// Add the first representation byte to the point coordinates
| DH.DH_P256 -> create 1 (u8 4) @| pk
val dkp_nist_p: cs:ciphersuite -> lbytes (size_kem_kdf cs) -> counter:uint8 -> Tot (option (key_dh_secret_s cs & key_dh_public_s cs)) (decreases 255 - v counter)
let rec dkp_nist_p cs dkp_prk counter =
let counterbyte = nat_to_intseq_be #U8 #SEC 1 (v counter) in
let bytes = labeled_expand (kem_hash_of_cs cs) (suite_id_kem cs) dkp_prk label_candidate counterbyte (size_dh_key cs) in
let bytes = Lib.Sequence.map2 (logand #U8 #SEC) bytes (Seq.create (size_dh_key cs) (u8 255)) in
let sk = nat_from_intseq_be #U8 #SEC bytes in
if sk = 0 || sk >= Spec.P256.prime then
if (v counter) = 255 then None
else dkp_nist_p cs dkp_prk (counter +! (u8 1))
else
match DH.secret_to_public (kem_dh_of_cs cs) bytes with
| Some pk -> Some (bytes, serialize_public_key cs pk)
| None ->
if (v counter) = 255 then None
else dkp_nist_p cs dkp_prk (counter +! (u8 1))
let derive_key_pair cs ikm =
match kem_dh_of_cs cs with
| DH.DH_Curve25519 -> begin
let dkp_prk = labeled_extract (kem_hash_of_cs cs) (suite_id_kem cs) lbytes_empty label_dkp_prk ikm in
let sk = labeled_expand (kem_hash_of_cs cs) (suite_id_kem cs) dkp_prk label_sk lbytes_empty (size_dh_key cs) in
match DH.secret_to_public (kem_dh_of_cs cs) sk with
| Some pk -> Some (sk, serialize_public_key cs pk)
end
| DH.DH_P256 ->
let dkp_prk = labeled_extract (kem_hash_of_cs cs) (suite_id_kem cs) lbytes_empty label_dkp_prk ikm in
dkp_nist_p cs dkp_prk (u8 0)
val prepare_dh: cs:ciphersuite -> DH.serialized_point (kem_dh_of_cs cs) -> Tot (lbytes 32)
let prepare_dh cs dh = match (kem_dh_of_cs cs) with
| DH.DH_Curve25519 -> serialize_public_key cs dh
| DH.DH_P256 -> sub dh 0 32
val encap:
cs:ciphersuite
-> skE:key_dh_secret_s cs
-> pkR:DH.serialized_point (kem_dh_of_cs cs) ->
Tot (option (key_kem_s cs & key_dh_public_s cs))
#restart-solver
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let encap cs skE pkR =
let _ = allow_inversion Spec.Agile.DH.algorithm in
match DH.secret_to_public (kem_dh_of_cs cs) skE with
| None -> None
| Some pkE ->
let enc = serialize_public_key cs pkE in
match DH.dh (kem_dh_of_cs cs) skE pkR with
| None -> None
| Some dh ->
let pkRm = serialize_public_key cs pkR in
let kem_context = concat enc pkRm in
let dhm = prepare_dh cs dh in
assert (Seq.length kem_context = 2*size_dh_public cs);
assert (extract_and_expand_ctx_pred cs (Seq.length kem_context));
let shared_secret:key_kem_s cs = extract_and_expand cs dhm kem_context in
Some (shared_secret, enc)
val decap:
cs: ciphersuite
-> enc: key_dh_public_s cs
-> skR: key_dh_secret_s cs ->
Tot (option (key_kem_s cs))
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let decap cs enc skR =
let _ = allow_inversion Spec.Agile.DH.algorithm in
let _ = allow_inversion Spec.Agile.Hash.hash_alg in
let pkE = deserialize_public_key cs enc in
match DH.dh (kem_dh_of_cs cs) skR pkE with
| None -> None
| Some dh ->
match DH.secret_to_public (kem_dh_of_cs cs) skR with
| None -> None
| Some pkR ->
let pkRm = serialize_public_key cs pkR in
let kem_context = concat enc pkRm in
let dhm = prepare_dh cs dh in
assert (Seq.length kem_context = 2*size_dh_public cs);
assert (extract_and_expand_ctx_pred cs (Seq.length kem_context));
let shared_secret = extract_and_expand cs dhm kem_context in
Some (shared_secret)
val auth_encap:
cs:ciphersuite
-> skE:key_dh_secret_s cs
-> pkR:DH.serialized_point (kem_dh_of_cs cs)
-> skS:key_dh_secret_s cs ->
Tot (option (key_kem_s cs & key_dh_public_s cs))
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let auth_encap cs skE pkR skS =
let _ = allow_inversion Spec.Agile.DH.algorithm in
match DH.secret_to_public (kem_dh_of_cs cs) skE with
| None -> None
| Some pkE ->
match DH.dh (kem_dh_of_cs cs) skE pkR with
| None -> None
| Some es ->
match DH.dh (kem_dh_of_cs cs) skS pkR with
| None -> None
| Some ss ->
let esm = prepare_dh cs es in
let ssm = prepare_dh cs ss in
// TODO Do not put 32 literally
let dh = concat #uint8 #32 #32 esm ssm in
let enc = serialize_public_key cs pkE in
match DH.secret_to_public (kem_dh_of_cs cs) skS with
| None -> None
| Some pkS ->
let pkSm = serialize_public_key cs pkS in
let pkRm = serialize_public_key cs pkR in
let kem_context = concat enc (concat pkRm pkSm) in
assert (Seq.length kem_context = 3*size_dh_public cs);
assert (labeled_expand_info_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_shared_secret + Seq.length kem_context));
assert (extract_and_expand_ctx_pred cs (Seq.length kem_context));
// TODO Do not put 64 literally
assert (Seq.length dh = 64);
assert (labeled_extract_ikm_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_eae_prk + Seq.length dh));
assert (extract_and_expand_dh_pred cs (Seq.length dh));
let shared_secret = extract_and_expand cs dh kem_context in
Some (shared_secret, enc)
#reset-options
val auth_decap:
cs: ciphersuite
-> enc: key_dh_public_s cs
-> skR: key_dh_secret_s cs
-> pkS: DH.serialized_point (kem_dh_of_cs cs) ->
Tot (option (key_kem_s cs))
#restart-solver
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let auth_decap cs enc skR pkS =
let _ = allow_inversion Spec.Agile.DH.algorithm in
let pkE = deserialize_public_key cs enc in
match DH.dh (kem_dh_of_cs cs) skR pkE with
| None -> None
| Some es ->
match DH.dh (kem_dh_of_cs cs) skR pkS with
| None -> None
| Some ss ->
let esm = prepare_dh cs es in
let ssm = prepare_dh cs ss in
let dh = concat #uint8 #32 #32 esm ssm in
match DH.secret_to_public (kem_dh_of_cs cs) skR with
| None -> None
| Some pkR ->
let pkRm = serialize_public_key cs pkR in
let pkSm = serialize_public_key cs pkS in
let kem_context = concat enc (concat pkRm pkSm) in
assert (Seq.length kem_context = 3*size_dh_public cs);
assert (labeled_expand_info_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_shared_secret + Seq.length kem_context));
assert (extract_and_expand_ctx_pred cs (Seq.length kem_context));
assert (Seq.length dh = 64);
assert (labeled_extract_ikm_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_eae_prk + Seq.length dh));
assert (extract_and_expand_dh_pred cs (Seq.length dh));
let shared_secret = extract_and_expand cs dh kem_context in
Some (shared_secret)
#reset-options
let default_psk = lbytes_empty
let default_psk_id = lbytes_empty
val build_context:
cs:ciphersuite
-> m:mode
-> psk_id_hash:lbytes (size_kdf cs)
-> info_hash:lbytes (size_kdf cs) ->
Tot (lbytes (size_ks_ctx cs))
let build_context cs m psk_id_hash info_hash =
let context = id_of_mode m in
let context = Seq.append context psk_id_hash in
let context = Seq.append context info_hash in
context
let verify_psk_inputs (cs:ciphersuite) (m:mode) (opsk:option(psk_s cs & psk_id_s cs)) : bool =
match (m, opsk) with
| Base, None -> true
| PSK, Some _ -> true
| Auth, None -> true
| AuthPSK, Some _ -> true
| _, _ -> false
// key and nonce are zero-length if AEAD is Export-Only
let encryption_context (cs:ciphersuite) = key_aead_s cs & nonce_aead_s cs & seq_aead_s cs & exporter_secret_s cs
val key_schedule:
cs:ciphersuite
-> m:mode
-> shared_secret:key_kem_s cs
-> info:info_s cs
-> opsk:option (psk_s cs & psk_id_s cs) ->
Pure (encryption_context cs)
(requires verify_psk_inputs cs m opsk)
(ensures fun _ -> True)
#set-options "--z3rlimit 500 --fuel 0 --ifuel 2"
let key_schedule_core
(cs:ciphersuite)
(m:mode)
(shared_secret:key_kem_s cs)
(info:info_s cs)
(opsk:option (psk_s cs & psk_id_s cs))
: (lbytes (size_ks_ctx cs) & exporter_secret_s cs & (lbytes (Spec.Hash.Definitions.hash_length (hash_of_cs cs)))) =
let (psk, psk_id) =
match opsk with
| None -> (default_psk, default_psk_id)
| Some (psk, psk_id) -> (psk, psk_id)
in
let psk_id_hash = labeled_extract (hash_of_cs cs) (suite_id_hpke cs) lbytes_empty label_psk_id_hash psk_id in
let info_hash = labeled_extract (hash_of_cs cs) (suite_id_hpke cs) lbytes_empty label_info_hash info in
let context = build_context cs m psk_id_hash info_hash in
let secret = labeled_extract (hash_of_cs cs) (suite_id_hpke cs) shared_secret label_secret psk in
let exporter_secret = labeled_expand (hash_of_cs cs) (suite_id_hpke cs) secret label_exp context (size_kdf cs) in
context, exporter_secret, secret
let key_schedule_end
(cs:ciphersuite)
(m:mode)
(context:lbytes (size_ks_ctx cs))
(exporter_secret:exporter_secret_s cs)
(secret:(lbytes (Spec.Hash.Definitions.hash_length (hash_of_cs cs))))
: encryption_context cs
=
if is_valid_not_export_only_ciphersuite cs then (
let key = labeled_expand (hash_of_cs cs) (suite_id_hpke cs) secret label_key context (size_aead_key cs) in
let base_nonce = labeled_expand (hash_of_cs cs) (suite_id_hpke cs) secret label_base_nonce context (size_aead_nonce cs) in
(key, base_nonce, 0, exporter_secret)
) else (
(* if AEAD is Export-Only, then skip computation of key and base_nonce *)
assert (size_aead_key cs = 0);
assert (size_aead_nonce cs = 0);
(lbytes_empty, lbytes_empty, 0, exporter_secret))
let key_schedule cs m shared_secret info opsk =
let context, exporter_secret, secret = key_schedule_core cs m shared_secret info opsk in
key_schedule_end cs m context exporter_secret secret
let key_of_ctx (cs:ciphersuite) (ctx:encryption_context cs) =
let key, _, _, _ = ctx in key
let base_nonce_of_ctx (cs:ciphersuite) (ctx:encryption_context cs) =
let _, base_nonce, _, _ = ctx in base_nonce
| false | false |
Spec.Agile.HPKE.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 2,
"max_fuel": 0,
"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": 500,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val seq_of_ctx : cs: Spec.Agile.HPKE.ciphersuite -> ctx: Spec.Agile.HPKE.encryption_context cs
-> Spec.Agile.HPKE.seq_aead_s cs
|
[] |
Spec.Agile.HPKE.seq_of_ctx
|
{
"file_name": "specs/Spec.Agile.HPKE.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
cs: Spec.Agile.HPKE.ciphersuite -> ctx: Spec.Agile.HPKE.encryption_context cs
-> Spec.Agile.HPKE.seq_aead_s cs
|
{
"end_col": 31,
"end_line": 394,
"start_col": 61,
"start_line": 393
}
|
|
Prims.Tot
|
val pow2_35_less_than_pow2_125:_: unit{pow2 32 * pow2 3 <= pow2 125 - 1}
|
[
{
"abbrev": true,
"full_module": "Spec.Agile.HKDF",
"short_module": "HKDF"
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"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": true,
"full_module": "Spec.Agile.HKDF",
"short_module": "HKDF"
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"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.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let pow2_35_less_than_pow2_125 : _:unit{pow2 32 * pow2 3 <= pow2 125 - 1} = assert_norm(pow2 32 * pow2 3 <= pow2 125 - 1)
|
val pow2_35_less_than_pow2_125:_: unit{pow2 32 * pow2 3 <= pow2 125 - 1}
let pow2_35_less_than_pow2_125:_: unit{pow2 32 * pow2 3 <= pow2 125 - 1} =
| false | null | false |
assert_norm (pow2 32 * pow2 3 <= pow2 125 - 1)
|
{
"checked_file": "Spec.Agile.HPKE.fst.checked",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Loops.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"Spec.Agile.HKDF.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"Spec.Agile.DH.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Spec.Agile.HPKE.fst"
}
|
[
"total"
] |
[
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.op_Subtraction"
] |
[] |
module Spec.Agile.HPKE
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module DH = Spec.Agile.DH
module AEAD = Spec.Agile.AEAD
module Hash = Spec.Agile.Hash
module HKDF = Spec.Agile.HKDF
let pow2_61 : _:unit{pow2 61 == 2305843009213693952} = assert_norm(pow2 61 == 2305843009213693952)
| false | false |
Spec.Agile.HPKE.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val pow2_35_less_than_pow2_125:_: unit{pow2 32 * pow2 3 <= pow2 125 - 1}
|
[] |
Spec.Agile.HPKE.pow2_35_less_than_pow2_125
|
{
"file_name": "specs/Spec.Agile.HPKE.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
_: Prims.unit{Prims.pow2 32 * Prims.pow2 3 <= Prims.pow2 125 - 1}
|
{
"end_col": 121,
"end_line": 17,
"start_col": 76,
"start_line": 17
}
|
Prims.Tot
|
val verify_psk_inputs (cs: ciphersuite) (m: mode) (opsk: option (psk_s cs & psk_id_s cs)) : bool
|
[
{
"abbrev": true,
"full_module": "Spec.Agile.HKDF",
"short_module": "HKDF"
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"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": true,
"full_module": "Spec.Agile.HKDF",
"short_module": "HKDF"
},
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"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.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false |
let verify_psk_inputs (cs:ciphersuite) (m:mode) (opsk:option(psk_s cs & psk_id_s cs)) : bool =
match (m, opsk) with
| Base, None -> true
| PSK, Some _ -> true
| Auth, None -> true
| AuthPSK, Some _ -> true
| _, _ -> false
|
val verify_psk_inputs (cs: ciphersuite) (m: mode) (opsk: option (psk_s cs & psk_id_s cs)) : bool
let verify_psk_inputs (cs: ciphersuite) (m: mode) (opsk: option (psk_s cs & psk_id_s cs)) : bool =
| false | null | false |
match (m, opsk) with
| Base, None -> true
| PSK, Some _ -> true
| Auth, None -> true
| AuthPSK, Some _ -> true
| _, _ -> false
|
{
"checked_file": "Spec.Agile.HPKE.fst.checked",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Loops.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"Spec.Agile.HKDF.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"Spec.Agile.DH.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Spec.Agile.HPKE.fst"
}
|
[
"total"
] |
[
"Spec.Agile.HPKE.ciphersuite",
"Spec.Agile.HPKE.mode",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"Spec.Agile.HPKE.psk_s",
"Spec.Agile.HPKE.psk_id_s",
"FStar.Pervasives.Native.Mktuple2",
"Prims.bool"
] |
[] |
module Spec.Agile.HPKE
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module DH = Spec.Agile.DH
module AEAD = Spec.Agile.AEAD
module Hash = Spec.Agile.Hash
module HKDF = Spec.Agile.HKDF
let pow2_61 : _:unit{pow2 61 == 2305843009213693952} = assert_norm(pow2 61 == 2305843009213693952)
let pow2_35_less_than_pow2_61 : _:unit{pow2 32 * pow2 3 <= pow2 61 - 1} = assert_norm(pow2 32 * pow2 3 <= pow2 61 - 1)
let pow2_35_less_than_pow2_125 : _:unit{pow2 32 * pow2 3 <= pow2 125 - 1} = assert_norm(pow2 32 * pow2 3 <= pow2 125 - 1)
#set-options "--z3rlimit 20 --fuel 0 --ifuel 1"
/// Types
val id_kem: cs:ciphersuite -> Tot (lbytes 2)
let id_kem cs = let kem_dh, kem_hash, _, _ = cs in
match kem_dh, kem_hash with
| DH.DH_P256, Hash.SHA2_256 -> create 1 (u8 0) @| create 1 (u8 16)
| DH.DH_Curve25519, Hash.SHA2_256 -> create 1 (u8 0) @| create 1 (u8 32)
val id_kdf: cs:ciphersuite -> Tot (lbytes 2)
let id_kdf cs = let _, _, _, h = cs in
match h with
| Hash.SHA2_256 -> create 1 (u8 0) @| create 1 (u8 1)
| Hash.SHA2_384 -> create 1 (u8 0) @| create 1 (u8 2)
| Hash.SHA2_512 -> create 1 (u8 0) @| create 1 (u8 3)
val id_aead: cs:ciphersuite -> Tot (lbytes 2)
let id_aead cs = let _, _, a, _ = cs in
match a with
| Seal AEAD.AES128_GCM -> create 1 (u8 0) @| create 1 (u8 1)
| Seal AEAD.AES256_GCM -> create 1 (u8 0) @| create 1 (u8 2)
| Seal AEAD.CHACHA20_POLY1305 -> create 1 (u8 0) @| create 1 (u8 3)
| ExportOnly -> create 1 (u8 255) @| create 1 (u8 255)
val suite_id_kem: cs:ciphersuite -> Tot (lbytes size_suite_id_kem)
let suite_id_kem cs =
Seq.append label_KEM (id_kem cs)
val suite_id_hpke: cs:ciphersuite -> Tot (lbytes size_suite_id_hpke)
let suite_id_hpke cs =
Seq.append label_HPKE (id_kem cs @| id_kdf cs @| id_aead cs)
val id_of_mode: m:mode -> Tot (lbytes size_mode_identifier)
let id_of_mode m =
match m with
| Base -> create 1 (u8 0)
| PSK -> create 1 (u8 1)
| Auth -> create 1 (u8 2)
| AuthPSK -> create 1 (u8 3)
val labeled_extract:
a:hash_algorithm
-> suite_id:bytes
-> salt:bytes
-> label:bytes
-> ikm:bytes ->
Pure (lbytes (Spec.Hash.Definitions.hash_length a))
(requires
Spec.Agile.HMAC.keysized a (Seq.length salt) /\
labeled_extract_ikm_length_pred a (Seq.length suite_id + Seq.length label + Seq.length ikm))
(ensures fun _ -> True)
let labeled_extract a suite_id salt label ikm =
let labeled_ikm1 = Seq.append label_version suite_id in
let labeled_ikm2 = Seq.append labeled_ikm1 label in
let labeled_ikm3 = Seq.append labeled_ikm2 ikm in
HKDF.extract a salt labeled_ikm3
val labeled_expand:
a:hash_algorithm
-> suite_id:bytes
-> prk:bytes
-> label:bytes
-> info:bytes
-> l:size_nat ->
Pure (lbytes l)
(requires
Spec.Hash.Definitions.hash_length a <= Seq.length prk /\
Spec.Agile.HMAC.keysized a (Seq.length prk) /\
labeled_expand_info_length_pred a (Seq.length suite_id + Seq.length label + Seq.length info) /\
HKDF.expand_output_length_pred a l)
(ensures fun _ -> True)
let labeled_expand a suite_id prk label info l =
let labeled_info1 = nat_to_bytes_be 2 l in
let labeled_info2 = Seq.append labeled_info1 label_version in
let labeled_info3 = Seq.append labeled_info2 suite_id in
let labeled_info4 = Seq.append labeled_info3 label in
let labeled_info5 = Seq.append labeled_info4 info in
HKDF.expand a prk labeled_info5 l
let extract_and_expand_dh_pred (cs:ciphersuite) (dh_length:nat) =
labeled_extract_ikm_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_eae_prk + dh_length)
let extract_and_expand_ctx_pred (cs:ciphersuite) (ctx_length:nat) =
labeled_expand_info_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_shared_secret + ctx_length)
val extract_and_expand:
cs:ciphersuite
-> dh:bytes
-> kem_context:bytes ->
Pure (key_kem_s cs)
(requires
extract_and_expand_dh_pred cs (Seq.length dh) /\
extract_and_expand_ctx_pred cs (Seq.length kem_context))
(ensures fun _ -> True)
let extract_and_expand cs dh kem_context =
let eae_prk = labeled_extract (kem_hash_of_cs cs) (suite_id_kem cs) lbytes_empty label_eae_prk dh in
labeled_expand (kem_hash_of_cs cs) (suite_id_kem cs) eae_prk label_shared_secret kem_context (size_kem_key cs)
let deserialize_public_key cs pk = match kem_dh_of_cs cs with
| DH.DH_Curve25519 -> pk
// Extract the point coordinates by removing the first representation byte
| DH.DH_P256 -> sub pk 1 64
let serialize_public_key cs pk = match kem_dh_of_cs cs with
| DH.DH_Curve25519 -> pk
// Add the first representation byte to the point coordinates
| DH.DH_P256 -> create 1 (u8 4) @| pk
val dkp_nist_p: cs:ciphersuite -> lbytes (size_kem_kdf cs) -> counter:uint8 -> Tot (option (key_dh_secret_s cs & key_dh_public_s cs)) (decreases 255 - v counter)
let rec dkp_nist_p cs dkp_prk counter =
let counterbyte = nat_to_intseq_be #U8 #SEC 1 (v counter) in
let bytes = labeled_expand (kem_hash_of_cs cs) (suite_id_kem cs) dkp_prk label_candidate counterbyte (size_dh_key cs) in
let bytes = Lib.Sequence.map2 (logand #U8 #SEC) bytes (Seq.create (size_dh_key cs) (u8 255)) in
let sk = nat_from_intseq_be #U8 #SEC bytes in
if sk = 0 || sk >= Spec.P256.prime then
if (v counter) = 255 then None
else dkp_nist_p cs dkp_prk (counter +! (u8 1))
else
match DH.secret_to_public (kem_dh_of_cs cs) bytes with
| Some pk -> Some (bytes, serialize_public_key cs pk)
| None ->
if (v counter) = 255 then None
else dkp_nist_p cs dkp_prk (counter +! (u8 1))
let derive_key_pair cs ikm =
match kem_dh_of_cs cs with
| DH.DH_Curve25519 -> begin
let dkp_prk = labeled_extract (kem_hash_of_cs cs) (suite_id_kem cs) lbytes_empty label_dkp_prk ikm in
let sk = labeled_expand (kem_hash_of_cs cs) (suite_id_kem cs) dkp_prk label_sk lbytes_empty (size_dh_key cs) in
match DH.secret_to_public (kem_dh_of_cs cs) sk with
| Some pk -> Some (sk, serialize_public_key cs pk)
end
| DH.DH_P256 ->
let dkp_prk = labeled_extract (kem_hash_of_cs cs) (suite_id_kem cs) lbytes_empty label_dkp_prk ikm in
dkp_nist_p cs dkp_prk (u8 0)
val prepare_dh: cs:ciphersuite -> DH.serialized_point (kem_dh_of_cs cs) -> Tot (lbytes 32)
let prepare_dh cs dh = match (kem_dh_of_cs cs) with
| DH.DH_Curve25519 -> serialize_public_key cs dh
| DH.DH_P256 -> sub dh 0 32
val encap:
cs:ciphersuite
-> skE:key_dh_secret_s cs
-> pkR:DH.serialized_point (kem_dh_of_cs cs) ->
Tot (option (key_kem_s cs & key_dh_public_s cs))
#restart-solver
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let encap cs skE pkR =
let _ = allow_inversion Spec.Agile.DH.algorithm in
match DH.secret_to_public (kem_dh_of_cs cs) skE with
| None -> None
| Some pkE ->
let enc = serialize_public_key cs pkE in
match DH.dh (kem_dh_of_cs cs) skE pkR with
| None -> None
| Some dh ->
let pkRm = serialize_public_key cs pkR in
let kem_context = concat enc pkRm in
let dhm = prepare_dh cs dh in
assert (Seq.length kem_context = 2*size_dh_public cs);
assert (extract_and_expand_ctx_pred cs (Seq.length kem_context));
let shared_secret:key_kem_s cs = extract_and_expand cs dhm kem_context in
Some (shared_secret, enc)
val decap:
cs: ciphersuite
-> enc: key_dh_public_s cs
-> skR: key_dh_secret_s cs ->
Tot (option (key_kem_s cs))
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let decap cs enc skR =
let _ = allow_inversion Spec.Agile.DH.algorithm in
let _ = allow_inversion Spec.Agile.Hash.hash_alg in
let pkE = deserialize_public_key cs enc in
match DH.dh (kem_dh_of_cs cs) skR pkE with
| None -> None
| Some dh ->
match DH.secret_to_public (kem_dh_of_cs cs) skR with
| None -> None
| Some pkR ->
let pkRm = serialize_public_key cs pkR in
let kem_context = concat enc pkRm in
let dhm = prepare_dh cs dh in
assert (Seq.length kem_context = 2*size_dh_public cs);
assert (extract_and_expand_ctx_pred cs (Seq.length kem_context));
let shared_secret = extract_and_expand cs dhm kem_context in
Some (shared_secret)
val auth_encap:
cs:ciphersuite
-> skE:key_dh_secret_s cs
-> pkR:DH.serialized_point (kem_dh_of_cs cs)
-> skS:key_dh_secret_s cs ->
Tot (option (key_kem_s cs & key_dh_public_s cs))
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let auth_encap cs skE pkR skS =
let _ = allow_inversion Spec.Agile.DH.algorithm in
match DH.secret_to_public (kem_dh_of_cs cs) skE with
| None -> None
| Some pkE ->
match DH.dh (kem_dh_of_cs cs) skE pkR with
| None -> None
| Some es ->
match DH.dh (kem_dh_of_cs cs) skS pkR with
| None -> None
| Some ss ->
let esm = prepare_dh cs es in
let ssm = prepare_dh cs ss in
// TODO Do not put 32 literally
let dh = concat #uint8 #32 #32 esm ssm in
let enc = serialize_public_key cs pkE in
match DH.secret_to_public (kem_dh_of_cs cs) skS with
| None -> None
| Some pkS ->
let pkSm = serialize_public_key cs pkS in
let pkRm = serialize_public_key cs pkR in
let kem_context = concat enc (concat pkRm pkSm) in
assert (Seq.length kem_context = 3*size_dh_public cs);
assert (labeled_expand_info_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_shared_secret + Seq.length kem_context));
assert (extract_and_expand_ctx_pred cs (Seq.length kem_context));
// TODO Do not put 64 literally
assert (Seq.length dh = 64);
assert (labeled_extract_ikm_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_eae_prk + Seq.length dh));
assert (extract_and_expand_dh_pred cs (Seq.length dh));
let shared_secret = extract_and_expand cs dh kem_context in
Some (shared_secret, enc)
#reset-options
val auth_decap:
cs: ciphersuite
-> enc: key_dh_public_s cs
-> skR: key_dh_secret_s cs
-> pkS: DH.serialized_point (kem_dh_of_cs cs) ->
Tot (option (key_kem_s cs))
#restart-solver
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let auth_decap cs enc skR pkS =
let _ = allow_inversion Spec.Agile.DH.algorithm in
let pkE = deserialize_public_key cs enc in
match DH.dh (kem_dh_of_cs cs) skR pkE with
| None -> None
| Some es ->
match DH.dh (kem_dh_of_cs cs) skR pkS with
| None -> None
| Some ss ->
let esm = prepare_dh cs es in
let ssm = prepare_dh cs ss in
let dh = concat #uint8 #32 #32 esm ssm in
match DH.secret_to_public (kem_dh_of_cs cs) skR with
| None -> None
| Some pkR ->
let pkRm = serialize_public_key cs pkR in
let pkSm = serialize_public_key cs pkS in
let kem_context = concat enc (concat pkRm pkSm) in
assert (Seq.length kem_context = 3*size_dh_public cs);
assert (labeled_expand_info_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_shared_secret + Seq.length kem_context));
assert (extract_and_expand_ctx_pred cs (Seq.length kem_context));
assert (Seq.length dh = 64);
assert (labeled_extract_ikm_length_pred (kem_hash_of_cs cs) (size_suite_id_kem + size_label_eae_prk + Seq.length dh));
assert (extract_and_expand_dh_pred cs (Seq.length dh));
let shared_secret = extract_and_expand cs dh kem_context in
Some (shared_secret)
#reset-options
let default_psk = lbytes_empty
let default_psk_id = lbytes_empty
val build_context:
cs:ciphersuite
-> m:mode
-> psk_id_hash:lbytes (size_kdf cs)
-> info_hash:lbytes (size_kdf cs) ->
Tot (lbytes (size_ks_ctx cs))
let build_context cs m psk_id_hash info_hash =
let context = id_of_mode m in
let context = Seq.append context psk_id_hash in
let context = Seq.append context info_hash in
context
| false | false |
Spec.Agile.HPKE.fst
|
{
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
}
| null |
val verify_psk_inputs (cs: ciphersuite) (m: mode) (opsk: option (psk_s cs & psk_id_s cs)) : bool
|
[] |
Spec.Agile.HPKE.verify_psk_inputs
|
{
"file_name": "specs/Spec.Agile.HPKE.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
}
|
cs: Spec.Agile.HPKE.ciphersuite ->
m: Spec.Agile.HPKE.mode ->
opsk: FStar.Pervasives.Native.option (Spec.Agile.HPKE.psk_s cs * Spec.Agile.HPKE.psk_id_s cs)
-> Prims.bool
|
{
"end_col": 17,
"end_line": 328,
"start_col": 2,
"start_line": 323
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.