effect
stringclasses 48
values | original_source_type
stringlengths 0
23k
| opens_and_abbrevs
listlengths 2
92
| isa_cross_project_example
bool 1
class | source_definition
stringlengths 9
57.9k
| partial_definition
stringlengths 7
23.3k
| is_div
bool 2
classes | is_type
null | is_proof
bool 2
classes | completed_definiton
stringlengths 1
250k
| dependencies
dict | effect_flags
sequencelengths 0
2
| ideal_premises
sequencelengths 0
236
| mutual_with
sequencelengths 0
11
| file_context
stringlengths 0
407k
| interleaved
bool 1
class | is_simply_typed
bool 2
classes | file_name
stringlengths 5
48
| vconfig
dict | is_simple_lemma
null | source_type
stringlengths 10
23k
| proof_features
sequencelengths 0
1
| name
stringlengths 8
95
| source
dict | verbose_type
stringlengths 1
7.42k
| source_range
dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Prims.Tot | [
{
"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