effect stringclasses 48
values | original_source_type stringlengths 0 23k | opens_and_abbrevs listlengths 2 92 | isa_cross_project_example bool 1
class | source_definition stringlengths 9 57.9k | partial_definition stringlengths 7 23.3k | is_div bool 2
classes | is_type null | is_proof bool 2
classes | completed_definiton stringlengths 1 250k | dependencies dict | effect_flags listlengths 0 2 | ideal_premises listlengths 0 236 | mutual_with listlengths 0 11 | file_context stringlengths 0 407k | interleaved bool 1
class | is_simply_typed bool 2
classes | file_name stringlengths 5 48 | vconfig dict | is_simple_lemma null | source_type stringlengths 10 23k | proof_features listlengths 0 1 | name stringlengths 8 95 | source dict | verbose_type stringlengths 1 7.42k | source_range dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
FStar.Pervasives.Lemma | val _sigma1_lemma (#a #m x: _)
: Lemma (vec_v (_sigma1 #a #m x) == LSeq.map (Spec._sigma1 a) (vec_v x)) [SMTPat (_sigma1 x)] | [
{
"abbrev": true,
"full_module": "Hacl.Spec.SHA2.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"f... | false | let _sigma1_lemma #a #m x :
Lemma (vec_v (_sigma1 #a #m x) == LSeq.map (Spec._sigma1 a) (vec_v x))
[SMTPat (_sigma1 x)]
=
LSeq.eq_intro (vec_v (_sigma1 #a #m x)) (LSeq.map (Spec._sigma1 a) (vec_v x)) | val _sigma1_lemma (#a #m x: _)
: Lemma (vec_v (_sigma1 #a #m x) == LSeq.map (Spec._sigma1 a) (vec_v x)) [SMTPat (_sigma1 x)]
let _sigma1_lemma #a #m x
: Lemma (vec_v (_sigma1 #a #m x) == LSeq.map (Spec._sigma1 a) (vec_v x)) [SMTPat (_sigma1 x)] = | false | null | true | LSeq.eq_intro (vec_v (_sigma1 #a #m x)) (LSeq.map (Spec._sigma1 a) (vec_v x)) | {
"checked_file": "Hacl.Spec.SHA2.Equiv.fst.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.Serialize.fsti.chec... | [
"lemma"
] | [
"Spec.Hash.Definitions.sha2_alg",
"Hacl.Spec.SHA2.Vec.m_spec",
"Lib.IntVector.vec_t",
"Spec.Hash.Definitions.word_t",
"Hacl.Spec.SHA2.Vec.lanes",
"Lib.Sequence.eq_intro",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.SEC",
"Lib.IntVector.vec_v",
"Hacl.Spec.SHA2.Vec._sigma1",
"Lib.Sequence.map",
"Hacl.S... | [] | module Hacl.Spec.SHA2.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.NTuple
open Lib.Sequence
open Lib.IntVector
open Lib.IntVector.Serialize
open Lib.LoopCombinators
open Spec.Hash.Definitions
open Hacl.Spec.SHA2.Vec
module Spec = Hacl.Spec.SHA2
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module Lemma... | false | false | Hacl.Spec.SHA2.Equiv.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_el... | null | val _sigma1_lemma (#a #m x: _)
: Lemma (vec_v (_sigma1 #a #m x) == LSeq.map (Spec._sigma1 a) (vec_v x)) [SMTPat (_sigma1 x)] | [] | Hacl.Spec.SHA2.Equiv._sigma1_lemma | {
"file_name": "code/sha2-mb/Hacl.Spec.SHA2.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Lib.IntVector.vec_t (Spec.Hash.Definitions.word_t a) (Hacl.Spec.SHA2.Vec.lanes a m)
-> FStar.Pervasives.Lemma
(ensures
Lib.IntVector.vec_v (Hacl.Spec.SHA2.Vec._sigma1 x) ==
Lib.Sequence.map (Hacl.Spec.SHA2._sigma1 a) (Lib.IntVector.vec_v x))
[SMTPat (Hacl.Spec.SHA2.Vec._sigma1 x)] | {
"end_col": 79,
"end_line": 61,
"start_col": 2,
"start_line": 61
} |
FStar.Pervasives.Lemma | val update_lemma_l:
#a:sha2_alg
-> #m:m_spec{is_supported a m}
-> b:multiblock_spec a m
-> st:state_spec a m
-> l:nat{l < lanes a m} ->
Lemma ((state_spec_v (update b st)).[l] ==
Spec.update a b.(|l|) (state_spec_v st).[l]) | [
{
"abbrev": true,
"full_module": "Hacl.Spec.SHA2.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"f... | false | let update_lemma_l #a #m b st l =
reveal_opaque (`%update) (update #a #m);
let ws = load_ws b in
load_ws_lemma_l b l;
let st1 = shuffle ws st in
shuffle_lemma_l ws st l;
let res = map2 (+|) st1 st in
state_spec_v_map2_add #a #m st1 st l | val update_lemma_l:
#a:sha2_alg
-> #m:m_spec{is_supported a m}
-> b:multiblock_spec a m
-> st:state_spec a m
-> l:nat{l < lanes a m} ->
Lemma ((state_spec_v (update b st)).[l] ==
Spec.update a b.(|l|) (state_spec_v st).[l])
let update_lemma_l #a #m b st l = | false | null | true | reveal_opaque (`%update) (update #a #m);
let ws = load_ws b in
load_ws_lemma_l b l;
let st1 = shuffle ws st in
shuffle_lemma_l ws st l;
let res = map2 ( +| ) st1 st in
state_spec_v_map2_add #a #m st1 st l | {
"checked_file": "Hacl.Spec.SHA2.Equiv.fst.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.Serialize.fsti.chec... | [
"lemma"
] | [
"Spec.Hash.Definitions.sha2_alg",
"Hacl.Spec.SHA2.Vec.m_spec",
"Hacl.Spec.SHA2.Vec.is_supported",
"Hacl.Spec.SHA2.Vec.multiblock_spec",
"Hacl.Spec.SHA2.Vec.state_spec",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.SHA2.Vec.lanes",
"Hacl.Spec.SHA2.Equiv.state_spec_v_map2_add",
"Lib.S... | [] | module Hacl.Spec.SHA2.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.NTuple
open Lib.Sequence
open Lib.IntVector
open Lib.IntVector.Serialize
open Lib.LoopCombinators
open Spec.Hash.Definitions
open Hacl.Spec.SHA2.Vec
module Spec = Hacl.Spec.SHA2
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module Lemma... | false | false | Hacl.Spec.SHA2.Equiv.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_el... | null | val update_lemma_l:
#a:sha2_alg
-> #m:m_spec{is_supported a m}
-> b:multiblock_spec a m
-> st:state_spec a m
-> l:nat{l < lanes a m} ->
Lemma ((state_spec_v (update b st)).[l] ==
Spec.update a b.(|l|) (state_spec_v st).[l]) | [] | Hacl.Spec.SHA2.Equiv.update_lemma_l | {
"file_name": "code/sha2-mb/Hacl.Spec.SHA2.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
b: Hacl.Spec.SHA2.Vec.multiblock_spec a m ->
st: Hacl.Spec.SHA2.Vec.state_spec a m ->
l: Prims.nat{l < Hacl.Spec.SHA2.Vec.lanes a m}
-> FStar.Pervasives.Lemma
(ensures
(Hacl.Spec.SHA2.Vec.state_spec_v (Hacl.Spec.SHA2.Vec.update b st)).[ l ] ==
Hacl.Spec.SHA2.update a (( .(||) ) b l) (Hacl... | {
"end_col": 38,
"end_line": 452,
"start_col": 2,
"start_line": 444
} |
FStar.Pervasives.Lemma | val _Sigma0_lemma (#a #m x: _)
: Lemma (vec_v (_Sigma0 #a #m x) == LSeq.map (Spec._Sigma0 a) (vec_v x)) [SMTPat (_Sigma0 x)] | [
{
"abbrev": true,
"full_module": "Hacl.Spec.SHA2.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"f... | false | let _Sigma0_lemma #a #m x :
Lemma (vec_v (_Sigma0 #a #m x) == LSeq.map (Spec._Sigma0 a) (vec_v x))
[SMTPat (_Sigma0 x)]
=
LSeq.eq_intro (vec_v (_Sigma0 #a #m x)) (LSeq.map (Spec._Sigma0 a) (vec_v x)) | val _Sigma0_lemma (#a #m x: _)
: Lemma (vec_v (_Sigma0 #a #m x) == LSeq.map (Spec._Sigma0 a) (vec_v x)) [SMTPat (_Sigma0 x)]
let _Sigma0_lemma #a #m x
: Lemma (vec_v (_Sigma0 #a #m x) == LSeq.map (Spec._Sigma0 a) (vec_v x)) [SMTPat (_Sigma0 x)] = | false | null | true | LSeq.eq_intro (vec_v (_Sigma0 #a #m x)) (LSeq.map (Spec._Sigma0 a) (vec_v x)) | {
"checked_file": "Hacl.Spec.SHA2.Equiv.fst.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.Serialize.fsti.chec... | [
"lemma"
] | [
"Spec.Hash.Definitions.sha2_alg",
"Hacl.Spec.SHA2.Vec.m_spec",
"Lib.IntVector.vec_t",
"Spec.Hash.Definitions.word_t",
"Hacl.Spec.SHA2.Vec.lanes",
"Lib.Sequence.eq_intro",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.SEC",
"Lib.IntVector.vec_v",
"Hacl.Spec.SHA2.Vec._Sigma0",
"Lib.Sequence.map",
"Hacl.S... | [] | module Hacl.Spec.SHA2.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.NTuple
open Lib.Sequence
open Lib.IntVector
open Lib.IntVector.Serialize
open Lib.LoopCombinators
open Spec.Hash.Definitions
open Hacl.Spec.SHA2.Vec
module Spec = Hacl.Spec.SHA2
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module Lemma... | false | false | Hacl.Spec.SHA2.Equiv.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_el... | null | val _Sigma0_lemma (#a #m x: _)
: Lemma (vec_v (_Sigma0 #a #m x) == LSeq.map (Spec._Sigma0 a) (vec_v x)) [SMTPat (_Sigma0 x)] | [] | Hacl.Spec.SHA2.Equiv._Sigma0_lemma | {
"file_name": "code/sha2-mb/Hacl.Spec.SHA2.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Lib.IntVector.vec_t (Spec.Hash.Definitions.word_t a) (Hacl.Spec.SHA2.Vec.lanes a m)
-> FStar.Pervasives.Lemma
(ensures
Lib.IntVector.vec_v (Hacl.Spec.SHA2.Vec._Sigma0 x) ==
Lib.Sequence.map (Hacl.Spec.SHA2._Sigma0 a) (Lib.IntVector.vec_v x))
[SMTPat (Hacl.Spec.SHA2.Vec._Sigma0 x)] | {
"end_col": 79,
"end_line": 43,
"start_col": 2,
"start_line": 43
} |
FStar.Pervasives.Lemma | val _Sigma1_lemma (#a #m x: _)
: Lemma (vec_v (_Sigma1 #a #m x) == LSeq.map (Spec._Sigma1 a) (vec_v x)) [SMTPat (_Sigma1 x)] | [
{
"abbrev": true,
"full_module": "Hacl.Spec.SHA2.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"f... | false | let _Sigma1_lemma #a #m x :
Lemma (vec_v (_Sigma1 #a #m x) == LSeq.map (Spec._Sigma1 a) (vec_v x))
[SMTPat (_Sigma1 x)]
=
LSeq.eq_intro (vec_v (_Sigma1 #a #m x)) (LSeq.map (Spec._Sigma1 a) (vec_v x)) | val _Sigma1_lemma (#a #m x: _)
: Lemma (vec_v (_Sigma1 #a #m x) == LSeq.map (Spec._Sigma1 a) (vec_v x)) [SMTPat (_Sigma1 x)]
let _Sigma1_lemma #a #m x
: Lemma (vec_v (_Sigma1 #a #m x) == LSeq.map (Spec._Sigma1 a) (vec_v x)) [SMTPat (_Sigma1 x)] = | false | null | true | LSeq.eq_intro (vec_v (_Sigma1 #a #m x)) (LSeq.map (Spec._Sigma1 a) (vec_v x)) | {
"checked_file": "Hacl.Spec.SHA2.Equiv.fst.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.Serialize.fsti.chec... | [
"lemma"
] | [
"Spec.Hash.Definitions.sha2_alg",
"Hacl.Spec.SHA2.Vec.m_spec",
"Lib.IntVector.vec_t",
"Spec.Hash.Definitions.word_t",
"Hacl.Spec.SHA2.Vec.lanes",
"Lib.Sequence.eq_intro",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.SEC",
"Lib.IntVector.vec_v",
"Hacl.Spec.SHA2.Vec._Sigma1",
"Lib.Sequence.map",
"Hacl.S... | [] | module Hacl.Spec.SHA2.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.NTuple
open Lib.Sequence
open Lib.IntVector
open Lib.IntVector.Serialize
open Lib.LoopCombinators
open Spec.Hash.Definitions
open Hacl.Spec.SHA2.Vec
module Spec = Hacl.Spec.SHA2
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module Lemma... | false | false | Hacl.Spec.SHA2.Equiv.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_el... | null | val _Sigma1_lemma (#a #m x: _)
: Lemma (vec_v (_Sigma1 #a #m x) == LSeq.map (Spec._Sigma1 a) (vec_v x)) [SMTPat (_Sigma1 x)] | [] | Hacl.Spec.SHA2.Equiv._Sigma1_lemma | {
"file_name": "code/sha2-mb/Hacl.Spec.SHA2.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Lib.IntVector.vec_t (Spec.Hash.Definitions.word_t a) (Hacl.Spec.SHA2.Vec.lanes a m)
-> FStar.Pervasives.Lemma
(ensures
Lib.IntVector.vec_v (Hacl.Spec.SHA2.Vec._Sigma1 x) ==
Lib.Sequence.map (Hacl.Spec.SHA2._Sigma1 a) (Lib.IntVector.vec_v x))
[SMTPat (Hacl.Spec.SHA2.Vec._Sigma1 x)] | {
"end_col": 79,
"end_line": 49,
"start_col": 2,
"start_line": 49
} |
FStar.Pervasives.Lemma | val _sigma0_lemma (#a #m x: _)
: Lemma (vec_v (_sigma0 #a #m x) == LSeq.map (Spec._sigma0 a) (vec_v x)) [SMTPat (_sigma0 x)] | [
{
"abbrev": true,
"full_module": "Hacl.Spec.SHA2.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"f... | false | let _sigma0_lemma #a #m x :
Lemma (vec_v (_sigma0 #a #m x) == LSeq.map (Spec._sigma0 a) (vec_v x))
[SMTPat (_sigma0 x)]
=
LSeq.eq_intro (vec_v (_sigma0 #a #m x)) (LSeq.map (Spec._sigma0 a) (vec_v x)) | val _sigma0_lemma (#a #m x: _)
: Lemma (vec_v (_sigma0 #a #m x) == LSeq.map (Spec._sigma0 a) (vec_v x)) [SMTPat (_sigma0 x)]
let _sigma0_lemma #a #m x
: Lemma (vec_v (_sigma0 #a #m x) == LSeq.map (Spec._sigma0 a) (vec_v x)) [SMTPat (_sigma0 x)] = | false | null | true | LSeq.eq_intro (vec_v (_sigma0 #a #m x)) (LSeq.map (Spec._sigma0 a) (vec_v x)) | {
"checked_file": "Hacl.Spec.SHA2.Equiv.fst.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.Serialize.fsti.chec... | [
"lemma"
] | [
"Spec.Hash.Definitions.sha2_alg",
"Hacl.Spec.SHA2.Vec.m_spec",
"Lib.IntVector.vec_t",
"Spec.Hash.Definitions.word_t",
"Hacl.Spec.SHA2.Vec.lanes",
"Lib.Sequence.eq_intro",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.SEC",
"Lib.IntVector.vec_v",
"Hacl.Spec.SHA2.Vec._sigma0",
"Lib.Sequence.map",
"Hacl.S... | [] | module Hacl.Spec.SHA2.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.NTuple
open Lib.Sequence
open Lib.IntVector
open Lib.IntVector.Serialize
open Lib.LoopCombinators
open Spec.Hash.Definitions
open Hacl.Spec.SHA2.Vec
module Spec = Hacl.Spec.SHA2
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module Lemma... | false | false | Hacl.Spec.SHA2.Equiv.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_el... | null | val _sigma0_lemma (#a #m x: _)
: Lemma (vec_v (_sigma0 #a #m x) == LSeq.map (Spec._sigma0 a) (vec_v x)) [SMTPat (_sigma0 x)] | [] | Hacl.Spec.SHA2.Equiv._sigma0_lemma | {
"file_name": "code/sha2-mb/Hacl.Spec.SHA2.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Lib.IntVector.vec_t (Spec.Hash.Definitions.word_t a) (Hacl.Spec.SHA2.Vec.lanes a m)
-> FStar.Pervasives.Lemma
(ensures
Lib.IntVector.vec_v (Hacl.Spec.SHA2.Vec._sigma0 x) ==
Lib.Sequence.map (Hacl.Spec.SHA2._sigma0 a) (Lib.IntVector.vec_v x))
[SMTPat (Hacl.Spec.SHA2.Vec._sigma0 x)] | {
"end_col": 79,
"end_line": 55,
"start_col": 2,
"start_line": 55
} |
FStar.Pervasives.Lemma | val shuffle_loop_lemma:
#a:sha2_alg
-> #m:m_spec
-> ws0:ws_spec a m
-> st0:state_spec a m
-> l:nat{l < lanes a m}
-> n:nat{n <= Spec.num_rounds16 a} ->
Lemma
(let (ws_v, st_v) = repeati n (shuffle_inner_loop #a #m) (ws0, st0) in
let (ws, st) = repeati n (Spec.shuffle_inner_loop a) ((ws_spec_v ws0... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.SHA2.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"f... | false | let rec shuffle_loop_lemma #a #m ws0 st0 l n =
let (ws_v, st_v) = repeati n (shuffle_inner_loop #a #m) (ws0, st0) in
let acc0 = ((ws_spec_v ws0).[l], (state_spec_v st0).[l]) in
let (ws, st) = repeati n (Spec.shuffle_inner_loop a) acc0 in
if n = 0 then begin
eq_repeati0 n (shuffle_inner_loop #a #m) (ws0, st... | val shuffle_loop_lemma:
#a:sha2_alg
-> #m:m_spec
-> ws0:ws_spec a m
-> st0:state_spec a m
-> l:nat{l < lanes a m}
-> n:nat{n <= Spec.num_rounds16 a} ->
Lemma
(let (ws_v, st_v) = repeati n (shuffle_inner_loop #a #m) (ws0, st0) in
let (ws, st) = repeati n (Spec.shuffle_inner_loop a) ((ws_spec_v ws0... | false | null | true | let ws_v, st_v = repeati n (shuffle_inner_loop #a #m) (ws0, st0) in
let acc0 = ((ws_spec_v ws0).[ l ], (state_spec_v st0).[ l ]) in
let ws, st = repeati n (Spec.shuffle_inner_loop a) acc0 in
if n = 0
then
(eq_repeati0 n (shuffle_inner_loop #a #m) (ws0, st0);
eq_repeati0 n (Spec.shuffle_inner_loop a) acc0;
shu... | {
"checked_file": "Hacl.Spec.SHA2.Equiv.fst.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.Serialize.fsti.chec... | [
"lemma"
] | [
"Spec.Hash.Definitions.sha2_alg",
"Hacl.Spec.SHA2.Vec.m_spec",
"Hacl.Spec.SHA2.Vec.ws_spec",
"Hacl.Spec.SHA2.Vec.state_spec",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.SHA2.Vec.lanes",
"Prims.op_LessThanOrEqual",
"Hacl.Spec.SHA2.num_rounds16",
"Hacl.Spec.SHA2.k_w",
"Spec.Hash.D... | [] | module Hacl.Spec.SHA2.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.NTuple
open Lib.Sequence
open Lib.IntVector
open Lib.IntVector.Serialize
open Lib.LoopCombinators
open Spec.Hash.Definitions
open Hacl.Spec.SHA2.Vec
module Spec = Hacl.Spec.SHA2
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module Lemma... | false | false | Hacl.Spec.SHA2.Equiv.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_el... | null | val shuffle_loop_lemma:
#a:sha2_alg
-> #m:m_spec
-> ws0:ws_spec a m
-> st0:state_spec a m
-> l:nat{l < lanes a m}
-> n:nat{n <= Spec.num_rounds16 a} ->
Lemma
(let (ws_v, st_v) = repeati n (shuffle_inner_loop #a #m) (ws0, st0) in
let (ws, st) = repeati n (Spec.shuffle_inner_loop a) ((ws_spec_v ws0... | [
"recursion"
] | Hacl.Spec.SHA2.Equiv.shuffle_loop_lemma | {
"file_name": "code/sha2-mb/Hacl.Spec.SHA2.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
ws0: Hacl.Spec.SHA2.Vec.ws_spec a m ->
st0: Hacl.Spec.SHA2.Vec.state_spec a m ->
l: Prims.nat{l < Hacl.Spec.SHA2.Vec.lanes a m} ->
n: Prims.nat{n <= Hacl.Spec.SHA2.num_rounds16 a}
-> FStar.Pervasives.Lemma
(ensures
(let _ = Lib.LoopCombinators.repeati n Hacl.Spec.SHA2.Vec.shuffle_inner_loop... | {
"end_col": 65,
"end_line": 280,
"start_col": 46,
"start_line": 264
} |
FStar.Pervasives.Lemma | val load_blocks_lemma_ij_subst:
#a:sha2_alg
-> #m:m_spec
-> b:multiblock_spec a m
-> j:nat{j < lanes a m}
-> i:nat{i < 16} ->
Lemma (let l = lanes a m in
(vec_v (load_blocks b).[i / l * l + j]).[i % l] ==
BSeq.uint_from_bytes_be
(Seq.slice b.(|j|) (i * word_length a) (i * word_length a + wor... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.SHA2.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"f... | false | let load_blocks_lemma_ij_subst #a #m b j i =
let l = lanes a m in
let i_new = i / l * l + j in
let j_new = i % l in
load_blocks_lemma_ij #a #m b j_new i_new;
//assert (
//(vec_v (load_blocks b).[i_new]).[j_new] ==
//BSeq.uint_from_bytes_be (sub b.(|i_new % l|) ((i_new / l * l + j_new) * word_length a)... | val load_blocks_lemma_ij_subst:
#a:sha2_alg
-> #m:m_spec
-> b:multiblock_spec a m
-> j:nat{j < lanes a m}
-> i:nat{i < 16} ->
Lemma (let l = lanes a m in
(vec_v (load_blocks b).[i / l * l + j]).[i % l] ==
BSeq.uint_from_bytes_be
(Seq.slice b.(|j|) (i * word_length a) (i * word_length a + wor... | false | null | true | let l = lanes a m in
let i_new = (i / l) * l + j in
let j_new = i % l in
load_blocks_lemma_ij #a #m b j_new i_new;
calc ( == ) {
i_new % l;
( == ) { () }
((i / l) * l + j) % l;
( == ) { Math.Lemmas.modulo_addition_lemma j l (i / l) }
j % l;
( == ) { Math.Lemmas.small_mod j l }
j;
};
calc ( == ) {
(i_new... | {
"checked_file": "Hacl.Spec.SHA2.Equiv.fst.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.Serialize.fsti.chec... | [
"lemma"
] | [
"Spec.Hash.Definitions.sha2_alg",
"Hacl.Spec.SHA2.Vec.m_spec",
"Hacl.Spec.SHA2.Vec.multiblock_spec",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.SHA2.Vec.lanes",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.op_Division",
... | [] | module Hacl.Spec.SHA2.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.NTuple
open Lib.Sequence
open Lib.IntVector
open Lib.IntVector.Serialize
open Lib.LoopCombinators
open Spec.Hash.Definitions
open Hacl.Spec.SHA2.Vec
module Spec = Hacl.Spec.SHA2
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module Lemma... | false | false | Hacl.Spec.SHA2.Equiv.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_el... | null | val load_blocks_lemma_ij_subst:
#a:sha2_alg
-> #m:m_spec
-> b:multiblock_spec a m
-> j:nat{j < lanes a m}
-> i:nat{i < 16} ->
Lemma (let l = lanes a m in
(vec_v (load_blocks b).[i / l * l + j]).[i % l] ==
BSeq.uint_from_bytes_be
(Seq.slice b.(|j|) (i * word_length a) (i * word_length a + wor... | [] | Hacl.Spec.SHA2.Equiv.load_blocks_lemma_ij_subst | {
"file_name": "code/sha2-mb/Hacl.Spec.SHA2.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
b: Hacl.Spec.SHA2.Vec.multiblock_spec a m ->
j: Prims.nat{j < Hacl.Spec.SHA2.Vec.lanes a m} ->
i: Prims.nat{i < 16}
-> FStar.Pervasives.Lemma
(ensures
(let l = Hacl.Spec.SHA2.Vec.lanes a m in
(Lib.IntVector.vec_v (Hacl.Spec.SHA2.Vec.load_blocks b).[ (i / l) * l + j ]).[ i % l ] ==
... | {
"end_col": 5,
"end_line": 389,
"start_col": 44,
"start_line": 358
} |
FStar.Pervasives.Lemma | val update_nblocks_loop_lemma:
#a:sha2_alg
-> #m:m_spec{is_supported a m}
-> len:Spec.len_lt_max_a_t a
-> b:multiseq (lanes a m) len
-> st:state_spec a m
-> l:nat{l < lanes a m}
-> n:nat{n <= len / block_length a } ->
Lemma
((state_spec_v (repeati n (update_block #a #m len b) st)).[l] ==
repeat... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.SHA2.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"f... | false | let rec update_nblocks_loop_lemma #a #m len b st l n =
let lp = repeati n (update_block #a #m len b) st in
let f_sc = Spec.update_block a len b.(|l|) in
let rp = repeati n f_sc (state_spec_v st).[l] in
if n = 0 then begin
eq_repeati0 n (update_block #a #m len b) st;
eq_repeati0 n f_sc (state_spec_v st)... | val update_nblocks_loop_lemma:
#a:sha2_alg
-> #m:m_spec{is_supported a m}
-> len:Spec.len_lt_max_a_t a
-> b:multiseq (lanes a m) len
-> st:state_spec a m
-> l:nat{l < lanes a m}
-> n:nat{n <= len / block_length a } ->
Lemma
((state_spec_v (repeati n (update_block #a #m len b) st)).[l] ==
repeat... | false | null | true | let lp = repeati n (update_block #a #m len b) st in
let f_sc = Spec.update_block a len b.(| l |) in
let rp = repeati n f_sc (state_spec_v st).[ l ] in
if n = 0
then
(eq_repeati0 n (update_block #a #m len b) st;
eq_repeati0 n f_sc (state_spec_v st).[ l ])
else
let lp1 = repeati (n - 1) (update_block #a #m len b)... | {
"checked_file": "Hacl.Spec.SHA2.Equiv.fst.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.Serialize.fsti.chec... | [
"lemma"
] | [
"Spec.Hash.Definitions.sha2_alg",
"Hacl.Spec.SHA2.Vec.m_spec",
"Hacl.Spec.SHA2.Vec.is_supported",
"Hacl.Spec.SHA2.len_lt_max_a_t",
"Hacl.Spec.SHA2.Vec.multiseq",
"Hacl.Spec.SHA2.Vec.lanes",
"Hacl.Spec.SHA2.Vec.state_spec",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual"... | [] | module Hacl.Spec.SHA2.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.NTuple
open Lib.Sequence
open Lib.IntVector
open Lib.IntVector.Serialize
open Lib.LoopCombinators
open Spec.Hash.Definitions
open Hacl.Spec.SHA2.Vec
module Spec = Hacl.Spec.SHA2
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module Lemma... | false | false | Hacl.Spec.SHA2.Equiv.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_el... | null | val update_nblocks_loop_lemma:
#a:sha2_alg
-> #m:m_spec{is_supported a m}
-> len:Spec.len_lt_max_a_t a
-> b:multiseq (lanes a m) len
-> st:state_spec a m
-> l:nat{l < lanes a m}
-> n:nat{n <= len / block_length a } ->
Lemma
((state_spec_v (repeati n (update_block #a #m len b) st)).[l] ==
repeat... | [
"recursion"
] | Hacl.Spec.SHA2.Equiv.update_nblocks_loop_lemma | {
"file_name": "code/sha2-mb/Hacl.Spec.SHA2.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
len: Hacl.Spec.SHA2.len_lt_max_a_t a ->
b: Hacl.Spec.SHA2.Vec.multiseq (Hacl.Spec.SHA2.Vec.lanes a m) len ->
st: Hacl.Spec.SHA2.Vec.state_spec a m ->
l: Prims.nat{l < Hacl.Spec.SHA2.Vec.lanes a m} ->
n: Prims.nat{n <= len / Spec.Hash.Definitions.block_length a}
-> FStar.Pervasives.Lemma
(ensu... | {
"end_col": 54,
"end_line": 638,
"start_col": 54,
"start_line": 623
} |
FStar.Pervasives.Lemma | val store_state_lemma_l:
#a:sha2_alg
-> #m:m_spec{is_supported a m}
-> st:state_spec a m
-> l:nat{l < lanes a m} ->
Lemma
(sub (store_state st) (l * (8 * word_length a)) (8 * word_length a) ==
Spec.store_state a (state_spec_v st).[l]) | [
{
"abbrev": true,
"full_module": "Hacl.Spec.SHA2.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"f... | false | let store_state_lemma_l #a #m st l =
let st_l : words_state a = (state_spec_v st).[l] in
let rp = Spec.store_state a st_l in
let lp = store_state st in
let aux (i:nat{i < 8 * word_length a}) : Lemma (lp.[l * (8 * word_length a) + i] == rp.[i]) =
//assert (rp == BSeq.uints_to_bytes_be #(word_t a) #SEC #8 st... | val store_state_lemma_l:
#a:sha2_alg
-> #m:m_spec{is_supported a m}
-> st:state_spec a m
-> l:nat{l < lanes a m} ->
Lemma
(sub (store_state st) (l * (8 * word_length a)) (8 * word_length a) ==
Spec.store_state a (state_spec_v st).[l])
let store_state_lemma_l #a #m st l = | false | null | true | let st_l:words_state a = (state_spec_v st).[ l ] in
let rp = Spec.store_state a st_l in
let lp = store_state st in
let aux (i: nat{i < 8 * word_length a}) : Lemma (lp.[ l * (8 * word_length a) + i ] == rp.[ i ]) =
BSeq.index_uints_to_bytes_be #(word_t a) #SEC #8 st_l i;
store_state_lemma_ij #a #m st l i
in
Classica... | {
"checked_file": "Hacl.Spec.SHA2.Equiv.fst.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.Serialize.fsti.chec... | [
"lemma"
] | [
"Spec.Hash.Definitions.sha2_alg",
"Hacl.Spec.SHA2.Vec.m_spec",
"Hacl.Spec.SHA2.Vec.is_supported",
"Hacl.Spec.SHA2.Vec.state_spec",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.SHA2.Vec.lanes",
"Lib.Sequence.eq_intro",
"Lib.IntTypes.uint8",
"FStar.Mul.op_Star",
"Spec.Hash.Definitio... | [] | module Hacl.Spec.SHA2.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.NTuple
open Lib.Sequence
open Lib.IntVector
open Lib.IntVector.Serialize
open Lib.LoopCombinators
open Spec.Hash.Definitions
open Hacl.Spec.SHA2.Vec
module Spec = Hacl.Spec.SHA2
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module Lemma... | false | false | Hacl.Spec.SHA2.Equiv.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_el... | null | val store_state_lemma_l:
#a:sha2_alg
-> #m:m_spec{is_supported a m}
-> st:state_spec a m
-> l:nat{l < lanes a m} ->
Lemma
(sub (store_state st) (l * (8 * word_length a)) (8 * word_length a) ==
Spec.store_state a (state_spec_v st).[l]) | [] | Hacl.Spec.SHA2.Equiv.store_state_lemma_l | {
"file_name": "code/sha2-mb/Hacl.Spec.SHA2.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | st: Hacl.Spec.SHA2.Vec.state_spec a m -> l: Prims.nat{l < Hacl.Spec.SHA2.Vec.lanes a m}
-> FStar.Pervasives.Lemma
(ensures
Lib.Sequence.sub (Hacl.Spec.SHA2.Vec.store_state st)
(l * (8 * Spec.Hash.Definitions.word_length a))
(8 * Spec.Hash.Definitions.word_length a) ==
Hacl.Spec.SHA2.st... | {
"end_col": 46,
"end_line": 570,
"start_col": 36,
"start_line": 557
} |
FStar.Pervasives.Lemma | val ws_next_lemma_loop:
#a:sha2_alg
-> #m:m_spec
-> ws:ws_spec a m
-> l:nat{l < lanes a m}
-> n:nat{n <= 16} ->
Lemma
((ws_spec_v (repeati n (ws_next_inner #a #m) ws)).[l] ==
repeati n (Spec.ws_next_inner a) (ws_spec_v ws).[l]) | [
{
"abbrev": true,
"full_module": "Hacl.Spec.SHA2.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"f... | false | let rec ws_next_lemma_loop #a #m ws l n =
let lp = repeati n (ws_next_inner #a #m) ws in
let rp = repeati n (Spec.ws_next_inner a) (ws_spec_v ws).[l] in
if n = 0 then begin
eq_repeati0 n (ws_next_inner #a #m) ws;
eq_repeati0 n (Spec.ws_next_inner a) (ws_spec_v ws).[l];
ws_next_inner_lemma_l 0 ws l en... | val ws_next_lemma_loop:
#a:sha2_alg
-> #m:m_spec
-> ws:ws_spec a m
-> l:nat{l < lanes a m}
-> n:nat{n <= 16} ->
Lemma
((ws_spec_v (repeati n (ws_next_inner #a #m) ws)).[l] ==
repeati n (Spec.ws_next_inner a) (ws_spec_v ws).[l])
let rec ws_next_lemma_loop #a #m ws l n = | false | null | true | let lp = repeati n (ws_next_inner #a #m) ws in
let rp = repeati n (Spec.ws_next_inner a) (ws_spec_v ws).[ l ] in
if n = 0
then
(eq_repeati0 n (ws_next_inner #a #m) ws;
eq_repeati0 n (Spec.ws_next_inner a) (ws_spec_v ws).[ l ];
ws_next_inner_lemma_l 0 ws l)
else
let lp0 = repeati (n - 1) (ws_next_inner #a #m... | {
"checked_file": "Hacl.Spec.SHA2.Equiv.fst.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.Serialize.fsti.chec... | [
"lemma"
] | [
"Spec.Hash.Definitions.sha2_alg",
"Hacl.Spec.SHA2.Vec.m_spec",
"Hacl.Spec.SHA2.Vec.ws_spec",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.SHA2.Vec.lanes",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"Hacl.Spec.SHA2.Equiv.ws_next_inner_lemma_l",
"Prims.unit",
"L... | [] | module Hacl.Spec.SHA2.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.NTuple
open Lib.Sequence
open Lib.IntVector
open Lib.IntVector.Serialize
open Lib.LoopCombinators
open Spec.Hash.Definitions
open Hacl.Spec.SHA2.Vec
module Spec = Hacl.Spec.SHA2
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module Lemma... | false | false | Hacl.Spec.SHA2.Equiv.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_el... | null | val ws_next_lemma_loop:
#a:sha2_alg
-> #m:m_spec
-> ws:ws_spec a m
-> l:nat{l < lanes a m}
-> n:nat{n <= 16} ->
Lemma
((ws_spec_v (repeati n (ws_next_inner #a #m) ws)).[l] ==
repeati n (Spec.ws_next_inner a) (ws_spec_v ws).[l]) | [
"recursion"
] | Hacl.Spec.SHA2.Equiv.ws_next_lemma_loop | {
"file_name": "code/sha2-mb/Hacl.Spec.SHA2.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
ws: Hacl.Spec.SHA2.Vec.ws_spec a m ->
l: Prims.nat{l < Hacl.Spec.SHA2.Vec.lanes a m} ->
n: Prims.nat{n <= 16}
-> FStar.Pervasives.Lemma
(ensures
(Hacl.Spec.SHA2.Vec.ws_spec_v (Lib.LoopCombinators.repeati n
Hacl.Spec.SHA2.Vec.ws_next_inner
ws)).[ l ] ==
Lib.Loop... | {
"end_col": 10,
"end_line": 173,
"start_col": 41,
"start_line": 155
} |
FStar.Pervasives.Lemma | val state_spec_v_map2_add:
#a:sha2_alg
-> #m:m_spec
-> st1:state_spec a m
-> st2:state_spec a m
-> l:nat{l < lanes a m} ->
Lemma ((state_spec_v (map2 (+|) st1 st2)).[l] ==
map2 #_ #_ #_ #8 (+.) (state_spec_v st1).[l] (state_spec_v st2).[l]) | [
{
"abbrev": true,
"full_module": "Hacl.Spec.SHA2.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"f... | false | let state_spec_v_map2_add #a #m st1 st2 l =
eq_intro
(state_spec_v (map2 (+|) st1 st2)).[l]
(map2 #_ #_ #_ #8 (+.) (state_spec_v st1).[l] (state_spec_v st2).[l]) | val state_spec_v_map2_add:
#a:sha2_alg
-> #m:m_spec
-> st1:state_spec a m
-> st2:state_spec a m
-> l:nat{l < lanes a m} ->
Lemma ((state_spec_v (map2 (+|) st1 st2)).[l] ==
map2 #_ #_ #_ #8 (+.) (state_spec_v st1).[l] (state_spec_v st2).[l])
let state_spec_v_map2_add #a #m st1 st2 l = | false | null | true | eq_intro (state_spec_v (map2 ( +| ) st1 st2)).[ l ]
(map2 #_ #_ #_ #8 ( +. ) (state_spec_v st1).[ l ] (state_spec_v st2).[ l ]) | {
"checked_file": "Hacl.Spec.SHA2.Equiv.fst.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.Serialize.fsti.chec... | [
"lemma"
] | [
"Spec.Hash.Definitions.sha2_alg",
"Hacl.Spec.SHA2.Vec.m_spec",
"Hacl.Spec.SHA2.Vec.state_spec",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.SHA2.Vec.lanes",
"Lib.Sequence.eq_intro",
"Hacl.Spec.SHA2.Vec.word",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.SHA2.Vec.words_state'",
"Ha... | [] | module Hacl.Spec.SHA2.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.NTuple
open Lib.Sequence
open Lib.IntVector
open Lib.IntVector.Serialize
open Lib.LoopCombinators
open Spec.Hash.Definitions
open Hacl.Spec.SHA2.Vec
module Spec = Hacl.Spec.SHA2
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module Lemma... | false | false | Hacl.Spec.SHA2.Equiv.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_el... | null | val state_spec_v_map2_add:
#a:sha2_alg
-> #m:m_spec
-> st1:state_spec a m
-> st2:state_spec a m
-> l:nat{l < lanes a m} ->
Lemma ((state_spec_v (map2 (+|) st1 st2)).[l] ==
map2 #_ #_ #_ #8 (+.) (state_spec_v st1).[l] (state_spec_v st2).[l]) | [] | Hacl.Spec.SHA2.Equiv.state_spec_v_map2_add | {
"file_name": "code/sha2-mb/Hacl.Spec.SHA2.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
st1: Hacl.Spec.SHA2.Vec.state_spec a m ->
st2: Hacl.Spec.SHA2.Vec.state_spec a m ->
l: Prims.nat{l < Hacl.Spec.SHA2.Vec.lanes a m}
-> FStar.Pervasives.Lemma
(ensures
(Hacl.Spec.SHA2.Vec.state_spec_v (Lib.Sequence.map2 Hacl.Spec.SHA2.Vec.op_Plus_Bar st1 st2)).[
l ] ==
Lib.Sequence.... | {
"end_col": 73,
"end_line": 431,
"start_col": 2,
"start_line": 429
} |
FStar.Pervasives.Lemma | val shuffle_inner_lemma_l:
#a:sha2_alg
-> #m:m_spec
-> ws:ws_spec a m
-> i:nat{i < Spec.num_rounds16 a}
-> j:nat{j < 16}
-> st:state_spec a m
-> l:nat{l < lanes a m} ->
Lemma
((state_spec_v (shuffle_inner ws i j st)).[l] ==
Spec.shuffle_inner a (ws_spec_v ws).[l] i j (state_spec_v st).[l]) | [
{
"abbrev": true,
"full_module": "Hacl.Spec.SHA2.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"f... | false | let shuffle_inner_lemma_l #a #m ws i j st l =
let k_t = Seq.index (Spec.k0 a) (16 * i + j) in
let ws_t = ws.[j] in
shuffle_core_spec_lemma_l k_t ws_t st l | val shuffle_inner_lemma_l:
#a:sha2_alg
-> #m:m_spec
-> ws:ws_spec a m
-> i:nat{i < Spec.num_rounds16 a}
-> j:nat{j < 16}
-> st:state_spec a m
-> l:nat{l < lanes a m} ->
Lemma
((state_spec_v (shuffle_inner ws i j st)).[l] ==
Spec.shuffle_inner a (ws_spec_v ws).[l] i j (state_spec_v st).[l])
le... | false | null | true | let k_t = Seq.index (Spec.k0 a) (16 * i + j) in
let ws_t = ws.[ j ] in
shuffle_core_spec_lemma_l k_t ws_t st l | {
"checked_file": "Hacl.Spec.SHA2.Equiv.fst.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.Serialize.fsti.chec... | [
"lemma"
] | [
"Spec.Hash.Definitions.sha2_alg",
"Hacl.Spec.SHA2.Vec.m_spec",
"Hacl.Spec.SHA2.Vec.ws_spec",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.SHA2.num_rounds16",
"Hacl.Spec.SHA2.Vec.state_spec",
"Hacl.Spec.SHA2.Vec.lanes",
"Hacl.Spec.SHA2.Equiv.shuffle_core_spec_lemma_l",
"Hacl.Spec.SHA... | [] | module Hacl.Spec.SHA2.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.NTuple
open Lib.Sequence
open Lib.IntVector
open Lib.IntVector.Serialize
open Lib.LoopCombinators
open Spec.Hash.Definitions
open Hacl.Spec.SHA2.Vec
module Spec = Hacl.Spec.SHA2
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module Lemma... | false | false | Hacl.Spec.SHA2.Equiv.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_el... | null | val shuffle_inner_lemma_l:
#a:sha2_alg
-> #m:m_spec
-> ws:ws_spec a m
-> i:nat{i < Spec.num_rounds16 a}
-> j:nat{j < 16}
-> st:state_spec a m
-> l:nat{l < lanes a m} ->
Lemma
((state_spec_v (shuffle_inner ws i j st)).[l] ==
Spec.shuffle_inner a (ws_spec_v ws).[l] i j (state_spec_v st).[l]) | [] | Hacl.Spec.SHA2.Equiv.shuffle_inner_lemma_l | {
"file_name": "code/sha2-mb/Hacl.Spec.SHA2.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
ws: Hacl.Spec.SHA2.Vec.ws_spec a m ->
i: Prims.nat{i < Hacl.Spec.SHA2.num_rounds16 a} ->
j: Prims.nat{j < 16} ->
st: Hacl.Spec.SHA2.Vec.state_spec a m ->
l: Prims.nat{l < Hacl.Spec.SHA2.Vec.lanes a m}
-> FStar.Pervasives.Lemma
(ensures
(Hacl.Spec.SHA2.Vec.state_spec_v (Hacl.Spec.SHA2.Ve... | {
"end_col": 41,
"end_line": 201,
"start_col": 45,
"start_line": 198
} |
FStar.Pervasives.Lemma | val shuffle_core_spec_lemma_l:
#a:sha2_alg
-> #m:m_spec
-> k_t:word a
-> ws_t:element_t a m
-> st:state_spec a m
-> l:nat{l < lanes a m} ->
Lemma
((state_spec_v (shuffle_core_spec k_t ws_t st)).[l] ==
Spec.shuffle_core_pre a k_t (vec_v ws_t).[l] (state_spec_v st).[l]) | [
{
"abbrev": true,
"full_module": "Hacl.Spec.SHA2.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"f... | false | let shuffle_core_spec_lemma_l #a #m k_t ws_t st l =
eq_intro #(word a) #(state_word_length a)
(state_spec_v (shuffle_core_spec k_t ws_t st)).[l]
(shuffle_core_pre_create8 a k_t (vec_v ws_t).[l] (state_spec_v st).[l]);
shuffle_core_pre_create8_lemma a k_t (vec_v ws_t).[l] (state_spec_v st).[l] | val shuffle_core_spec_lemma_l:
#a:sha2_alg
-> #m:m_spec
-> k_t:word a
-> ws_t:element_t a m
-> st:state_spec a m
-> l:nat{l < lanes a m} ->
Lemma
((state_spec_v (shuffle_core_spec k_t ws_t st)).[l] ==
Spec.shuffle_core_pre a k_t (vec_v ws_t).[l] (state_spec_v st).[l])
let shuffle_core_spec_lemma_... | false | null | true | eq_intro #(word a)
#(state_word_length a)
(state_spec_v (shuffle_core_spec k_t ws_t st)).[ l ]
(shuffle_core_pre_create8 a k_t (vec_v ws_t).[ l ] (state_spec_v st).[ l ]);
shuffle_core_pre_create8_lemma a k_t (vec_v ws_t).[ l ] (state_spec_v st).[ l ] | {
"checked_file": "Hacl.Spec.SHA2.Equiv.fst.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.Serialize.fsti.chec... | [
"lemma"
] | [
"Spec.Hash.Definitions.sha2_alg",
"Hacl.Spec.SHA2.Vec.m_spec",
"Hacl.Spec.SHA2.Vec.word",
"Hacl.Spec.SHA2.Vec.element_t",
"Hacl.Spec.SHA2.Vec.state_spec",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.SHA2.Vec.lanes",
"Hacl.Spec.SHA2.Equiv.shuffle_core_pre_create8_lemma",
"Lib.Sequen... | [] | module Hacl.Spec.SHA2.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.NTuple
open Lib.Sequence
open Lib.IntVector
open Lib.IntVector.Serialize
open Lib.LoopCombinators
open Spec.Hash.Definitions
open Hacl.Spec.SHA2.Vec
module Spec = Hacl.Spec.SHA2
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module Lemma... | false | false | Hacl.Spec.SHA2.Equiv.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_el... | null | val shuffle_core_spec_lemma_l:
#a:sha2_alg
-> #m:m_spec
-> k_t:word a
-> ws_t:element_t a m
-> st:state_spec a m
-> l:nat{l < lanes a m} ->
Lemma
((state_spec_v (shuffle_core_spec k_t ws_t st)).[l] ==
Spec.shuffle_core_pre a k_t (vec_v ws_t).[l] (state_spec_v st).[l]) | [] | Hacl.Spec.SHA2.Equiv.shuffle_core_spec_lemma_l | {
"file_name": "code/sha2-mb/Hacl.Spec.SHA2.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k_t: Hacl.Spec.SHA2.Vec.word a ->
ws_t: Hacl.Spec.SHA2.Vec.element_t a m ->
st: Hacl.Spec.SHA2.Vec.state_spec a m ->
l: Prims.nat{l < Hacl.Spec.SHA2.Vec.lanes a m}
-> FStar.Pervasives.Lemma
(ensures
(Hacl.Spec.SHA2.Vec.state_spec_v (Hacl.Spec.SHA2.Vec.shuffle_core_spec k_t ws_t st)).[ l ] =... | {
"end_col": 77,
"end_line": 127,
"start_col": 2,
"start_line": 124
} |
FStar.Pervasives.Lemma | val shuffle_inner_loop_lemma:
#a:sha2_alg
-> #m:m_spec
-> i:nat{i < Spec.num_rounds16 a}
-> ws0:ws_spec a m
-> st0:state_spec a m
-> l:nat{l < lanes a m}
-> n:nat{n <= 16} ->
Lemma
((state_spec_v (repeati n (shuffle_inner ws0 i) st0)).[l] ==
repeati n (Spec.shuffle_inner a (ws_spec_v ws0).[l]... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.SHA2.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"f... | false | let rec shuffle_inner_loop_lemma #a #m i ws0 st0 l n =
let f_sc = Spec.shuffle_inner a (ws_spec_v ws0).[l] i in
let lp = repeati n (shuffle_inner ws0 i) st0 in
let rp = repeati n f_sc (state_spec_v st0).[l] in
if n = 0 then begin
eq_repeati0 n (shuffle_inner ws0 i) st0;
eq_repeati0 n f_sc (state_spec_v... | val shuffle_inner_loop_lemma:
#a:sha2_alg
-> #m:m_spec
-> i:nat{i < Spec.num_rounds16 a}
-> ws0:ws_spec a m
-> st0:state_spec a m
-> l:nat{l < lanes a m}
-> n:nat{n <= 16} ->
Lemma
((state_spec_v (repeati n (shuffle_inner ws0 i) st0)).[l] ==
repeati n (Spec.shuffle_inner a (ws_spec_v ws0).[l]... | false | null | true | let f_sc = Spec.shuffle_inner a (ws_spec_v ws0).[ l ] i in
let lp = repeati n (shuffle_inner ws0 i) st0 in
let rp = repeati n f_sc (state_spec_v st0).[ l ] in
if n = 0
then
(eq_repeati0 n (shuffle_inner ws0 i) st0;
eq_repeati0 n f_sc (state_spec_v st0).[ l ];
shuffle_inner_lemma_l #a #m ws0 i n st0 l)
else
... | {
"checked_file": "Hacl.Spec.SHA2.Equiv.fst.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.Serialize.fsti.chec... | [
"lemma"
] | [
"Spec.Hash.Definitions.sha2_alg",
"Hacl.Spec.SHA2.Vec.m_spec",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.SHA2.num_rounds16",
"Hacl.Spec.SHA2.Vec.ws_spec",
"Hacl.Spec.SHA2.Vec.state_spec",
"Hacl.Spec.SHA2.Vec.lanes",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
... | [] | module Hacl.Spec.SHA2.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.NTuple
open Lib.Sequence
open Lib.IntVector
open Lib.IntVector.Serialize
open Lib.LoopCombinators
open Spec.Hash.Definitions
open Hacl.Spec.SHA2.Vec
module Spec = Hacl.Spec.SHA2
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module Lemma... | false | false | Hacl.Spec.SHA2.Equiv.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_el... | null | val shuffle_inner_loop_lemma:
#a:sha2_alg
-> #m:m_spec
-> i:nat{i < Spec.num_rounds16 a}
-> ws0:ws_spec a m
-> st0:state_spec a m
-> l:nat{l < lanes a m}
-> n:nat{n <= 16} ->
Lemma
((state_spec_v (repeati n (shuffle_inner ws0 i) st0)).[l] ==
repeati n (Spec.shuffle_inner a (ws_spec_v ws0).[l]... | [
"recursion"
] | Hacl.Spec.SHA2.Equiv.shuffle_inner_loop_lemma | {
"file_name": "code/sha2-mb/Hacl.Spec.SHA2.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
i: Prims.nat{i < Hacl.Spec.SHA2.num_rounds16 a} ->
ws0: Hacl.Spec.SHA2.Vec.ws_spec a m ->
st0: Hacl.Spec.SHA2.Vec.state_spec a m ->
l: Prims.nat{l < Hacl.Spec.SHA2.Vec.lanes a m} ->
n: Prims.nat{n <= 16}
-> FStar.Pervasives.Lemma
(ensures
(Hacl.Spec.SHA2.Vec.state_spec_v (Lib.LoopCombin... | {
"end_col": 55,
"end_line": 232,
"start_col": 54,
"start_line": 216
} |
FStar.Pervasives.Lemma | val load_last_lemma_l:
#a:sha2_alg
-> #m:m_spec{is_supported a m}
-> totlen_seq:lseq uint8 (len_length a)
-> fin:nat{fin == block_length a \/ fin == 2 * block_length a}
-> len:nat{len <= block_length a}
-> b:multiseq (lanes a m) len
-> l:nat{l < lanes a m} ->
Lemma
(let (b0_v, b1_v) = load_last tot... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.SHA2.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"f... | false | let load_last_lemma_l #a #m totlen_seq fin len b l =
reveal_opaque (`%load_last) (load_last #a #m);
allow_inversion sha2_alg;
allow_inversion m_spec | val load_last_lemma_l:
#a:sha2_alg
-> #m:m_spec{is_supported a m}
-> totlen_seq:lseq uint8 (len_length a)
-> fin:nat{fin == block_length a \/ fin == 2 * block_length a}
-> len:nat{len <= block_length a}
-> b:multiseq (lanes a m) len
-> l:nat{l < lanes a m} ->
Lemma
(let (b0_v, b1_v) = load_last tot... | false | null | true | reveal_opaque (`%load_last) (load_last #a #m);
allow_inversion sha2_alg;
allow_inversion m_spec | {
"checked_file": "Hacl.Spec.SHA2.Equiv.fst.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.Serialize.fsti.chec... | [
"lemma"
] | [
"Spec.Hash.Definitions.sha2_alg",
"Hacl.Spec.SHA2.Vec.m_spec",
"Hacl.Spec.SHA2.Vec.is_supported",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Spec.Hash.Definitions.len_length",
"Prims.nat",
"Prims.l_or",
"Prims.eq2",
"Prims.int",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Prims.op_disEqual... | [] | module Hacl.Spec.SHA2.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.NTuple
open Lib.Sequence
open Lib.IntVector
open Lib.IntVector.Serialize
open Lib.LoopCombinators
open Spec.Hash.Definitions
open Hacl.Spec.SHA2.Vec
module Spec = Hacl.Spec.SHA2
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module Lemma... | false | false | Hacl.Spec.SHA2.Equiv.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_el... | null | val load_last_lemma_l:
#a:sha2_alg
-> #m:m_spec{is_supported a m}
-> totlen_seq:lseq uint8 (len_length a)
-> fin:nat{fin == block_length a \/ fin == 2 * block_length a}
-> len:nat{len <= block_length a}
-> b:multiseq (lanes a m) len
-> l:nat{l < lanes a m} ->
Lemma
(let (b0_v, b1_v) = load_last tot... | [] | Hacl.Spec.SHA2.Equiv.load_last_lemma_l | {
"file_name": "code/sha2-mb/Hacl.Spec.SHA2.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
totlen_seq: Lib.Sequence.lseq Lib.IntTypes.uint8 (Spec.Hash.Definitions.len_length a) ->
fin:
Prims.nat
{ fin == Spec.Hash.Definitions.block_length a \/
fin == 2 * Spec.Hash.Definitions.block_length a } ->
len: Prims.nat{len <= Spec.Hash.Definitions.block_length a} ->
b: Hacl.Sp... | {
"end_col": 24,
"end_line": 471,
"start_col": 2,
"start_line": 469
} |
FStar.Pervasives.Lemma | val load_blocks_lemma_ij:
#a:sha2_alg
-> #m:m_spec
-> b:multiblock_spec a m
-> j:nat{j < lanes a m}
-> i:nat{i < 16} ->
Lemma (let l = lanes a m in
let ind = (i / l * l + j) * word_length a in
(vec_v (load_blocks b).[i]).[j] ==
BSeq.uint_from_bytes_be
(Seq.slice b.(|i % l|) ind (ind + wo... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.SHA2.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"f... | false | let load_blocks_lemma_ij #a #m b j i =
let l = lanes a m in
let idx_i = i % l in
let idx_j = i / l in
let blocksize = word_length a in
let blocksize_l = l * blocksize in
let b_j = Seq.slice b.(|idx_i|) (idx_j * blocksize_l) (idx_j * blocksize_l + blocksize_l) in
//assert ((load_blocks b).[i] == vec_from... | val load_blocks_lemma_ij:
#a:sha2_alg
-> #m:m_spec
-> b:multiblock_spec a m
-> j:nat{j < lanes a m}
-> i:nat{i < 16} ->
Lemma (let l = lanes a m in
let ind = (i / l * l + j) * word_length a in
(vec_v (load_blocks b).[i]).[j] ==
BSeq.uint_from_bytes_be
(Seq.slice b.(|i % l|) ind (ind + wo... | false | null | true | let l = lanes a m in
let idx_i = i % l in
let idx_j = i / l in
let blocksize = word_length a in
let blocksize_l = l * blocksize in
let b_j = Seq.slice b.(| idx_i |) (idx_j * blocksize_l) (idx_j * blocksize_l + blocksize_l) in
assert (vec_v ((load_blocks b).[ i ]) == BSeq.uints_from_bytes_be b_j);
BSeq.index_uints_from_... | {
"checked_file": "Hacl.Spec.SHA2.Equiv.fst.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.Serialize.fsti.chec... | [
"lemma"
] | [
"Spec.Hash.Definitions.sha2_alg",
"Hacl.Spec.SHA2.Vec.m_spec",
"Hacl.Spec.SHA2.Vec.multiblock_spec",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.SHA2.Vec.lanes",
"Prims._assert",
"Prims.eq2",
"Lib.IntTypes.uint_t",
"Spec.Hash.Definitions.word_t",
"Lib.IntTypes.SEC",
"Lib.Sequen... | [] | module Hacl.Spec.SHA2.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.NTuple
open Lib.Sequence
open Lib.IntVector
open Lib.IntVector.Serialize
open Lib.LoopCombinators
open Spec.Hash.Definitions
open Hacl.Spec.SHA2.Vec
module Spec = Hacl.Spec.SHA2
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module Lemma... | false | false | Hacl.Spec.SHA2.Equiv.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_el... | null | val load_blocks_lemma_ij:
#a:sha2_alg
-> #m:m_spec
-> b:multiblock_spec a m
-> j:nat{j < lanes a m}
-> i:nat{i < 16} ->
Lemma (let l = lanes a m in
let ind = (i / l * l + j) * word_length a in
(vec_v (load_blocks b).[i]).[j] ==
BSeq.uint_from_bytes_be
(Seq.slice b.(|i % l|) ind (ind + wo... | [] | Hacl.Spec.SHA2.Equiv.load_blocks_lemma_ij | {
"file_name": "code/sha2-mb/Hacl.Spec.SHA2.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
b: Hacl.Spec.SHA2.Vec.multiblock_spec a m ->
j: Prims.nat{j < Hacl.Spec.SHA2.Vec.lanes a m} ->
i: Prims.nat{i < 16}
-> FStar.Pervasives.Lemma
(ensures
(let l = Hacl.Spec.SHA2.Vec.lanes a m in
let ind = ((i / l) * l + j) * Spec.Hash.Definitions.word_length a in
(Lib.IntVector.vec... | {
"end_col": 51,
"end_line": 344,
"start_col": 38,
"start_line": 315
} |
FStar.Pervasives.Lemma | val store_state_lemma_ij:
#a:sha2_alg
-> #m:m_spec{is_supported a m}
-> st:state_spec a m
-> j:nat{j < lanes a m}
-> i:nat{i < 8 * word_length a} ->
Lemma
((store_state st).[j * (8 * word_length a) + i] ==
(BSeq.uint_to_bytes_be (Seq.index (state_spec_v st).[j] (i / word_length a))).[i % word_lengt... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.SHA2.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"f... | false | let store_state_lemma_ij #a #m st j i =
let st1 = transpose_state st in
let j_v = j * (8 * word_length a) + i in
let blocksize_v = word_length a * lanes a m in
calc (==) { // j_v % blocksize_v / word_length a
(j * (8 * word_length a) + i) % blocksize_v / word_length a;
(==) { Math.Lemmas.modulo_divisio... | val store_state_lemma_ij:
#a:sha2_alg
-> #m:m_spec{is_supported a m}
-> st:state_spec a m
-> j:nat{j < lanes a m}
-> i:nat{i < 8 * word_length a} ->
Lemma
((store_state st).[j * (8 * word_length a) + i] ==
(BSeq.uint_to_bytes_be (Seq.index (state_spec_v st).[j] (i / word_length a))).[i % word_lengt... | false | null | true | let st1 = transpose_state st in
let j_v = j * (8 * word_length a) + i in
let blocksize_v = word_length a * lanes a m in
calc ( == ) {
(j * (8 * word_length a) + i) % blocksize_v / word_length a;
( == ) { Math.Lemmas.modulo_division_lemma (j * (8 * word_length a) + i)
(word_length a)
(lanes a m) }
(j * (8 ... | {
"checked_file": "Hacl.Spec.SHA2.Equiv.fst.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.Serialize.fsti.chec... | [
"lemma"
] | [
"Spec.Hash.Definitions.sha2_alg",
"Hacl.Spec.SHA2.Vec.m_spec",
"Hacl.Spec.SHA2.Vec.is_supported",
"Hacl.Spec.SHA2.Vec.state_spec",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.SHA2.Vec.lanes",
"FStar.Mul.op_Star",
"Spec.Hash.Definitions.word_length",
"FStar.Calc.calc_finish",
"Lib... | [] | module Hacl.Spec.SHA2.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.NTuple
open Lib.Sequence
open Lib.IntVector
open Lib.IntVector.Serialize
open Lib.LoopCombinators
open Spec.Hash.Definitions
open Hacl.Spec.SHA2.Vec
module Spec = Hacl.Spec.SHA2
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module Lemma... | false | false | Hacl.Spec.SHA2.Equiv.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_el... | null | val store_state_lemma_ij:
#a:sha2_alg
-> #m:m_spec{is_supported a m}
-> st:state_spec a m
-> j:nat{j < lanes a m}
-> i:nat{i < 8 * word_length a} ->
Lemma
((store_state st).[j * (8 * word_length a) + i] ==
(BSeq.uint_to_bytes_be (Seq.index (state_spec_v st).[j] (i / word_length a))).[i % word_lengt... | [] | Hacl.Spec.SHA2.Equiv.store_state_lemma_ij | {
"file_name": "code/sha2-mb/Hacl.Spec.SHA2.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
st: Hacl.Spec.SHA2.Vec.state_spec a m ->
j: Prims.nat{j < Hacl.Spec.SHA2.Vec.lanes a m} ->
i: Prims.nat{i < 8 * Spec.Hash.Definitions.word_length a}
-> FStar.Pervasives.Lemma
(ensures
(Hacl.Spec.SHA2.Vec.store_state st).[ j * (8 * Spec.Hash.Definitions.word_length a) + i ] ==
(Lib.ByteSeq... | {
"end_col": 5,
"end_line": 545,
"start_col": 39,
"start_line": 507
} |
FStar.Pervasives.Lemma | val ws_next_inner_lemma_l:
#a:sha2_alg
-> #m:m_spec
-> i:nat{i < 16}
-> ws:ws_spec a m
-> l:nat{l < lanes a m} ->
Lemma ((ws_spec_v (ws_next_inner i ws)).[l] == Spec.ws_next_inner a i (ws_spec_v ws).[l]) | [
{
"abbrev": true,
"full_module": "Hacl.Spec.SHA2.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"f... | false | let ws_next_inner_lemma_l #a #m i ws l =
eq_intro #(word a) #16
(ws_spec_v (ws_next_inner i ws)).[l]
(Spec.ws_next_inner a i (ws_spec_v ws).[l]) | val ws_next_inner_lemma_l:
#a:sha2_alg
-> #m:m_spec
-> i:nat{i < 16}
-> ws:ws_spec a m
-> l:nat{l < lanes a m} ->
Lemma ((ws_spec_v (ws_next_inner i ws)).[l] == Spec.ws_next_inner a i (ws_spec_v ws).[l])
let ws_next_inner_lemma_l #a #m i ws l = | false | null | true | eq_intro #(word a)
#16
(ws_spec_v (ws_next_inner i ws)).[ l ]
(Spec.ws_next_inner a i (ws_spec_v ws).[ l ]) | {
"checked_file": "Hacl.Spec.SHA2.Equiv.fst.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.Serialize.fsti.chec... | [
"lemma"
] | [
"Spec.Hash.Definitions.sha2_alg",
"Hacl.Spec.SHA2.Vec.m_spec",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.SHA2.Vec.ws_spec",
"Hacl.Spec.SHA2.Vec.lanes",
"Lib.Sequence.eq_intro",
"Hacl.Spec.SHA2.Vec.word",
"Lib.Sequence.op_String_Access",
"Lib.Sequence.lseq",
"Hacl.Spec.SHA2.Vec.... | [] | module Hacl.Spec.SHA2.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.NTuple
open Lib.Sequence
open Lib.IntVector
open Lib.IntVector.Serialize
open Lib.LoopCombinators
open Spec.Hash.Definitions
open Hacl.Spec.SHA2.Vec
module Spec = Hacl.Spec.SHA2
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module Lemma... | false | false | Hacl.Spec.SHA2.Equiv.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_el... | null | val ws_next_inner_lemma_l:
#a:sha2_alg
-> #m:m_spec
-> i:nat{i < 16}
-> ws:ws_spec a m
-> l:nat{l < lanes a m} ->
Lemma ((ws_spec_v (ws_next_inner i ws)).[l] == Spec.ws_next_inner a i (ws_spec_v ws).[l]) | [] | Hacl.Spec.SHA2.Equiv.ws_next_inner_lemma_l | {
"file_name": "code/sha2-mb/Hacl.Spec.SHA2.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
i: Prims.nat{i < 16} ->
ws: Hacl.Spec.SHA2.Vec.ws_spec a m ->
l: Prims.nat{l < Hacl.Spec.SHA2.Vec.lanes a m}
-> FStar.Pervasives.Lemma
(ensures
(Hacl.Spec.SHA2.Vec.ws_spec_v (Hacl.Spec.SHA2.Vec.ws_next_inner i ws)).[ l ] ==
Hacl.Spec.SHA2.ws_next_inner a i (Hacl.Spec.SHA2.Vec.ws_spec_v ws... | {
"end_col": 47,
"end_line": 142,
"start_col": 2,
"start_line": 140
} |
FStar.Pervasives.Lemma | val load_ws_lemma_l:
#a:sha2_alg
-> #m:m_spec{is_supported a m}
-> b:multiblock_spec a m
-> j:nat{j < lanes a m} ->
Lemma ((ws_spec_v (load_ws b)).[j] == BSeq.uints_from_bytes_be #(word_t a) #SEC #(block_word_length a) b.(|j|)) | [
{
"abbrev": true,
"full_module": "Hacl.Spec.SHA2.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"f... | false | let load_ws_lemma_l #a #m b j =
let lp = Seq.index (ws_spec_v (load_ws b)) j in
let rp = BSeq.uints_from_bytes_be #(word_t a) #SEC #16 b.(|j|) in
let aux (i:nat{i < 16}) : Lemma (Seq.index lp i == Seq.index rp i) =
let l = lanes a m in
BSeq.index_uints_from_bytes_be #(word_t a) #SEC #16 b.(|j|) i;
as... | val load_ws_lemma_l:
#a:sha2_alg
-> #m:m_spec{is_supported a m}
-> b:multiblock_spec a m
-> j:nat{j < lanes a m} ->
Lemma ((ws_spec_v (load_ws b)).[j] == BSeq.uints_from_bytes_be #(word_t a) #SEC #(block_word_length a) b.(|j|))
let load_ws_lemma_l #a #m b j = | false | null | true | let lp = Seq.index (ws_spec_v (load_ws b)) j in
let rp = BSeq.uints_from_bytes_be #(word_t a) #SEC #16 b.(| j |) in
let aux (i: nat{i < 16}) : Lemma (Seq.index lp i == Seq.index rp i) =
let l = lanes a m in
BSeq.index_uints_from_bytes_be #(word_t a) #SEC #16 b.(| j |) i;
assert (Seq.index rp i ==
BSeq.uint_... | {
"checked_file": "Hacl.Spec.SHA2.Equiv.fst.checked",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NTuple.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.Serialize.fsti.chec... | [
"lemma"
] | [
"Spec.Hash.Definitions.sha2_alg",
"Hacl.Spec.SHA2.Vec.m_spec",
"Hacl.Spec.SHA2.Vec.is_supported",
"Hacl.Spec.SHA2.Vec.multiblock_spec",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.SHA2.Vec.lanes",
"Lib.Sequence.eq_intro",
"Hacl.Spec.SHA2.Vec.word",
"Prims.unit",
"FStar.Classical.... | [] | module Hacl.Spec.SHA2.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.NTuple
open Lib.Sequence
open Lib.IntVector
open Lib.IntVector.Serialize
open Lib.LoopCombinators
open Spec.Hash.Definitions
open Hacl.Spec.SHA2.Vec
module Spec = Hacl.Spec.SHA2
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module Lemma... | false | false | Hacl.Spec.SHA2.Equiv.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_el... | null | val load_ws_lemma_l:
#a:sha2_alg
-> #m:m_spec{is_supported a m}
-> b:multiblock_spec a m
-> j:nat{j < lanes a m} ->
Lemma ((ws_spec_v (load_ws b)).[j] == BSeq.uints_from_bytes_be #(word_t a) #SEC #(block_word_length a) b.(|j|)) | [] | Hacl.Spec.SHA2.Equiv.load_ws_lemma_l | {
"file_name": "code/sha2-mb/Hacl.Spec.SHA2.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b: Hacl.Spec.SHA2.Vec.multiblock_spec a m -> j: Prims.nat{j < Hacl.Spec.SHA2.Vec.lanes a m}
-> FStar.Pervasives.Lemma
(ensures
(Hacl.Spec.SHA2.Vec.ws_spec_v (Hacl.Spec.SHA2.Vec.load_ws b)).[ j ] ==
Lib.ByteSequence.uints_from_bytes_be (( .(||) ) b j)) | {
"end_col": 16,
"end_line": 415,
"start_col": 31,
"start_line": 400
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let size_key = 32 | let size_key = | false | null | false | 32 | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [] | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100" | false | true | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val size_key : Prims.int | [] | Spec.Salsa20.size_key | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.int | {
"end_col": 17,
"end_line": 13,
"start_col": 15,
"start_line": 13
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let size_block = 64 | let size_block = | false | null | false | 64 | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [] | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *) | false | true | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val size_block : Prims.int | [] | Spec.Salsa20.size_block | {
"file_name": "specs/Spec.Salsa20.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": 14,
"start_col": 17,
"start_line": 14
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let op_At f g = fun x -> g (f x) | let op_At f g = | false | null | false | fun x -> g (f x) | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [] | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *)
let size_block = 64 (* in bytes *)
let size_nonce = 8 (* in bytes *)
let size_xnonc... | false | false | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val op_At : f: (_: _ -> _) -> g: (_: _ -> _) -> x: _ -> _ | [] | Spec.Salsa20.op_At | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: (_: _ -> _) -> g: (_: _ -> _) -> x: _ -> _ | {
"end_col": 32,
"end_line": 29,
"start_col": 16,
"start_line": 29
} | |
Prims.Tot | val rounds:shuffle | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let rounds : shuffle =
repeat 10 double_round | val rounds:shuffle
let rounds:shuffle = | false | null | false | repeat 10 double_round | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [
"Lib.LoopCombinators.repeat",
"Spec.Salsa20.state",
"Spec.Salsa20.double_round"
] | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *)
let size_block = 64 (* in bytes *)
let size_nonce = 8 (* in bytes *)
let size_xnonc... | false | true | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val rounds:shuffle | [] | Spec.Salsa20.rounds | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Spec.Salsa20.shuffle | {
"end_col": 24,
"end_line": 58,
"start_col": 2,
"start_line": 58
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let size_nonce = 8 | let size_nonce = | false | null | false | 8 | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [] | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *) | false | true | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val size_nonce : Prims.int | [] | Spec.Salsa20.size_nonce | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.int | {
"end_col": 18,
"end_line": 15,
"start_col": 17,
"start_line": 15
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let size_xnonce = 16 | let size_xnonce = | false | null | false | 16 | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [] | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *)
let size_block = 64 (* in bytes *) | false | true | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val size_xnonce : Prims.int | [] | Spec.Salsa20.size_xnonce | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.int | {
"end_col": 20,
"end_line": 16,
"start_col": 18,
"start_line": 16
} | |
Prims.Tot | val double_round:shuffle | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let double_round: shuffle =
column_round @ row_round | val double_round:shuffle
let double_round:shuffle = | false | null | false | column_round @ row_round | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [
"Spec.Salsa20.op_At",
"Spec.Salsa20.state",
"Spec.Salsa20.column_round",
"Spec.Salsa20.row_round"
] | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *)
let size_block = 64 (* in bytes *)
let size_nonce = 8 (* in bytes *)
let size_xnonc... | false | true | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val double_round:shuffle | [] | Spec.Salsa20.double_round | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Spec.Salsa20.shuffle | {
"end_col": 26,
"end_line": 55,
"start_col": 2,
"start_line": 55
} |
Prims.Tot | val salsa20_encrypt_block (st0: state) (incr: counter) (b: block) : Tot block | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let salsa20_encrypt_block (st0:state) (incr:counter) (b:block) : Tot block =
let k = salsa20_core incr st0 in
xor_block k b | val salsa20_encrypt_block (st0: state) (incr: counter) (b: block) : Tot block
let salsa20_encrypt_block (st0: state) (incr: counter) (b: block) : Tot block = | false | null | false | let k = salsa20_core incr st0 in
xor_block k b | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [
"Spec.Salsa20.state",
"Spec.Salsa20.counter",
"Spec.Salsa20.block",
"Spec.Salsa20.xor_block",
"Spec.Salsa20.salsa20_core"
] | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *)
let size_block = 64 (* in bytes *)
let size_nonce = 8 (* in bytes *)
let size_xnonc... | false | true | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val salsa20_encrypt_block (st0: state) (incr: counter) (b: block) : Tot block | [] | Spec.Salsa20.salsa20_encrypt_block | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | st0: Spec.Salsa20.state -> incr: Spec.Salsa20.counter -> b: Spec.Salsa20.block -> Spec.Salsa20.block | {
"end_col": 15,
"end_line": 140,
"start_col": 76,
"start_line": 138
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let constant1 = u32 0x3320646e | let constant1 = | false | null | false | u32 0x3320646e | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [
"Lib.IntTypes.u32"
] | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *)
let size_block = 64 (* in bytes *)
let size_nonce = 8 (* in bytes *)
let size_xnonc... | false | false | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val constant1 : u19: Lib.IntTypes.uint32{Lib.IntTypes.v u19 == 0x3320646e} | [] | Spec.Salsa20.constant1 | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | u19: Lib.IntTypes.uint32{Lib.IntTypes.v u19 == 0x3320646e} | {
"end_col": 30,
"end_line": 73,
"start_col": 16,
"start_line": 73
} | |
Prims.Tot | val salsa20_core (ctr: counter) (s: state) : Tot state | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let salsa20_core (ctr:counter) (s:state) : Tot state =
let s' = salsa20_add_counter s ctr in
let s' = rounds s' in
let s' = map2 (+.) s' s in
salsa20_add_counter s' ctr | val salsa20_core (ctr: counter) (s: state) : Tot state
let salsa20_core (ctr: counter) (s: state) : Tot state = | false | null | false | let s' = salsa20_add_counter s ctr in
let s' = rounds s' in
let s' = map2 ( +. ) s' s in
salsa20_add_counter s' ctr | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [
"Spec.Salsa20.counter",
"Spec.Salsa20.state",
"Spec.Salsa20.salsa20_add_counter",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.SEC",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.eq2",
"Lib.Sequence.index",
"Lib.Int... | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *)
let size_block = 64 (* in bytes *)
let size_nonce = 8 (* in bytes *)
let size_xnonc... | false | true | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val salsa20_core (ctr: counter) (s: state) : Tot state | [] | Spec.Salsa20.salsa20_core | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | ctr: Spec.Salsa20.counter -> s: Spec.Salsa20.state -> Spec.Salsa20.state | {
"end_col": 28,
"end_line": 67,
"start_col": 54,
"start_line": 63
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let constant2 = u32 0x79622d32 | let constant2 = | false | null | false | u32 0x79622d32 | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [
"Lib.IntTypes.u32"
] | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *)
let size_block = 64 (* in bytes *)
let size_nonce = 8 (* in bytes *)
let size_xnonc... | false | false | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val constant2 : u19: Lib.IntTypes.uint32{Lib.IntTypes.v u19 == 0x79622d32} | [] | Spec.Salsa20.constant2 | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | u19: Lib.IntTypes.uint32{Lib.IntTypes.v u19 == 0x79622d32} | {
"end_col": 30,
"end_line": 75,
"start_col": 16,
"start_line": 75
} | |
Prims.Tot | val salsa20_init (k: key) (n: nonce) (ctr0: counter) : Tot state | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let salsa20_init (k:key) (n:nonce) (ctr0:counter) : Tot state =
let st = create 16 (u32 0) in
let st = setup k n ctr0 st in
st | val salsa20_init (k: key) (n: nonce) (ctr0: counter) : Tot state
let salsa20_init (k: key) (n: nonce) (ctr0: counter) : Tot state = | false | null | false | let st = create 16 (u32 0) in
let st = setup k n ctr0 st in
st | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [
"Spec.Salsa20.key",
"Spec.Salsa20.nonce",
"Spec.Salsa20.counter",
"Spec.Salsa20.state",
"Spec.Salsa20.setup",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.SEC",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.create",... | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *)
let size_block = 64 (* in bytes *)
let size_nonce = 8 (* in bytes *)
let size_xnonc... | false | true | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val salsa20_init (k: key) (n: nonce) (ctr0: counter) : Tot state | [] | Spec.Salsa20.salsa20_init | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | k: Spec.Salsa20.key -> n: Spec.Salsa20.nonce -> ctr0: Spec.Salsa20.counter -> Spec.Salsa20.state | {
"end_col": 4,
"end_line": 97,
"start_col": 63,
"start_line": 94
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let constant0 = u32 0x61707865 | let constant0 = | false | null | false | u32 0x61707865 | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [
"Lib.IntTypes.u32"
] | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *)
let size_block = 64 (* in bytes *)
let size_nonce = 8 (* in bytes *)
let size_xnonc... | false | false | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val constant0 : u19: Lib.IntTypes.uint32{Lib.IntTypes.v u19 == 0x61707865} | [] | Spec.Salsa20.constant0 | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | u19: Lib.IntTypes.uint32{Lib.IntTypes.v u19 == 0x61707865} | {
"end_col": 30,
"end_line": 71,
"start_col": 16,
"start_line": 71
} | |
Prims.Tot | val salsa20_key_block0 (k: key) (n: nonce) : Tot block | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let salsa20_key_block0 (k:key) (n:nonce) : Tot block =
let st = salsa20_init k n 0 in
salsa20_key_block st | val salsa20_key_block0 (k: key) (n: nonce) : Tot block
let salsa20_key_block0 (k: key) (n: nonce) : Tot block = | false | null | false | let st = salsa20_init k n 0 in
salsa20_key_block st | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [
"Spec.Salsa20.key",
"Spec.Salsa20.nonce",
"Spec.Salsa20.salsa20_key_block",
"Spec.Salsa20.state",
"Spec.Salsa20.salsa20_init",
"Spec.Salsa20.block"
] | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *)
let size_block = 64 (* in bytes *)
let size_nonce = 8 (* in bytes *)
let size_xnonc... | false | true | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val salsa20_key_block0 (k: key) (n: nonce) : Tot block | [] | Spec.Salsa20.salsa20_key_block0 | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | k: Spec.Salsa20.key -> n: Spec.Salsa20.nonce -> Spec.Salsa20.block | {
"end_col": 22,
"end_line": 131,
"start_col": 54,
"start_line": 129
} |
Prims.Tot | val xor_block (k: state) (b: block) : block | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let xor_block (k:state) (b:block) : block =
let ib = uints_from_bytes_le b in
let ob = map2 (^.) ib k in
uints_to_bytes_le ob | val xor_block (k: state) (b: block) : block
let xor_block (k: state) (b: block) : block = | false | null | false | let ib = uints_from_bytes_le b in
let ob = map2 ( ^. ) ib k in
uints_to_bytes_le ob | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [
"Spec.Salsa20.state",
"Spec.Salsa20.block",
"Lib.ByteSequence.uints_to_bytes_le",
"Lib.IntTypes.U32",
"Lib.IntTypes.SEC",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.eq2",
"Lib.Sequence.index",
"Lib.Int... | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *)
let size_block = 64 (* in bytes *)
let size_nonce = 8 (* in bytes *)
let size_xnonc... | false | true | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val xor_block (k: state) (b: block) : block | [] | Spec.Salsa20.xor_block | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | k: Spec.Salsa20.state -> b: Spec.Salsa20.block -> Spec.Salsa20.block | {
"end_col": 22,
"end_line": 136,
"start_col": 44,
"start_line": 133
} |
Prims.Tot | val row_round:shuffle | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let row_round : shuffle =
quarter_round 0 1 2 3 @
quarter_round 5 6 7 4 @
quarter_round 10 11 8 9 @
quarter_round 15 12 13 14 | val row_round:shuffle
let row_round:shuffle = | false | null | false | quarter_round 0 1 2 3 @ quarter_round 5 6 7 4 @ quarter_round 10 11 8 9 @ quarter_round 15 12 13 14 | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [
"Spec.Salsa20.op_At",
"Spec.Salsa20.state",
"Spec.Salsa20.quarter_round"
] | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *)
let size_block = 64 (* in bytes *)
let size_nonce = 8 (* in bytes *)
let size_xnonc... | false | true | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val row_round:shuffle | [] | Spec.Salsa20.row_round | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Spec.Salsa20.shuffle | {
"end_col": 27,
"end_line": 52,
"start_col": 2,
"start_line": 49
} |
Prims.Tot | val hsalsa20_init (k: key) (n: xnonce) : Tot state | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let hsalsa20_init (k:key) (n:xnonce) : Tot state =
let st = create 16 (u32 0) in
let st = xsetup k n st in
st | val hsalsa20_init (k: key) (n: xnonce) : Tot state
let hsalsa20_init (k: key) (n: xnonce) : Tot state = | false | null | false | let st = create 16 (u32 0) in
let st = xsetup k n st in
st | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [
"Spec.Salsa20.key",
"Spec.Salsa20.xnonce",
"Spec.Salsa20.state",
"Spec.Salsa20.xsetup",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.SEC",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int"... | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *)
let size_block = 64 (* in bytes *)
let size_nonce = 8 (* in bytes *)
let size_xnonc... | false | true | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val hsalsa20_init (k: key) (n: xnonce) : Tot state | [] | Spec.Salsa20.hsalsa20_init | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | k: Spec.Salsa20.key -> n: Spec.Salsa20.xnonce -> Spec.Salsa20.state | {
"end_col": 4,
"end_line": 114,
"start_col": 50,
"start_line": 111
} |
Prims.Tot | val salsa20_add_counter (s: state) (ctr: counter) : Tot state | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let salsa20_add_counter (s:state) (ctr:counter) : Tot state =
s.[8] <- s.[8] +. (u32 ctr) | val salsa20_add_counter (s: state) (ctr: counter) : Tot state
let salsa20_add_counter (s: state) (ctr: counter) : Tot state = | false | null | false | s.[ 8 ] <- s.[ 8 ] +. (u32 ctr) | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [
"Spec.Salsa20.state",
"Spec.Salsa20.counter",
"Lib.Sequence.op_String_Assignment",
"Lib.IntTypes.uint32",
"Lib.IntTypes.op_Plus_Dot",
"Lib.IntTypes.U32",
"Lib.IntTypes.SEC",
"Lib.Sequence.op_String_Access",
"Lib.IntTypes.u32"
] | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *)
let size_block = 64 (* in bytes *)
let size_nonce = 8 (* in bytes *)
let size_xnonc... | false | true | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val salsa20_add_counter (s: state) (ctr: counter) : Tot state | [] | Spec.Salsa20.salsa20_add_counter | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Spec.Salsa20.state -> ctr: Spec.Salsa20.counter -> Spec.Salsa20.state | {
"end_col": 29,
"end_line": 61,
"start_col": 2,
"start_line": 61
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let constant3 = u32 0x6b206574 | let constant3 = | false | null | false | u32 0x6b206574 | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [
"Lib.IntTypes.u32"
] | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *)
let size_block = 64 (* in bytes *)
let size_nonce = 8 (* in bytes *)
let size_xnonc... | false | false | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val constant3 : u19: Lib.IntTypes.uint32{Lib.IntTypes.v u19 == 0x6b206574} | [] | Spec.Salsa20.constant3 | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | u19: Lib.IntTypes.uint32{Lib.IntTypes.v u19 == 0x6b206574} | {
"end_col": 30,
"end_line": 77,
"start_col": 16,
"start_line": 77
} | |
Prims.Tot | val line (a b d: idx) (s: rotval U32) (m: state) : state | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let line (a:idx) (b:idx) (d:idx) (s:rotval U32) (m:state) : state =
let m = m.[a] <- (m.[a] ^. ((m.[b] +. m.[d]) <<<. s)) in
m | val line (a b d: idx) (s: rotval U32) (m: state) : state
let line (a b d: idx) (s: rotval U32) (m: state) : state = | false | null | false | let m = m.[ a ] <- (m.[ a ] ^. ((m.[ b ] +. m.[ d ]) <<<. s)) in
m | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [
"Spec.Salsa20.idx",
"Lib.IntTypes.rotval",
"Lib.IntTypes.U32",
"Spec.Salsa20.state",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.SEC",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.upd",
"Lib.IntTypes.logxor",
"Lib.Sequence.index",
... | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *)
let size_block = 64 (* in bytes *)
let size_nonce = 8 (* in bytes *)
let size_xnonc... | false | true | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val line (a b d: idx) (s: rotval U32) (m: state) : state | [] | Spec.Salsa20.line | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Spec.Salsa20.idx ->
b: Spec.Salsa20.idx ->
d: Spec.Salsa20.idx ->
s: Lib.IntTypes.rotval Lib.IntTypes.U32 ->
m: Spec.Salsa20.state
-> Spec.Salsa20.state | {
"end_col": 3,
"end_line": 34,
"start_col": 67,
"start_line": 32
} |
Prims.Tot | val column_round:shuffle | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let column_round : shuffle =
quarter_round 0 4 8 12 @
quarter_round 5 9 13 1 @
quarter_round 10 14 2 6 @
quarter_round 15 3 7 11 | val column_round:shuffle
let column_round:shuffle = | false | null | false | quarter_round 0 4 8 12 @ quarter_round 5 9 13 1 @ quarter_round 10 14 2 6 @ quarter_round 15 3 7 11 | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [
"Spec.Salsa20.op_At",
"Spec.Salsa20.state",
"Spec.Salsa20.quarter_round"
] | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *)
let size_block = 64 (* in bytes *)
let size_nonce = 8 (* in bytes *)
let size_xnonc... | false | true | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val column_round:shuffle | [] | Spec.Salsa20.column_round | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Spec.Salsa20.shuffle | {
"end_col": 25,
"end_line": 46,
"start_col": 2,
"start_line": 43
} |
Prims.Tot | val salsa20_encrypt_bytes:
k: key
-> n: nonce
-> c: counter
-> msg: bytes{length msg / size_block <= max_size_t}
-> cipher: bytes{length cipher == length msg} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let salsa20_encrypt_bytes key nonce ctr0 msg =
let st0 = salsa20_init key nonce ctr0 in
salsa20_update st0 msg | val salsa20_encrypt_bytes:
k: key
-> n: nonce
-> c: counter
-> msg: bytes{length msg / size_block <= max_size_t}
-> cipher: bytes{length cipher == length msg}
let salsa20_encrypt_bytes key nonce ctr0 msg = | false | null | false | let st0 = salsa20_init key nonce ctr0 in
salsa20_update st0 msg | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [
"Spec.Salsa20.key",
"Spec.Salsa20.nonce",
"Spec.Salsa20.counter",
"Lib.ByteSequence.bytes",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Division",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.Salsa20.size_block",
"Lib.IntTypes.max_size_t",... | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *)
let size_block = 64 (* in bytes *)
let size_nonce = 8 (* in bytes *)
let size_xnonc... | false | false | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val salsa20_encrypt_bytes:
k: key
-> n: nonce
-> c: counter
-> msg: bytes{length msg / size_block <= max_size_t}
-> cipher: bytes{length cipher == length msg} | [] | Spec.Salsa20.salsa20_encrypt_bytes | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k: Spec.Salsa20.key ->
n: Spec.Salsa20.nonce ->
c: Spec.Salsa20.counter ->
msg:
Lib.ByteSequence.bytes
{Lib.Sequence.length msg / Spec.Salsa20.size_block <= Lib.IntTypes.max_size_t}
-> cipher: Lib.ByteSequence.bytes{Lib.Sequence.length cipher == Lib.Sequence.length msg} | {
"end_col": 24,
"end_line": 171,
"start_col": 46,
"start_line": 169
} |
Prims.Tot | val salsa20_key_block (st: state) : Tot block | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let salsa20_key_block (st:state) : Tot block =
let st' = salsa20_core 0 st in
uints_to_bytes_le st' | val salsa20_key_block (st: state) : Tot block
let salsa20_key_block (st: state) : Tot block = | false | null | false | let st' = salsa20_core 0 st in
uints_to_bytes_le st' | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [
"Spec.Salsa20.state",
"Lib.ByteSequence.uints_to_bytes_le",
"Lib.IntTypes.U32",
"Lib.IntTypes.SEC",
"Spec.Salsa20.salsa20_core",
"Spec.Salsa20.block"
] | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *)
let size_block = 64 (* in bytes *)
let size_nonce = 8 (* in bytes *)
let size_xnonc... | false | true | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val salsa20_key_block (st: state) : Tot block | [] | Spec.Salsa20.salsa20_key_block | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | st: Spec.Salsa20.state -> Spec.Salsa20.block | {
"end_col": 23,
"end_line": 127,
"start_col": 46,
"start_line": 125
} |
Prims.Tot | val salsa20_decrypt_bytes:
k: key
-> n: nonce
-> c: counter
-> cipher: bytes{length cipher / size_block <= max_size_t}
-> msg: bytes{length cipher == length msg} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let salsa20_decrypt_bytes key nonce ctr0 cipher =
let st0 = salsa20_init key nonce ctr0 in
salsa20_update st0 cipher | val salsa20_decrypt_bytes:
k: key
-> n: nonce
-> c: counter
-> cipher: bytes{length cipher / size_block <= max_size_t}
-> msg: bytes{length cipher == length msg}
let salsa20_decrypt_bytes key nonce ctr0 cipher = | false | null | false | let st0 = salsa20_init key nonce ctr0 in
salsa20_update st0 cipher | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [
"Spec.Salsa20.key",
"Spec.Salsa20.nonce",
"Spec.Salsa20.counter",
"Lib.ByteSequence.bytes",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Division",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.Salsa20.size_block",
"Lib.IntTypes.max_size_t",... | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *)
let size_block = 64 (* in bytes *)
let size_nonce = 8 (* in bytes *)
let size_xnonc... | false | false | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val salsa20_decrypt_bytes:
k: key
-> n: nonce
-> c: counter
-> cipher: bytes{length cipher / size_block <= max_size_t}
-> msg: bytes{length cipher == length msg} | [] | Spec.Salsa20.salsa20_decrypt_bytes | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k: Spec.Salsa20.key ->
n: Spec.Salsa20.nonce ->
c: Spec.Salsa20.counter ->
cipher:
Lib.ByteSequence.bytes
{Lib.Sequence.length cipher / Spec.Salsa20.size_block <= Lib.IntTypes.max_size_t}
-> msg: Lib.ByteSequence.bytes{Lib.Sequence.length cipher == Lib.Sequence.length msg} | {
"end_col": 27,
"end_line": 183,
"start_col": 49,
"start_line": 181
} |
Prims.Tot | val salsa20_encrypt_last
(st0: state)
(incr: counter)
(len: size_nat{len < size_block})
(b: lbytes len)
: lbytes len | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let salsa20_encrypt_last (st0:state) (incr:counter)
(len:size_nat{len < size_block})
(b:lbytes len) : lbytes len =
let plain = create size_block (u8 0) in
let plain = update_sub plain 0 (length b) b in
let cipher = salsa20_encrypt_block st0 incr plain in
sub cipher 0 len | val salsa20_encrypt_last
(st0: state)
(incr: counter)
(len: size_nat{len < size_block})
(b: lbytes len)
: lbytes len
let salsa20_encrypt_last
(st0: state)
(incr: counter)
(len: size_nat{len < size_block})
(b: lbytes len)
: lbytes len = | false | null | false | let plain = create size_block (u8 0) in
let plain = update_sub plain 0 (length b) b in
let cipher = salsa20_encrypt_block st0 incr plain in
sub cipher 0 len | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [
"Spec.Salsa20.state",
"Spec.Salsa20.counter",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThan",
"Spec.Salsa20.size_block",
"Lib.ByteSequence.lbytes",
"Lib.Sequence.sub",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.Salsa20.block",
"Spec.Salsa20.salsa20_encrypt... | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *)
let size_block = 64 (* in bytes *)
let size_nonce = 8 (* in bytes *)
let size_xnonc... | false | false | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val salsa20_encrypt_last
(st0: state)
(incr: counter)
(len: size_nat{len < size_block})
(b: lbytes len)
: lbytes len | [] | Spec.Salsa20.salsa20_encrypt_last | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
st0: Spec.Salsa20.state ->
incr: Spec.Salsa20.counter ->
len: Lib.IntTypes.size_nat{len < Spec.Salsa20.size_block} ->
b: Lib.ByteSequence.lbytes len
-> Lib.ByteSequence.lbytes len | {
"end_col": 18,
"end_line": 148,
"start_col": 34,
"start_line": 144
} |
Prims.Tot | val salsa20_update:
ctx: state
-> msg: bytes{length msg / size_block <= max_size_t}
-> cipher: bytes{length cipher == length msg} | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let salsa20_update ctx msg =
let cipher = msg in
map_blocks size_block cipher
(salsa20_encrypt_block ctx)
(salsa20_encrypt_last ctx) | val salsa20_update:
ctx: state
-> msg: bytes{length msg / size_block <= max_size_t}
-> cipher: bytes{length cipher == length msg}
let salsa20_update ctx msg = | false | null | false | let cipher = msg in
map_blocks size_block cipher (salsa20_encrypt_block ctx) (salsa20_encrypt_last ctx) | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [
"Spec.Salsa20.state",
"Lib.ByteSequence.bytes",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Division",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.Salsa20.size_block",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.map_blocks",
"Spec.Salsa20.sa... | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *)
let size_block = 64 (* in bytes *)
let size_nonce = 8 (* in bytes *)
let size_xnonc... | false | false | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val salsa20_update:
ctx: state
-> msg: bytes{length msg / size_block <= max_size_t}
-> cipher: bytes{length cipher == length msg} | [] | Spec.Salsa20.salsa20_update | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
ctx: Spec.Salsa20.state ->
msg:
Lib.ByteSequence.bytes
{Lib.Sequence.length msg / Spec.Salsa20.size_block <= Lib.IntTypes.max_size_t}
-> cipher: Lib.ByteSequence.bytes{Lib.Sequence.length cipher == Lib.Sequence.length msg} | {
"end_col": 30,
"end_line": 159,
"start_col": 28,
"start_line": 155
} |
Prims.Tot | val hsalsa20 (k: key) (n: xnonce) : Tot (lbytes 32) | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let hsalsa20 (k:key) (n:xnonce) : Tot (lbytes 32) =
let st = hsalsa20_init k n in
let st = rounds st in
[@inline_let]
let res_l = [st.[0]; st.[5]; st.[10]; st.[15]; st.[6]; st.[7]; st.[8]; st.[9]] in
assert_norm(List.Tot.length res_l == 8);
let res = createL res_l in
uints_to_bytes_le res | val hsalsa20 (k: key) (n: xnonce) : Tot (lbytes 32)
let hsalsa20 (k: key) (n: xnonce) : Tot (lbytes 32) = | false | null | false | let st = hsalsa20_init k n in
let st = rounds st in
[@@ inline_let ]let res_l =
[st.[ 0 ]; st.[ 5 ]; st.[ 10 ]; st.[ 15 ]; st.[ 6 ]; st.[ 7 ]; st.[ 8 ]; st.[ 9 ]]
in
assert_norm (List.Tot.length res_l == 8);
let res = createL res_l in
uints_to_bytes_le res | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [
"Spec.Salsa20.key",
"Spec.Salsa20.xnonce",
"Lib.ByteSequence.uints_to_bytes_le",
"Lib.IntTypes.U32",
"Lib.IntTypes.SEC",
"FStar.List.Tot.Base.length",
"Lib.IntTypes.uint_t",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Proper... | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *)
let size_block = 64 (* in bytes *)
let size_nonce = 8 (* in bytes *)
let size_xnonc... | false | false | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val hsalsa20 (k: key) (n: xnonce) : Tot (lbytes 32) | [] | Spec.Salsa20.hsalsa20 | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | k: Spec.Salsa20.key -> n: Spec.Salsa20.xnonce -> Lib.ByteSequence.lbytes 32 | {
"end_col": 23,
"end_line": 123,
"start_col": 51,
"start_line": 116
} |
Prims.Tot | val xsetup (k: key) (n: xnonce) (st: state) : Tot state | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let xsetup (k:key) (n:xnonce) (st:state) : Tot state =
let ks = uints_from_bytes_le #U32 #SEC #8 k in
let ns = uints_from_bytes_le #U32 #SEC #4 n in
let st = st.[0] <- constant0 in
let st = update_sub st 1 4 (slice ks 0 4) in
let st = st.[5] <- constant1 in
let st = update_sub st 6 4 ns in
let st = st.[10... | val xsetup (k: key) (n: xnonce) (st: state) : Tot state
let xsetup (k: key) (n: xnonce) (st: state) : Tot state = | false | null | false | let ks = uints_from_bytes_le #U32 #SEC #8 k in
let ns = uints_from_bytes_le #U32 #SEC #4 n in
let st = st.[ 0 ] <- constant0 in
let st = update_sub st 1 4 (slice ks 0 4) in
let st = st.[ 5 ] <- constant1 in
let st = update_sub st 6 4 ns in
let st = st.[ 10 ] <- constant2 in
let st = update_sub st 11 4 (slice ks 4 8) in... | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [
"Spec.Salsa20.key",
"Spec.Salsa20.xnonce",
"Spec.Salsa20.state",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.SEC",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.upd",
"Spec.Salsa20.constant3",
"Lib.Sequence.index",... | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *)
let size_block = 64 (* in bytes *)
let size_nonce = 8 (* in bytes *)
let size_xnonc... | false | true | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val xsetup (k: key) (n: xnonce) (st: state) : Tot state | [] | Spec.Salsa20.xsetup | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | k: Spec.Salsa20.key -> n: Spec.Salsa20.xnonce -> st: Spec.Salsa20.state -> Spec.Salsa20.state | {
"end_col": 4,
"end_line": 109,
"start_col": 54,
"start_line": 99
} |
Prims.Tot | val setup (k: key) (n: nonce) (ctr0: counter) (st: state) : Tot state | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full... | false | let setup (k:key) (n:nonce) (ctr0:counter) (st:state) : Tot state =
let ks = uints_from_bytes_le #U32 #SEC #8 k in
let ns = uints_from_bytes_le #U32 #SEC #2 n in
let st = st.[0] <- constant0 in
let st = update_sub st 1 4 (slice ks 0 4) in
let st = st.[5] <- constant1 in
let st = update_sub st 6 2 ns in
le... | val setup (k: key) (n: nonce) (ctr0: counter) (st: state) : Tot state
let setup (k: key) (n: nonce) (ctr0: counter) (st: state) : Tot state = | false | null | false | let ks = uints_from_bytes_le #U32 #SEC #8 k in
let ns = uints_from_bytes_le #U32 #SEC #2 n in
let st = st.[ 0 ] <- constant0 in
let st = update_sub st 1 4 (slice ks 0 4) in
let st = st.[ 5 ] <- constant1 in
let st = update_sub st 6 2 ns in
let st = st.[ 8 ] <- u32 ctr0 in
let st = st.[ 9 ] <- u32 0 in
let st = st.[ 10 ... | {
"checked_file": "Spec.Salsa20.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.... | [
"total"
] | [
"Spec.Salsa20.key",
"Spec.Salsa20.nonce",
"Spec.Salsa20.counter",
"Spec.Salsa20.state",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.SEC",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.upd",
"Spec.Salsa20.constant3"... | [] | module Spec.Salsa20
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.RawIntTypes
open Lib.LoopCombinators
#set-options "--max_fuel 0 --z3rlimit 100"
(* Constants *)
let size_key = 32 (* in bytes *)
let size_block = 64 (* in bytes *)
let size_nonce = 8 (* in bytes *)
let size_xnonc... | false | true | Spec.Salsa20.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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_el... | null | val setup (k: key) (n: nonce) (ctr0: counter) (st: state) : Tot state | [] | Spec.Salsa20.setup | {
"file_name": "specs/Spec.Salsa20.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | k: Spec.Salsa20.key -> n: Spec.Salsa20.nonce -> ctr0: Spec.Salsa20.counter -> st: Spec.Salsa20.state
-> Spec.Salsa20.state | {
"end_col": 4,
"end_line": 92,
"start_col": 67,
"start_line": 80
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let blocksize = size_block | let blocksize = | false | null | false | size_block | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"total"
] | [
"Hacl.Spec.Chacha20.Vec.size_block"
] | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | true | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val blocksize : Prims.int | [] | Hacl.Spec.Chacha20.Equiv.blocksize | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.int | {
"end_col": 26,
"end_line": 19,
"start_col": 16,
"start_line": 19
} | |
Prims.Tot | val scalar_rounds (m: Scalar.state) : Scalar.state | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let scalar_rounds (m:Scalar.state) : Scalar.state =
Scalar.double_round (Scalar.double_round (
Scalar.double_round (Scalar.double_round (
Scalar.double_round (Scalar.double_round (
Scalar.double_round (Scalar.double_round (
Scalar.double_round (Scalar.double_round m))))))))) | val scalar_rounds (m: Scalar.state) : Scalar.state
let scalar_rounds (m: Scalar.state) : Scalar.state = | false | null | false | Scalar.double_round (Scalar.double_round (Scalar.double_round (Scalar.double_round (Scalar.double_round
(Scalar.double_round (Scalar.double_round (Scalar.double_round (Scalar.double_round
(Scalar.double_round m))))))))) | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"total"
] | [
"Spec.Chacha20.state",
"Spec.Chacha20.double_round"
] | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | true | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val scalar_rounds (m: Scalar.state) : Scalar.state | [] | Hacl.Spec.Chacha20.Equiv.scalar_rounds | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | m: Spec.Chacha20.state -> Spec.Chacha20.state | {
"end_col": 53,
"end_line": 229,
"start_col": 2,
"start_line": 225
} |
FStar.Pervasives.Lemma | val scalar_rounds_unroll_lemma: m:Scalar.state ->
Lemma (scalar_rounds m `Seq.equal` Scalar.rounds m) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let scalar_rounds_unroll_lemma m =
let open Lib.LoopCombinators in
eq_repeat0 Scalar.double_round m;
unfold_repeat 10 Scalar.double_round m 0;
unfold_repeat 10 Scalar.double_round m 1;
unfold_repeat 10 Scalar.double_round m 2;
unfold_repeat 10 Scalar.double_round m 3;
unfold_repeat 10 Scalar.double_round ... | val scalar_rounds_unroll_lemma: m:Scalar.state ->
Lemma (scalar_rounds m `Seq.equal` Scalar.rounds m)
let scalar_rounds_unroll_lemma m = | false | null | true | let open Lib.LoopCombinators in
eq_repeat0 Scalar.double_round m;
unfold_repeat 10 Scalar.double_round m 0;
unfold_repeat 10 Scalar.double_round m 1;
unfold_repeat 10 Scalar.double_round m 2;
unfold_repeat 10 Scalar.double_round m 3;
unfold_repeat 10 Scalar.double_round m 4;
unfold_repeat 10 Scalar.double_round m 5;
un... | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Spec.Chacha20.state",
"Lib.LoopCombinators.unfold_repeat",
"Spec.Chacha20.double_round",
"Prims.unit",
"Lib.LoopCombinators.eq_repeat0"
] | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val scalar_rounds_unroll_lemma: m:Scalar.state ->
Lemma (scalar_rounds m `Seq.equal` Scalar.rounds m) | [] | Hacl.Spec.Chacha20.Equiv.scalar_rounds_unroll_lemma | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | m: Spec.Chacha20.state
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.equal (Hacl.Spec.Chacha20.Equiv.scalar_rounds m) (Spec.Chacha20.rounds m)) | {
"end_col": 42,
"end_line": 247,
"start_col": 2,
"start_line": 236
} |
FStar.Pervasives.Lemma | val quarter_round_lemma_i:
#w:lanes
-> a:idx -> b:idx -> c:idx -> d:idx
-> m:state w
-> i:nat{i < w} ->
Lemma ((transpose_state (quarter_round #w a b c d m)).[i] `Seq.equal`
Scalar.quarter_round a b c d (transpose_state m).[i]) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let quarter_round_lemma_i #w a b c d m i =
let lp0 = line a b d (size 16) m in
let lp1 = line c d b (size 12) lp0 in
let lp2 = line a b d (size 8) lp1 in
let lp3 = line c d b (size 7) lp2 in
assert (quarter_round #w a b c d m == lp3);
line_lemma_i a b d (size 16) m i;
line_lemma_i c d b (size 12) lp0 i;
... | val quarter_round_lemma_i:
#w:lanes
-> a:idx -> b:idx -> c:idx -> d:idx
-> m:state w
-> i:nat{i < w} ->
Lemma ((transpose_state (quarter_round #w a b c d m)).[i] `Seq.equal`
Scalar.quarter_round a b c d (transpose_state m).[i])
let quarter_round_lemma_i #w a b c d m i = | false | null | true | let lp0 = line a b d (size 16) m in
let lp1 = line c d b (size 12) lp0 in
let lp2 = line a b d (size 8) lp1 in
let lp3 = line c d b (size 7) lp2 in
assert (quarter_round #w a b c d m == lp3);
line_lemma_i a b d (size 16) m i;
line_lemma_i c d b (size 12) lp0 i;
line_lemma_i a b d (size 8) lp1 i;
line_lemma_i c d b (siz... | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Hacl.Spec.Chacha20.Vec.lanes",
"Hacl.Spec.Chacha20.Vec.idx",
"Hacl.Spec.Chacha20.Vec.state",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.Sequence.eq_intro",
"Lib.IntTypes.uint32",
"Lib.Sequence.op_String_Access",
"Lib.Sequence.lseq",
"Hacl.Spec.Chacha20.Vec.transpose_state",
"Hacl.Spe... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val quarter_round_lemma_i:
#w:lanes
-> a:idx -> b:idx -> c:idx -> d:idx
-> m:state w
-> i:nat{i < w} ->
Lemma ((transpose_state (quarter_round #w a b c d m)).[i] `Seq.equal`
Scalar.quarter_round a b c d (transpose_state m).[i]) | [] | Hacl.Spec.Chacha20.Equiv.quarter_round_lemma_i | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Hacl.Spec.Chacha20.Vec.idx ->
b: Hacl.Spec.Chacha20.Vec.idx ->
c: Hacl.Spec.Chacha20.Vec.idx ->
d: Hacl.Spec.Chacha20.Vec.idx ->
m: Hacl.Spec.Chacha20.Vec.state w ->
i: Prims.nat{i < w}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.equal (Hacl.Spec.Chacha20.Vec.transpose_stat... | {
"end_col": 58,
"end_line": 178,
"start_col": 42,
"start_line": 167
} |
FStar.Pervasives.Lemma | val double_round_lemma_i: #w:lanes -> m:state w -> i:nat{i < w} ->
Lemma ((transpose_state (double_round #w m)).[i] `Seq.equal` Scalar.double_round (transpose_state m).[i]) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let double_round_lemma_i #w m i =
let m1 = column_round m in
let m2 = diagonal_round m1 in
column_round_lemma_i m i;
diagonal_round_lemma_i m1 i | val double_round_lemma_i: #w:lanes -> m:state w -> i:nat{i < w} ->
Lemma ((transpose_state (double_round #w m)).[i] `Seq.equal` Scalar.double_round (transpose_state m).[i])
let double_round_lemma_i #w m i = | false | null | true | let m1 = column_round m in
let m2 = diagonal_round m1 in
column_round_lemma_i m i;
diagonal_round_lemma_i m1 i | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Hacl.Spec.Chacha20.Vec.lanes",
"Hacl.Spec.Chacha20.Vec.state",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Chacha20.Equiv.diagonal_round_lemma_i",
"Prims.unit",
"Hacl.Spec.Chacha20.Equiv.column_round_lemma_i",
"Hacl.Spec.Chacha20.Vec.diagonal_round",
"Hacl.Spec.Chacha20.Vec.column_r... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val double_round_lemma_i: #w:lanes -> m:state w -> i:nat{i < w} ->
Lemma ((transpose_state (double_round #w m)).[i] `Seq.equal` Scalar.double_round (transpose_state m).[i]) | [] | Hacl.Spec.Chacha20.Equiv.double_round_lemma_i | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | m: Hacl.Spec.Chacha20.Vec.state w -> i: Prims.nat{i < w}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.equal (Hacl.Spec.Chacha20.Vec.transpose_state (Hacl.Spec.Chacha20.Vec.double_round
m)).[ i ]
(Spec.Chacha20.double_round (Hacl.Spec.Chacha20.Vec.transpose_state m).[ i ])) | {
"end_col": 29,
"end_line": 220,
"start_col": 33,
"start_line": 216
} |
FStar.Pervasives.Lemma | val column_round_lemma_i: #w:lanes -> m:state w -> i:nat{i < w} ->
Lemma ((transpose_state (column_round #w m)).[i] `Seq.equal` Scalar.column_round (transpose_state m).[i]) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let column_round_lemma_i #w m i =
let lp0 = quarter_round 0 4 8 12 m in
let lp1 = quarter_round 1 5 9 13 lp0 in
let lp2 = quarter_round 2 6 10 14 lp1 in
let lp3 = quarter_round 3 7 11 15 lp2 in
assert (column_round #w m == lp3);
quarter_round_lemma_i 0 4 8 12 m i;
quarter_round_lemma_i 1 5 9 13 lp0 i;... | val column_round_lemma_i: #w:lanes -> m:state w -> i:nat{i < w} ->
Lemma ((transpose_state (column_round #w m)).[i] `Seq.equal` Scalar.column_round (transpose_state m).[i])
let column_round_lemma_i #w m i = | false | null | true | let lp0 = quarter_round 0 4 8 12 m in
let lp1 = quarter_round 1 5 9 13 lp0 in
let lp2 = quarter_round 2 6 10 14 lp1 in
let lp3 = quarter_round 3 7 11 15 lp2 in
assert (column_round #w m == lp3);
quarter_round_lemma_i 0 4 8 12 m i;
quarter_round_lemma_i 1 5 9 13 lp0 i;
quarter_round_lemma_i 2 6 10 14 lp1 i;
quarter_roun... | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Hacl.Spec.Chacha20.Vec.lanes",
"Hacl.Spec.Chacha20.Vec.state",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.Sequence.eq_intro",
"Lib.IntTypes.uint32",
"Lib.Sequence.op_String_Access",
"Lib.Sequence.lseq",
"Hacl.Spec.Chacha20.Vec.transpose_state",
"Hacl.Spec.Chacha20.Vec.column_round",
... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val column_round_lemma_i: #w:lanes -> m:state w -> i:nat{i < w} ->
Lemma ((transpose_state (column_round #w m)).[i] `Seq.equal` Scalar.column_round (transpose_state m).[i]) | [] | Hacl.Spec.Chacha20.Equiv.column_round_lemma_i | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | m: Hacl.Spec.Chacha20.Vec.state w -> i: Prims.nat{i < w}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.equal (Hacl.Spec.Chacha20.Vec.transpose_state (Hacl.Spec.Chacha20.Vec.column_round
m)).[ i ]
(Spec.Chacha20.column_round (Hacl.Spec.Chacha20.Vec.transpose_state m).[ i ])) | {
"end_col": 98,
"end_line": 194,
"start_col": 33,
"start_line": 184
} |
FStar.Pervasives.Lemma | val lemma_i_div_w4: w:pos -> i:nat{i < w * blocksize} ->
Lemma (let bs = w * 4 in i / bs * bs + i % bs / 4 * 4 == i / 4 * 4) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let lemma_i_div_w4 w i =
let bs = w * 4 in
calc (==) {
i / bs * bs + i % bs / 4 * 4;
(==) { Math.Lemmas.euclidean_division_definition (i % bs) 4 }
i / bs * bs + i % bs - i % bs % 4;
(==) { Math.Lemmas.euclidean_division_definition i bs }
i - i % bs % 4;
(==) { Math.Lemmas.modulo_modulo_lemma... | val lemma_i_div_w4: w:pos -> i:nat{i < w * blocksize} ->
Lemma (let bs = w * 4 in i / bs * bs + i % bs / 4 * 4 == i / 4 * 4)
let lemma_i_div_w4 w i = | false | null | true | let bs = w * 4 in
calc ( == ) {
(i / bs) * bs + (i % bs / 4) * 4;
( == ) { Math.Lemmas.euclidean_division_definition (i % bs) 4 }
(i / bs) * bs + i % bs - i % bs % 4;
( == ) { Math.Lemmas.euclidean_division_definition i bs }
i - i % bs % 4;
( == ) { Math.Lemmas.modulo_modulo_lemma i 4 w }
i - i % 4;
( =... | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Prims.pos",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Mul.op_Star",
"Hacl.Spec.Chacha20.Equiv.blocksize",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Addition",
"Prims.op_Division",
"Prims.op_Modulus",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_i_div_w4: w:pos -> i:nat{i < w * blocksize} ->
Lemma (let bs = w * 4 in i / bs * bs + i % bs / 4 * 4 == i / 4 * 4) | [] | Hacl.Spec.Chacha20.Equiv.lemma_i_div_w4 | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | w: Prims.pos -> i: Prims.nat{i < w * Hacl.Spec.Chacha20.Equiv.blocksize}
-> FStar.Pervasives.Lemma
(ensures
(let bs = w * 4 in
(i / bs) * bs + (i % bs / 4) * 4 == (i / 4) * 4)) | {
"end_col": 5,
"end_line": 356,
"start_col": 24,
"start_line": 344
} |
FStar.Pervasives.Lemma | val diagonal_round_lemma_i: #w:lanes -> m:state w -> i:nat{i < w} ->
Lemma ((transpose_state (diagonal_round #w m)).[i] `Seq.equal` Scalar.diagonal_round (transpose_state m).[i]) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let diagonal_round_lemma_i #w m i =
let lp0 = quarter_round 0 5 10 15 m in
let lp1 = quarter_round 1 6 11 12 lp0 in
let lp2 = quarter_round 2 7 8 13 lp1 in
let lp3 = quarter_round 3 4 9 14 lp2 in
assert (diagonal_round #w m == lp3);
quarter_round_lemma_i 0 5 10 15 m i;
quarter_round_lemma_i 1 6 11 12 lp... | val diagonal_round_lemma_i: #w:lanes -> m:state w -> i:nat{i < w} ->
Lemma ((transpose_state (diagonal_round #w m)).[i] `Seq.equal` Scalar.diagonal_round (transpose_state m).[i])
let diagonal_round_lemma_i #w m i = | false | null | true | let lp0 = quarter_round 0 5 10 15 m in
let lp1 = quarter_round 1 6 11 12 lp0 in
let lp2 = quarter_round 2 7 8 13 lp1 in
let lp3 = quarter_round 3 4 9 14 lp2 in
assert (diagonal_round #w m == lp3);
quarter_round_lemma_i 0 5 10 15 m i;
quarter_round_lemma_i 1 6 11 12 lp0 i;
quarter_round_lemma_i 2 7 8 13 lp1 i;
quarter_r... | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Hacl.Spec.Chacha20.Vec.lanes",
"Hacl.Spec.Chacha20.Vec.state",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.Sequence.eq_intro",
"Lib.IntTypes.uint32",
"Lib.Sequence.op_String_Access",
"Lib.Sequence.lseq",
"Hacl.Spec.Chacha20.Vec.transpose_state",
"Hacl.Spec.Chacha20.Vec.diagonal_round",
... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val diagonal_round_lemma_i: #w:lanes -> m:state w -> i:nat{i < w} ->
Lemma ((transpose_state (diagonal_round #w m)).[i] `Seq.equal` Scalar.diagonal_round (transpose_state m).[i]) | [] | Hacl.Spec.Chacha20.Equiv.diagonal_round_lemma_i | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | m: Hacl.Spec.Chacha20.Vec.state w -> i: Prims.nat{i < w}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.equal (Hacl.Spec.Chacha20.Vec.transpose_state (Hacl.Spec.Chacha20.Vec.diagonal_round
m)).[ i ]
(Spec.Chacha20.diagonal_round (Hacl.Spec.Chacha20.Vec.transpose_state m).[ i ])) | {
"end_col": 102,
"end_line": 210,
"start_col": 35,
"start_line": 200
} |
FStar.Pervasives.Lemma | val add_counter_lemma_aux:
w:lanes
-> c0:counter
-> c:counter{w * c <= max_size_t /\ c0 + w <= max_size_t}
-> i:nat{i < w}
-> b:uint32 ->
Lemma (b +. u32 c0 +. u32 (w * c + i) == b +. u32 (c0 + i) +. u32 (w * c)) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let add_counter_lemma_aux w c0 c i b =
let lp = b +. u32 c0 +. u32 (w * c + i) in
let rp = b +. u32 (c0 + i) +. u32 (w * c) in
assert (v lp == ((v b + c0) % modulus U32 + (w * c + i)) % modulus U32);
assert (v rp == ((v b + c0 + i) % modulus U32 + (w * c)) % modulus U32);
Math.Lemmas.lemma_mod_plus_distr_l (v... | val add_counter_lemma_aux:
w:lanes
-> c0:counter
-> c:counter{w * c <= max_size_t /\ c0 + w <= max_size_t}
-> i:nat{i < w}
-> b:uint32 ->
Lemma (b +. u32 c0 +. u32 (w * c + i) == b +. u32 (c0 + i) +. u32 (w * c))
let add_counter_lemma_aux w c0 c i b = | false | null | true | let lp = b +. u32 c0 +. u32 (w * c + i) in
let rp = b +. u32 (c0 + i) +. u32 (w * c) in
assert (v lp == ((v b + c0) % modulus U32 + (w * c + i)) % modulus U32);
assert (v rp == ((v b + c0 + i) % modulus U32 + (w * c)) % modulus U32);
Math.Lemmas.lemma_mod_plus_distr_l (v b + c0) (w * c + i) (modulus U32);
Math.Lemmas.l... | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Hacl.Spec.Chacha20.Vec.lanes",
"Hacl.Spec.Chacha20.Vec.counter",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Prims.op_Addition",
"Prims.nat",
"Prims.op_LessThan",
"Lib.IntTypes.uint32",
"FStar.Math.Lemmas.lemma_mod_plus_distr_l",
... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val add_counter_lemma_aux:
w:lanes
-> c0:counter
-> c:counter{w * c <= max_size_t /\ c0 + w <= max_size_t}
-> i:nat{i < w}
-> b:uint32 ->
Lemma (b +. u32 c0 +. u32 (w * c + i) == b +. u32 (c0 + i) +. u32 (w * c)) | [] | Hacl.Spec.Chacha20.Equiv.add_counter_lemma_aux | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
w: Hacl.Spec.Chacha20.Vec.lanes ->
c0: Hacl.Spec.Chacha20.Vec.counter ->
c:
Hacl.Spec.Chacha20.Vec.counter
{w * c <= Lib.IntTypes.max_size_t /\ c0 + w <= Lib.IntTypes.max_size_t} ->
i: Prims.nat{i < w} ->
b: Lib.IntTypes.uint32
-> FStar.Pervasives.Lemma
(ensures
b +. Lib.I... | {
"end_col": 73,
"end_line": 83,
"start_col": 38,
"start_line": 77
} |
FStar.Pervasives.Lemma | val lemma_i_div_blocksize: w:pos -> i:nat{i < w * blocksize} ->
Lemma (i / blocksize * blocksize + i % blocksize / 4 * 4 == i / 4 * 4) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let lemma_i_div_blocksize w i =
calc (==) {
i / blocksize * blocksize + i % blocksize / 4 * 4;
(==) { Math.Lemmas.euclidean_division_definition (i % blocksize) 4 }
i / blocksize * blocksize + i % blocksize - i % blocksize % 4;
(==) { Math.Lemmas.modulo_modulo_lemma i 4 16 }
i / blocksize * blocksi... | val lemma_i_div_blocksize: w:pos -> i:nat{i < w * blocksize} ->
Lemma (i / blocksize * blocksize + i % blocksize / 4 * 4 == i / 4 * 4)
let lemma_i_div_blocksize w i = | false | null | true | calc ( == ) {
(i / blocksize) * blocksize + (i % blocksize / 4) * 4;
( == ) { Math.Lemmas.euclidean_division_definition (i % blocksize) 4 }
(i / blocksize) * blocksize + i % blocksize - i % blocksize % 4;
( == ) { Math.Lemmas.modulo_modulo_lemma i 4 16 }
(i / blocksize) * blocksize + i % blocksize - i % 4;
... | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Prims.pos",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Mul.op_Star",
"Hacl.Spec.Chacha20.Equiv.blocksize",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Addition",
"Prims.op_Division",
"Prims.op_Modulus",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_i_div_blocksize: w:pos -> i:nat{i < w * blocksize} ->
Lemma (i / blocksize * blocksize + i % blocksize / 4 * 4 == i / 4 * 4) | [] | Hacl.Spec.Chacha20.Equiv.lemma_i_div_blocksize | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | w: Prims.pos -> i: Prims.nat{i < w * Hacl.Spec.Chacha20.Equiv.blocksize}
-> FStar.Pervasives.Lemma
(ensures
(i / Hacl.Spec.Chacha20.Equiv.blocksize) * Hacl.Spec.Chacha20.Equiv.blocksize +
(i % Hacl.Spec.Chacha20.Equiv.blocksize / 4) * 4 ==
(i / 4) * 4) | {
"end_col": 3,
"end_line": 371,
"start_col": 2,
"start_line": 361
} |
FStar.Pervasives.Lemma | val rounds_lemma_i: #w:lanes -> m:state w -> i:nat{i < w} ->
Lemma ((transpose_state (rounds #w m)).[i] `Seq.equal` Scalar.rounds (transpose_state m).[i]) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let rounds_lemma_i #w m i =
let ms = (transpose_state m).[i] in
let m1 = double_round m in
let m2 = double_round m1 in
let m3 = double_round m2 in
let m4 = double_round m3 in
let m5 = double_round m4 in
let m6 = double_round m5 in
let m7 = double_round m6 in
let m8 = double_round m7 in
let m9 = doub... | val rounds_lemma_i: #w:lanes -> m:state w -> i:nat{i < w} ->
Lemma ((transpose_state (rounds #w m)).[i] `Seq.equal` Scalar.rounds (transpose_state m).[i])
let rounds_lemma_i #w m i = | false | null | true | let ms = (transpose_state m).[ i ] in
let m1 = double_round m in
let m2 = double_round m1 in
let m3 = double_round m2 in
let m4 = double_round m3 in
let m5 = double_round m4 in
let m6 = double_round m5 in
let m7 = double_round m6 in
let m8 = double_round m7 in
let m9 = double_round m8 in
let m10 = double_round m9 in
as... | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Hacl.Spec.Chacha20.Vec.lanes",
"Hacl.Spec.Chacha20.Vec.state",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Chacha20.Equiv.scalar_rounds_unroll_lemma",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint32",
"Lib.Sequence.op_String_Access",
"Hacl... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val rounds_lemma_i: #w:lanes -> m:state w -> i:nat{i < w} ->
Lemma ((transpose_state (rounds #w m)).[i] `Seq.equal` Scalar.rounds (transpose_state m).[i]) | [] | Hacl.Spec.Chacha20.Equiv.rounds_lemma_i | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | m: Hacl.Spec.Chacha20.Vec.state w -> i: Prims.nat{i < w}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.equal (Hacl.Spec.Chacha20.Vec.transpose_state (Hacl.Spec.Chacha20.Vec.rounds m)
).[ i ]
(Spec.Chacha20.rounds (Hacl.Spec.Chacha20.Vec.transpose_state m).[ i ])) | {
"end_col": 31,
"end_line": 277,
"start_col": 27,
"start_line": 253
} |
FStar.Pervasives.Lemma | val update_sub_is_append:
#a:Type0
-> zero:a
-> blocksize:size_pos
-> len:nat{len < blocksize}
-> b_v:lseq a len ->
Lemma
(let plain = create blocksize zero in
let plain = update_sub plain 0 len b_v in
let zeros = create (blocksize - len) zero in
plain == Seq.append b_v zeros) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let update_sub_is_append #a zero blocksize len b_v =
let plain = create blocksize zero in
let plain = update_sub plain 0 len b_v in
let zeros = create (blocksize - len) zero in
Seq.Properties.lemma_split plain len;
Seq.Properties.lemma_split (Seq.append b_v zeros) len;
eq_intro plain (Seq.append b_v zeros) | val update_sub_is_append:
#a:Type0
-> zero:a
-> blocksize:size_pos
-> len:nat{len < blocksize}
-> b_v:lseq a len ->
Lemma
(let plain = create blocksize zero in
let plain = update_sub plain 0 len b_v in
let zeros = create (blocksize - len) zero in
plain == Seq.append b_v zeros)
let update_su... | false | null | true | let plain = create blocksize zero in
let plain = update_sub plain 0 len b_v in
let zeros = create (blocksize - len) zero in
Seq.Properties.lemma_split plain len;
Seq.Properties.lemma_split (Seq.append b_v zeros) len;
eq_intro plain (Seq.append b_v zeros) | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Lib.IntTypes.size_pos",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.Sequence.lseq",
"Lib.Sequence.eq_intro",
"FStar.Seq.Base.append",
"Prims.unit",
"FStar.Seq.Properties.lemma_split",
"Prims.op_Subtraction",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val update_sub_is_append:
#a:Type0
-> zero:a
-> blocksize:size_pos
-> len:nat{len < blocksize}
-> b_v:lseq a len ->
Lemma
(let plain = create blocksize zero in
let plain = update_sub plain 0 len b_v in
let zeros = create (blocksize - len) zero in
plain == Seq.append b_v zeros) | [] | Hacl.Spec.Chacha20.Equiv.update_sub_is_append | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
zero: a ->
blocksize: Lib.IntTypes.size_pos ->
len: Prims.nat{len < blocksize} ->
b_v: Lib.Sequence.lseq a len
-> FStar.Pervasives.Lemma
(ensures
(let plain = Lib.Sequence.create blocksize zero in
let plain = Lib.Sequence.update_sub plain 0 len b_v in
let zeros = Lib.Sequenc... | {
"end_col": 39,
"end_line": 594,
"start_col": 52,
"start_line": 588
} |
FStar.Pervasives.Lemma | val chacha20_map_blocks_vec_equiv_pre_k:
#w:lanes
-> k:key
-> n:nonce
-> c0:counter{c0 + w <= max_size_t}
-> hi_fv:size_nat{w * hi_fv + w <= max_size_t} // n == hi_fv == len / (w * blocksize)
-> rem:nat{rem < w * blocksize}
-> b_v:lseq uint8 rem
-> j:nat{j < rem} ->
Lemma
(let st_v0 = chacha20_in... | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let chacha20_map_blocks_vec_equiv_pre_k #w k n c0 hi_fv rem b_v j =
if j < rem / blocksize * blocksize then
chacha20_map_blocks_vec_equiv_pre_k0 #w k n c0 hi_fv rem b_v j
else
chacha20_map_blocks_vec_equiv_pre_k1 #w k n c0 hi_fv rem b_v j | val chacha20_map_blocks_vec_equiv_pre_k:
#w:lanes
-> k:key
-> n:nonce
-> c0:counter{c0 + w <= max_size_t}
-> hi_fv:size_nat{w * hi_fv + w <= max_size_t} // n == hi_fv == len / (w * blocksize)
-> rem:nat{rem < w * blocksize}
-> b_v:lseq uint8 rem
-> j:nat{j < rem} ->
Lemma
(let st_v0 = chacha20_in... | false | null | true | if j < (rem / blocksize) * blocksize
then chacha20_map_blocks_vec_equiv_pre_k0 #w k n c0 hi_fv rem b_v j
else chacha20_map_blocks_vec_equiv_pre_k1 #w k n c0 hi_fv rem b_v j | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Hacl.Spec.Chacha20.Vec.lanes",
"Hacl.Spec.Chacha20.Vec.key",
"Hacl.Spec.Chacha20.Vec.nonce",
"Hacl.Spec.Chacha20.Vec.counter",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Lib.IntTypes.size_nat",
"FStar.Mul.op_Star",
"Prims.nat",
"Prims.op_LessThan... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val chacha20_map_blocks_vec_equiv_pre_k:
#w:lanes
-> k:key
-> n:nonce
-> c0:counter{c0 + w <= max_size_t}
-> hi_fv:size_nat{w * hi_fv + w <= max_size_t} // n == hi_fv == len / (w * blocksize)
-> rem:nat{rem < w * blocksize}
-> b_v:lseq uint8 rem
-> j:nat{j < rem} ->
Lemma
(let st_v0 = chacha20_in... | [] | Hacl.Spec.Chacha20.Equiv.chacha20_map_blocks_vec_equiv_pre_k | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k: Hacl.Spec.Chacha20.Vec.key ->
n: Hacl.Spec.Chacha20.Vec.nonce ->
c0: Hacl.Spec.Chacha20.Vec.counter{c0 + w <= Lib.IntTypes.max_size_t} ->
hi_fv: Lib.IntTypes.size_nat{w * hi_fv + w <= Lib.IntTypes.max_size_t} ->
rem: Prims.nat{rem < w * Hacl.Spec.Chacha20.Equiv.blocksize} ->
b_v: Lib.Sequenc... | {
"end_col": 66,
"end_line": 922,
"start_col": 2,
"start_line": 919
} |
FStar.Pervasives.Lemma | val sum_state_lemma_i: #w:lanes -> st1:state w -> st2:state w -> i:nat{i < w} ->
Lemma ((transpose_state (sum_state st1 st2)).[i] `Seq.equal` Scalar.sum_state (transpose_state st1).[i] (transpose_state st2).[i]) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let sum_state_lemma_i #w st1 st2 i =
eq_intro (transpose_state (sum_state st1 st2)).[i] (Scalar.sum_state (transpose_state st1).[i] (transpose_state st2).[i]) | val sum_state_lemma_i: #w:lanes -> st1:state w -> st2:state w -> i:nat{i < w} ->
Lemma ((transpose_state (sum_state st1 st2)).[i] `Seq.equal` Scalar.sum_state (transpose_state st1).[i] (transpose_state st2).[i])
let sum_state_lemma_i #w st1 st2 i = | false | null | true | eq_intro (transpose_state (sum_state st1 st2)).[ i ]
(Scalar.sum_state (transpose_state st1).[ i ] (transpose_state st2).[ i ]) | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Hacl.Spec.Chacha20.Vec.lanes",
"Hacl.Spec.Chacha20.Vec.state",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.Sequence.eq_intro",
"Lib.IntTypes.uint32",
"Lib.Sequence.op_String_Access",
"Lib.Sequence.lseq",
"Hacl.Spec.Chacha20.Vec.transpose_state",
"Hacl.Spec.Chacha20.Vec.sum_state",
"Sp... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val sum_state_lemma_i: #w:lanes -> st1:state w -> st2:state w -> i:nat{i < w} ->
Lemma ((transpose_state (sum_state st1 st2)).[i] `Seq.equal` Scalar.sum_state (transpose_state st1).[i] (transpose_state st2).[i]) | [] | Hacl.Spec.Chacha20.Equiv.sum_state_lemma_i | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | st1: Hacl.Spec.Chacha20.Vec.state w -> st2: Hacl.Spec.Chacha20.Vec.state w -> i: Prims.nat{i < w}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.equal (Hacl.Spec.Chacha20.Vec.transpose_state (Hacl.Spec.Chacha20.Vec.sum_state
st1
st2)).[ i ]
(Spec.Chacha20.sum_state... | {
"end_col": 123,
"end_line": 284,
"start_col": 2,
"start_line": 284
} |
FStar.Pervasives.Lemma | val update_sub_get_block_lemma:
#a:Type
-> w:size_pos
-> blocksize:size_pos{w * blocksize <= max_size_t}
-> zero:a
-> len:nat{len < w * blocksize}
-> b_v:lseq a len
-> j:nat{j < len / blocksize * blocksize} ->
Lemma
(let blocksize_v = w * blocksize in
let plain_v = create blocksize_v zero in
... | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let update_sub_get_block_lemma #a w blocksize zero len b_v j =
let blocksize_v = w * blocksize in
let plain = create blocksize_v zero in
let plain = update_sub plain 0 len b_v in
div_mul_lt blocksize j w;
Math.Lemmas.cancel_mul_div w blocksize;
let b_p = SeqLemmas.get_block_s #a #blocksize_v blocksize plai... | val update_sub_get_block_lemma:
#a:Type
-> w:size_pos
-> blocksize:size_pos{w * blocksize <= max_size_t}
-> zero:a
-> len:nat{len < w * blocksize}
-> b_v:lseq a len
-> j:nat{j < len / blocksize * blocksize} ->
Lemma
(let blocksize_v = w * blocksize in
let plain_v = create blocksize_v zero in
... | false | null | true | let blocksize_v = w * blocksize in
let plain = create blocksize_v zero in
let plain = update_sub plain 0 len b_v in
div_mul_lt blocksize j w;
Math.Lemmas.cancel_mul_div w blocksize;
let b_p = SeqLemmas.get_block_s #a #blocksize_v blocksize plain j in
let b = SeqLemmas.get_block_s #a #len blocksize b_v j in
Classical.fo... | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Lib.IntTypes.size_pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Prims.nat",
"Prims.op_LessThan",
"Lib.Sequence.lseq",
"Prims.op_Division",
"Lib.Sequence.eq_intro",
"Prims.unit",
"FStar.Classical.forall_intro",
"Prims.eq2",
"FStar.Seq.Base.... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val update_sub_get_block_lemma:
#a:Type
-> w:size_pos
-> blocksize:size_pos{w * blocksize <= max_size_t}
-> zero:a
-> len:nat{len < w * blocksize}
-> b_v:lseq a len
-> j:nat{j < len / blocksize * blocksize} ->
Lemma
(let blocksize_v = w * blocksize in
let plain_v = create blocksize_v zero in
... | [] | Hacl.Spec.Chacha20.Equiv.update_sub_get_block_lemma | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
w: Lib.IntTypes.size_pos ->
blocksize: Lib.IntTypes.size_pos{w * blocksize <= Lib.IntTypes.max_size_t} ->
zero: a ->
len: Prims.nat{len < w * blocksize} ->
b_v: Lib.Sequence.lseq a len ->
j: Prims.nat{j < (len / blocksize) * blocksize}
-> FStar.Pervasives.Lemma
(ensures
(let blocksi... | {
"end_col": 16,
"end_line": 680,
"start_col": 62,
"start_line": 670
} |
FStar.Pervasives.Lemma | val update_sub_get_last_lemma:
#a:Type
-> w:size_pos
-> blocksize:size_pos{w * blocksize <= max_size_t}
-> zero:a
-> len:nat{len < w * blocksize}
-> b_v:lseq a len
-> j:nat{len / blocksize * blocksize <= j /\ j < len} ->
Lemma
(let blocksize_v = w * blocksize in
let plain_v = create blocksize_v... | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let update_sub_get_last_lemma #a w blocksize zero len b_v j =
let blocksize_v = w * blocksize in
let plain_v = create blocksize_v zero in
let plain_v = update_sub plain_v 0 len b_v in
div_mul_lt blocksize j w;
Math.Lemmas.cancel_mul_div w blocksize;
let block_l = SeqLemmas.get_last_s #a #len blocksize b_v ... | val update_sub_get_last_lemma:
#a:Type
-> w:size_pos
-> blocksize:size_pos{w * blocksize <= max_size_t}
-> zero:a
-> len:nat{len < w * blocksize}
-> b_v:lseq a len
-> j:nat{len / blocksize * blocksize <= j /\ j < len} ->
Lemma
(let blocksize_v = w * blocksize in
let plain_v = create blocksize_v... | false | null | true | let blocksize_v = w * blocksize in
let plain_v = create blocksize_v zero in
let plain_v = update_sub plain_v 0 len b_v in
div_mul_lt blocksize j w;
Math.Lemmas.cancel_mul_div w blocksize;
let block_l = SeqLemmas.get_last_s #a #len blocksize b_v in
let plain = create blocksize zero in
let plain = update_sub plain 0 (len... | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Lib.IntTypes.size_pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Prims.nat",
"Prims.op_LessThan",
"Lib.Sequence.lseq",
"Prims.l_and",
"Prims.op_Division",
"Lib.Sequence.eq_intro",
"Prims.unit",
"FStar.Classical.forall_intro",
"Prims.eq2",
... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val update_sub_get_last_lemma:
#a:Type
-> w:size_pos
-> blocksize:size_pos{w * blocksize <= max_size_t}
-> zero:a
-> len:nat{len < w * blocksize}
-> b_v:lseq a len
-> j:nat{len / blocksize * blocksize <= j /\ j < len} ->
Lemma
(let blocksize_v = w * blocksize in
let plain_v = create blocksize_v... | [] | Hacl.Spec.Chacha20.Equiv.update_sub_get_last_lemma | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
w: Lib.IntTypes.size_pos ->
blocksize: Lib.IntTypes.size_pos{w * blocksize <= Lib.IntTypes.max_size_t} ->
zero: a ->
len: Prims.nat{len < w * blocksize} ->
b_v: Lib.Sequence.lseq a len ->
j: Prims.nat{(len / blocksize) * blocksize <= j /\ j < len}
-> FStar.Pervasives.Lemma
(ensures
... | {
"end_col": 18,
"end_line": 808,
"start_col": 61,
"start_line": 791
} |
FStar.Pervasives.Lemma | val xor_block_scalar_lemma_i: k:Scalar.state -> b:Scalar.block -> i:nat{i < blocksize} -> Lemma
((Scalar.xor_block k b).[i] == (uint_to_bytes_le ((uint_from_bytes_le (sub b (i / 4 * 4) 4)) ^. k.[i / 4])).[i % 4]) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let xor_block_scalar_lemma_i k b i =
let ib = uints_from_bytes_le b in
let ob = map2 (^.) ib k in
let b_i = sub b (i / 4 * 4) 4 in
calc (==) {
Seq.index (uints_to_bytes_le ob) i;
(==) { index_uints_to_bytes_le ob i }
Seq.index (uint_to_bytes_le ob.[i / 4]) (i % 4);
(==) { (* def of xor *) }
... | val xor_block_scalar_lemma_i: k:Scalar.state -> b:Scalar.block -> i:nat{i < blocksize} -> Lemma
((Scalar.xor_block k b).[i] == (uint_to_bytes_le ((uint_from_bytes_le (sub b (i / 4 * 4) 4)) ^. k.[i / 4])).[i % 4])
let xor_block_scalar_lemma_i k b i = | false | null | true | let ib = uints_from_bytes_le b in
let ob = map2 ( ^. ) ib k in
let b_i = sub b ((i / 4) * 4) 4 in
calc ( == ) {
Seq.index (uints_to_bytes_le ob) i;
( == ) { index_uints_to_bytes_le ob i }
Seq.index (uint_to_bytes_le ob.[ i / 4 ]) (i % 4);
( == ) { () }
Seq.index (uint_to_bytes_le (ib.[ i / 4 ] ^. k.[ i / 4 ])... | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Spec.Chacha20.state",
"Spec.Chacha20.block",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Chacha20.Equiv.blocksize",
"FStar.Calc.calc_finish",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.eq2",
"FStar.Seq.Base.index",
"Lib.ByteSequence.uints_to_bytes_le"... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val xor_block_scalar_lemma_i: k:Scalar.state -> b:Scalar.block -> i:nat{i < blocksize} -> Lemma
((Scalar.xor_block k b).[i] == (uint_to_bytes_le ((uint_from_bytes_le (sub b (i / 4 * 4) 4)) ^. k.[i / 4])).[i % 4]) | [] | Hacl.Spec.Chacha20.Equiv.xor_block_scalar_lemma_i | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k: Spec.Chacha20.state ->
b: Spec.Chacha20.block ->
i: Prims.nat{i < Hacl.Spec.Chacha20.Equiv.blocksize}
-> FStar.Pervasives.Lemma
(ensures
(Spec.Chacha20.xor_block k b).[ i ] ==
(Lib.ByteSequence.uint_to_bytes_le (Lib.ByteSequence.uint_from_bytes_le (Lib.Sequence.sub b
... | {
"end_col": 5,
"end_line": 425,
"start_col": 36,
"start_line": 412
} |
FStar.Pervasives.Lemma | val kb_equiv_lemma:
#w:lanes
-> k:key
-> n:nonce
-> c0:counter
-> c:counter{w * c <= max_size_t /\ c0 + w <= max_size_t}
-> i:nat{i < w} -> Lemma
(let st1 = Scalar.chacha20_init k n c0 in
let st2 = Scalar.chacha20_init k n (c0 + i) in
Scalar.chacha20_core (w * c + i) st1 `Seq.equal` Scalar.chacha2... | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let kb_equiv_lemma #w k n c0 c i =
let st1 = Scalar.chacha20_init k n c0 in
let st2 = Scalar.chacha20_init k n (c0 + i) in
chacha20_init_scalar_lemma k n c0;
chacha20_init_scalar_lemma k n (c0 + i);
chacha20_core_scalar_lemma w st1 st2 c0 c i | val kb_equiv_lemma:
#w:lanes
-> k:key
-> n:nonce
-> c0:counter
-> c:counter{w * c <= max_size_t /\ c0 + w <= max_size_t}
-> i:nat{i < w} -> Lemma
(let st1 = Scalar.chacha20_init k n c0 in
let st2 = Scalar.chacha20_init k n (c0 + i) in
Scalar.chacha20_core (w * c + i) st1 `Seq.equal` Scalar.chacha2... | false | null | true | let st1 = Scalar.chacha20_init k n c0 in
let st2 = Scalar.chacha20_init k n (c0 + i) in
chacha20_init_scalar_lemma k n c0;
chacha20_init_scalar_lemma k n (c0 + i);
chacha20_core_scalar_lemma w st1 st2 c0 c i | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Hacl.Spec.Chacha20.Vec.lanes",
"Hacl.Spec.Chacha20.Vec.key",
"Hacl.Spec.Chacha20.Vec.nonce",
"Hacl.Spec.Chacha20.Vec.counter",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Prims.op_Addition",
"Prims.nat",
"Prims.op_LessThan",
"Hacl... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val kb_equiv_lemma:
#w:lanes
-> k:key
-> n:nonce
-> c0:counter
-> c:counter{w * c <= max_size_t /\ c0 + w <= max_size_t}
-> i:nat{i < w} -> Lemma
(let st1 = Scalar.chacha20_init k n c0 in
let st2 = Scalar.chacha20_init k n (c0 + i) in
Scalar.chacha20_core (w * c + i) st1 `Seq.equal` Scalar.chacha2... | [] | Hacl.Spec.Chacha20.Equiv.kb_equiv_lemma | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k: Hacl.Spec.Chacha20.Vec.key ->
n: Hacl.Spec.Chacha20.Vec.nonce ->
c0: Hacl.Spec.Chacha20.Vec.counter ->
c:
Hacl.Spec.Chacha20.Vec.counter
{w * c <= Lib.IntTypes.max_size_t /\ c0 + w <= Lib.IntTypes.max_size_t} ->
i: Prims.nat{i < w}
-> FStar.Pervasives.Lemma
(ensures
(le... | {
"end_col": 45,
"end_line": 136,
"start_col": 34,
"start_line": 131
} |
FStar.Pervasives.Lemma | val add_counter_lemma_i: #w:lanes -> st:state w -> c:counter{w * c <= max_size_t} -> i:nat{i < w} ->
Lemma ((transpose_state (add_counter #w c st)).[i] `Seq.equal` Scalar.chacha20_add_counter (transpose_state st).[i] (w * c)) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let add_counter_lemma_i #w st c i =
Math.Lemmas.modulo_lemma (w * c) (pow2 32);
assert (v (u32 w *! u32 c) == v (u32 (w * c)));
eq_intro (transpose_state (add_counter #w c st)).[i] (Scalar.chacha20_add_counter (transpose_state st).[i] (w * c)) | val add_counter_lemma_i: #w:lanes -> st:state w -> c:counter{w * c <= max_size_t} -> i:nat{i < w} ->
Lemma ((transpose_state (add_counter #w c st)).[i] `Seq.equal` Scalar.chacha20_add_counter (transpose_state st).[i] (w * c))
let add_counter_lemma_i #w st c i = | false | null | true | Math.Lemmas.modulo_lemma (w * c) (pow2 32);
assert (v (u32 w *! u32 c) == v (u32 (w * c)));
eq_intro (transpose_state (add_counter #w c st)).[ i ]
(Scalar.chacha20_add_counter (transpose_state st).[ i ] (w * c)) | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Hacl.Spec.Chacha20.Vec.lanes",
"Hacl.Spec.Chacha20.Vec.state",
"Hacl.Spec.Chacha20.Vec.counter",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Prims.nat",
"Prims.op_LessThan",
"Lib.Sequence.eq_intro",
"Lib.IntTypes.uint32",
"Lib.Sequence.op_String_A... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val add_counter_lemma_i: #w:lanes -> st:state w -> c:counter{w * c <= max_size_t} -> i:nat{i < w} ->
Lemma ((transpose_state (add_counter #w c st)).[i] `Seq.equal` Scalar.chacha20_add_counter (transpose_state st).[i] (w * c)) | [] | Hacl.Spec.Chacha20.Equiv.add_counter_lemma_i | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
st: Hacl.Spec.Chacha20.Vec.state w ->
c: Hacl.Spec.Chacha20.Vec.counter{w * c <= Lib.IntTypes.max_size_t} ->
i: Prims.nat{i < w}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.equal (Hacl.Spec.Chacha20.Vec.transpose_state (Hacl.Spec.Chacha20.Vec.add_counter
c
... | {
"end_col": 117,
"end_line": 293,
"start_col": 2,
"start_line": 291
} |
FStar.Pervasives.Lemma | val update_sub_get_last_lemma_plain_k:
#a:Type
-> w:size_pos
-> blocksize:size_pos{w * blocksize <= max_size_t}
-> zero:a
-> len:nat{len < w * blocksize}
-> b_v:lseq a len
-> j:nat{len / blocksize * blocksize <= j /\ j < len}
-> k:nat{k < blocksize} ->
Lemma
(let block_l = SeqLemmas.get_last_s #a... | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let update_sub_get_last_lemma_plain_k #a w blocksize zero len b_v j k =
let block_l = SeqLemmas.get_last_s #a #len blocksize b_v in
let plain = create blocksize zero in
let plain = update_sub plain 0 (len % blocksize) block_l in
let zeros = create (blocksize - len % blocksize) zero in
update_sub_is_append #a... | val update_sub_get_last_lemma_plain_k:
#a:Type
-> w:size_pos
-> blocksize:size_pos{w * blocksize <= max_size_t}
-> zero:a
-> len:nat{len < w * blocksize}
-> b_v:lseq a len
-> j:nat{len / blocksize * blocksize <= j /\ j < len}
-> k:nat{k < blocksize} ->
Lemma
(let block_l = SeqLemmas.get_last_s #a... | false | null | true | let block_l = SeqLemmas.get_last_s #a #len blocksize b_v in
let plain = create blocksize zero in
let plain = update_sub plain 0 (len % blocksize) block_l in
let zeros = create (blocksize - len % blocksize) zero in
update_sub_is_append #a zero blocksize (len % blocksize) block_l;
assert (plain == Seq.append block_l zero... | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Lib.IntTypes.size_pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Prims.nat",
"Prims.op_LessThan",
"Lib.Sequence.lseq",
"Prims.l_and",
"Prims.op_Division",
"Prims.op_Modulus",
"FStar.Calc.calc_finish",
"Prims.eq2",
"FStar.Seq.Base.index",
... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val update_sub_get_last_lemma_plain_k:
#a:Type
-> w:size_pos
-> blocksize:size_pos{w * blocksize <= max_size_t}
-> zero:a
-> len:nat{len < w * blocksize}
-> b_v:lseq a len
-> j:nat{len / blocksize * blocksize <= j /\ j < len}
-> k:nat{k < blocksize} ->
Lemma
(let block_l = SeqLemmas.get_last_s #a... | [] | Hacl.Spec.Chacha20.Equiv.update_sub_get_last_lemma_plain_k | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
w: Lib.IntTypes.size_pos ->
blocksize: Lib.IntTypes.size_pos{w * blocksize <= Lib.IntTypes.max_size_t} ->
zero: a ->
len: Prims.nat{len < w * blocksize} ->
b_v: Lib.Sequence.lseq a len ->
j: Prims.nat{(len / blocksize) * blocksize <= j /\ j < len} ->
k: Prims.nat{k < blocksize}
-> FStar.P... | {
"end_col": 9,
"end_line": 718,
"start_col": 71,
"start_line": 699
} |
FStar.Pervasives.Lemma | val update_sub_get_last_lemma_plain_v_k:
#a:Type
-> w:size_pos
-> blocksize:size_pos{w * blocksize <= max_size_t}
-> zero:a
-> len:nat{len < w * blocksize}
-> b_v:lseq a len
-> j:nat{len / blocksize * blocksize <= j /\ j < len}
-> k:nat{k < blocksize} ->
Lemma
(let blocksize_v = w * blocksize in
... | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let update_sub_get_last_lemma_plain_v_k #a w blocksize zero len b_v j k =
let blocksize_v = w * blocksize in
let plain_v = create blocksize_v zero in
let plain_v = update_sub plain_v 0 len b_v in
let zeros_v = create (blocksize_v - len) zero in
update_sub_is_append #a zero blocksize_v len b_v;
assert (plain... | val update_sub_get_last_lemma_plain_v_k:
#a:Type
-> w:size_pos
-> blocksize:size_pos{w * blocksize <= max_size_t}
-> zero:a
-> len:nat{len < w * blocksize}
-> b_v:lseq a len
-> j:nat{len / blocksize * blocksize <= j /\ j < len}
-> k:nat{k < blocksize} ->
Lemma
(let blocksize_v = w * blocksize in
... | false | null | true | let blocksize_v = w * blocksize in
let plain_v = create blocksize_v zero in
let plain_v = update_sub plain_v 0 len b_v in
let zeros_v = create (blocksize_v - len) zero in
update_sub_is_append #a zero blocksize_v len b_v;
assert (plain_v == Seq.append b_v zeros_v);
div_mul_lt blocksize j w;
Math.Lemmas.cancel_mul_div w ... | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Lib.IntTypes.size_pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Prims.nat",
"Prims.op_LessThan",
"Lib.Sequence.lseq",
"Prims.l_and",
"Prims.op_Division",
"FStar.Calc.calc_finish",
"Prims.eq2",
"FStar.Seq.Base.index",
"FStar.Seq.Base.slice"... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val update_sub_get_last_lemma_plain_v_k:
#a:Type
-> w:size_pos
-> blocksize:size_pos{w * blocksize <= max_size_t}
-> zero:a
-> len:nat{len < w * blocksize}
-> b_v:lseq a len
-> j:nat{len / blocksize * blocksize <= j /\ j < len}
-> k:nat{k < blocksize} ->
Lemma
(let blocksize_v = w * blocksize in
... | [] | Hacl.Spec.Chacha20.Equiv.update_sub_get_last_lemma_plain_v_k | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
w: Lib.IntTypes.size_pos ->
blocksize: Lib.IntTypes.size_pos{w * blocksize <= Lib.IntTypes.max_size_t} ->
zero: a ->
len: Prims.nat{len < w * blocksize} ->
b_v: Lib.Sequence.lseq a len ->
j: Prims.nat{(len / blocksize) * blocksize <= j /\ j < len} ->
k: Prims.nat{k < blocksize}
-> FStar.P... | {
"end_col": 5,
"end_line": 767,
"start_col": 73,
"start_line": 741
} |
FStar.Pervasives.Lemma | val transpose_lemma_i: #w:lanes -> k:state w -> i:nat{i < w * blocksize} -> Lemma
(Seq.index (vec_v (Seq.index (transpose k) (i / (w * 4)))) (i % (w * 4) / 4) ==
Seq.index (Seq.index (transpose_state k) (i / blocksize)) (i % blocksize / 4)) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let transpose_lemma_i #w k i =
let bs = w * 4 in
let j = i / bs in
let ki = (transpose_state k).[i / blocksize] in
calc (==) {
Seq.index (vec_v (Seq.index (transpose k) j)) (i % bs / 4);
(==) { Math.Lemmas.modulo_division_lemma i 4 w }
Seq.index (vec_v (Seq.index (transpose k) j)) (i / 4 % w);
(... | val transpose_lemma_i: #w:lanes -> k:state w -> i:nat{i < w * blocksize} -> Lemma
(Seq.index (vec_v (Seq.index (transpose k) (i / (w * 4)))) (i % (w * 4) / 4) ==
Seq.index (Seq.index (transpose_state k) (i / blocksize)) (i % blocksize / 4))
let transpose_lemma_i #w k i = | false | null | true | let bs = w * 4 in
let j = i / bs in
let ki = (transpose_state k).[ i / blocksize ] in
calc ( == ) {
Seq.index (vec_v (Seq.index (transpose k) j)) (i % bs / 4);
( == ) { Math.Lemmas.modulo_division_lemma i 4 w }
Seq.index (vec_v (Seq.index (transpose k) j)) (i / 4 % w);
( == ) { Math.Lemmas.division_multiplicati... | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Hacl.Spec.Chacha20.Vec.lanes",
"Hacl.Spec.Chacha20.Vec.state",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Mul.op_Star",
"Hacl.Spec.Chacha20.Equiv.blocksize",
"FStar.Calc.calc_finish",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.SEC",
"Prims.eq2",
"FStar.Seq.Base.inde... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val transpose_lemma_i: #w:lanes -> k:state w -> i:nat{i < w * blocksize} -> Lemma
(Seq.index (vec_v (Seq.index (transpose k) (i / (w * 4)))) (i % (w * 4) / 4) ==
Seq.index (Seq.index (transpose_state k) (i / blocksize)) (i % blocksize / 4)) | [] | Hacl.Spec.Chacha20.Equiv.transpose_lemma_i | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | k: Hacl.Spec.Chacha20.Vec.state w -> i: Prims.nat{i < w * Hacl.Spec.Chacha20.Equiv.blocksize}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.index (Lib.IntVector.vec_v (FStar.Seq.Base.index (Hacl.Spec.Chacha20.Vec.transpose
k)
(i / (w * 4))))
(i % (w * 4) / 4) ... | {
"end_col": 5,
"end_line": 446,
"start_col": 30,
"start_line": 432
} |
FStar.Pervasives.Lemma | val chacha20_core_lemma_i: #w:lanes -> c:counter{w * c <= max_size_t} -> st_v0:state w -> i:nat{i < w} ->
Lemma ((transpose_state (chacha20_core c st_v0)).[i] `Seq.equal` Scalar.chacha20_core (w * c) (transpose_state st_v0).[i]) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let chacha20_core_lemma_i #w c st_v0 i =
let k0 = add_counter c st_v0 in
add_counter_lemma_i st_v0 c i;
let k1 = rounds k0 in
rounds_lemma_i k0 i;
let k2 = sum_state k1 st_v0 in
sum_state_lemma_i k1 st_v0 i;
let k3 = add_counter c k2 in
add_counter_lemma_i k2 c i | val chacha20_core_lemma_i: #w:lanes -> c:counter{w * c <= max_size_t} -> st_v0:state w -> i:nat{i < w} ->
Lemma ((transpose_state (chacha20_core c st_v0)).[i] `Seq.equal` Scalar.chacha20_core (w * c) (transpose_state st_v0).[i])
let chacha20_core_lemma_i #w c st_v0 i = | false | null | true | let k0 = add_counter c st_v0 in
add_counter_lemma_i st_v0 c i;
let k1 = rounds k0 in
rounds_lemma_i k0 i;
let k2 = sum_state k1 st_v0 in
sum_state_lemma_i k1 st_v0 i;
let k3 = add_counter c k2 in
add_counter_lemma_i k2 c i | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Hacl.Spec.Chacha20.Vec.lanes",
"Hacl.Spec.Chacha20.Vec.counter",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Chacha20.Vec.state",
"Prims.nat",
"Prims.op_LessThan",
"Hacl.Spec.Chacha20.Equiv.add_counter_lemma_i",
"Hacl.Spec.Chacha20.Vec.add... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val chacha20_core_lemma_i: #w:lanes -> c:counter{w * c <= max_size_t} -> st_v0:state w -> i:nat{i < w} ->
Lemma ((transpose_state (chacha20_core c st_v0)).[i] `Seq.equal` Scalar.chacha20_core (w * c) (transpose_state st_v0).[i]) | [] | Hacl.Spec.Chacha20.Equiv.chacha20_core_lemma_i | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
c: Hacl.Spec.Chacha20.Vec.counter{w * c <= Lib.IntTypes.max_size_t} ->
st_v0: Hacl.Spec.Chacha20.Vec.state w ->
i: Prims.nat{i < w}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.equal (Hacl.Spec.Chacha20.Vec.transpose_state (Hacl.Spec.Chacha20.Vec.chacha20_core
c
... | {
"end_col": 28,
"end_line": 307,
"start_col": 40,
"start_line": 299
} |
FStar.Pervasives.Lemma | val encrypt_block_lemma_st0_i:
#w:lanes
-> st_v0:state w
-> c:counter{w * c <= max_size_t}
-> b_v:blocks w
-> j:nat{j < w * blocksize} ->
Lemma
(Math.Lemmas.cancel_mul_div w blocksize;
let b = SeqLemmas.get_block_s #uint8 #(w * blocksize) blocksize b_v j in
div_mul_lt blocksize j w;
(chacha20_e... | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let encrypt_block_lemma_st0_i #w st_v0 c b_v j =
let k = chacha20_core c st_v0 in
chacha20_core_lemma_i #w c st_v0 (j / blocksize);
xor_block_lemma_i #w k b_v j | val encrypt_block_lemma_st0_i:
#w:lanes
-> st_v0:state w
-> c:counter{w * c <= max_size_t}
-> b_v:blocks w
-> j:nat{j < w * blocksize} ->
Lemma
(Math.Lemmas.cancel_mul_div w blocksize;
let b = SeqLemmas.get_block_s #uint8 #(w * blocksize) blocksize b_v j in
div_mul_lt blocksize j w;
(chacha20_e... | false | null | true | let k = chacha20_core c st_v0 in
chacha20_core_lemma_i #w c st_v0 (j / blocksize);
xor_block_lemma_i #w k b_v j | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Hacl.Spec.Chacha20.Vec.lanes",
"Hacl.Spec.Chacha20.Vec.state",
"Hacl.Spec.Chacha20.Vec.counter",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Chacha20.Vec.blocks",
"Prims.nat",
"Prims.op_LessThan",
"Hacl.Spec.Chacha20.Equiv.blocksize",
"H... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val encrypt_block_lemma_st0_i:
#w:lanes
-> st_v0:state w
-> c:counter{w * c <= max_size_t}
-> b_v:blocks w
-> j:nat{j < w * blocksize} ->
Lemma
(Math.Lemmas.cancel_mul_div w blocksize;
let b = SeqLemmas.get_block_s #uint8 #(w * blocksize) blocksize b_v j in
div_mul_lt blocksize j w;
(chacha20_e... | [] | Hacl.Spec.Chacha20.Equiv.encrypt_block_lemma_st0_i | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
st_v0: Hacl.Spec.Chacha20.Vec.state w ->
c: Hacl.Spec.Chacha20.Vec.counter{w * c <= Lib.IntTypes.max_size_t} ->
b_v: Hacl.Spec.Chacha20.Vec.blocks w ->
j: Prims.nat{j < w * Hacl.Spec.Chacha20.Equiv.blocksize}
-> FStar.Pervasives.Lemma
(ensures
([@@ FStar.Pervasives.inline_let ]let _ =
... | {
"end_col": 30,
"end_line": 521,
"start_col": 48,
"start_line": 518
} |
FStar.Pervasives.Lemma | val chacha20_core_scalar_lemma:
w:lanes
-> st1:Scalar.state
-> st2:Scalar.state
-> c0:counter
-> c:counter{w * c <= max_size_t /\ c0 + w <= max_size_t}
-> i:nat{i < w} -> Lemma
(requires
(forall (j:nat). j < 16 /\ j <> 12 ==> st1.[j] == st2.[j] /\
st1.[12] == u32 c0 /\ st2.[12] == u32 (c0 + i)))... | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let chacha20_core_scalar_lemma w st1 st2 c0 c i =
let k1 = Scalar.chacha20_add_counter st1 (w * c + i) in
assert (k1.[12] == u32 c0 +. u32 (w * c + i));
let k2 = Scalar.chacha20_add_counter st2 (w * c) in
assert (k2.[12] == u32 (c0 + i) +. u32 (w * c));
assert (v k1.[12] == v k2.[12]);
eq_intro k1 k2;
let... | val chacha20_core_scalar_lemma:
w:lanes
-> st1:Scalar.state
-> st2:Scalar.state
-> c0:counter
-> c:counter{w * c <= max_size_t /\ c0 + w <= max_size_t}
-> i:nat{i < w} -> Lemma
(requires
(forall (j:nat). j < 16 /\ j <> 12 ==> st1.[j] == st2.[j] /\
st1.[12] == u32 c0 /\ st2.[12] == u32 (c0 + i)))... | false | null | true | let k1 = Scalar.chacha20_add_counter st1 (w * c + i) in
assert (k1.[ 12 ] == u32 c0 +. u32 (w * c + i));
let k2 = Scalar.chacha20_add_counter st2 (w * c) in
assert (k2.[ 12 ] == u32 (c0 + i) +. u32 (w * c));
assert (v k1.[ 12 ] == v k2.[ 12 ]);
eq_intro k1 k2;
let k = Scalar.rounds k1 in
let k1 = Scalar.sum_state k st1... | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Hacl.Spec.Chacha20.Vec.lanes",
"Spec.Chacha20.state",
"Hacl.Spec.Chacha20.Vec.counter",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Prims.op_Addition",
"Prims.nat",
"Prims.op_LessThan",
"Lib.Sequence.eq_intro",
"Lib.IntTypes.uint3... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val chacha20_core_scalar_lemma:
w:lanes
-> st1:Scalar.state
-> st2:Scalar.state
-> c0:counter
-> c:counter{w * c <= max_size_t /\ c0 + w <= max_size_t}
-> i:nat{i < w} -> Lemma
(requires
(forall (j:nat). j < 16 /\ j <> 12 ==> st1.[j] == st2.[j] /\
st1.[12] == u32 c0 /\ st2.[12] == u32 (c0 + i)))... | [] | Hacl.Spec.Chacha20.Equiv.chacha20_core_scalar_lemma | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
w: Hacl.Spec.Chacha20.Vec.lanes ->
st1: Spec.Chacha20.state ->
st2: Spec.Chacha20.state ->
c0: Hacl.Spec.Chacha20.Vec.counter ->
c:
Hacl.Spec.Chacha20.Vec.counter
{w * c <= Lib.IntTypes.max_size_t /\ c0 + w <= Lib.IntTypes.max_size_t} ->
i: Prims.nat{i < w}
-> FStar.Pervasives.L... | {
"end_col": 16,
"end_line": 117,
"start_col": 49,
"start_line": 99
} |
FStar.Pervasives.Lemma | val chacha20_init_scalar_lemma: k:key -> n:nonce -> c0:counter -> Lemma
(let uc = map secret chacha20_constants in
let uk = uints_from_bytes_le #U32 #SEC #8 k in
let uctr = create 1 (u32 c0) in
let un = uints_from_bytes_le #U32 #SEC #3 n in
Scalar.chacha20_init k n c0 == uc @| uk @| uctr @| un) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let chacha20_init_scalar_lemma k n c0 =
let uc = map secret chacha20_constants in
let uk = uints_from_bytes_le #U32 #SEC #8 k in
let uctr = create 1 (u32 c0) in
let un = uints_from_bytes_le #U32 #SEC #3 n in
let res = uc @| uk @| uctr @| un in
assert (res == concat uc (concat uk (concat uctr un)));
eq_int... | val chacha20_init_scalar_lemma: k:key -> n:nonce -> c0:counter -> Lemma
(let uc = map secret chacha20_constants in
let uk = uints_from_bytes_le #U32 #SEC #8 k in
let uctr = create 1 (u32 c0) in
let un = uints_from_bytes_le #U32 #SEC #3 n in
Scalar.chacha20_init k n c0 == uc @| uk @| uctr @| un)
let chacha... | false | null | true | let uc = map secret chacha20_constants in
let uk = uints_from_bytes_le #U32 #SEC #8 k in
let uctr = create 1 (u32 c0) in
let un = uints_from_bytes_le #U32 #SEC #3 n in
let res = uc @| uk @| uctr @| un in
assert (res == concat uc (concat uk (concat uctr un)));
eq_intro res (concat (concat (concat uc uk) uctr) un);
let l... | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Hacl.Spec.Chacha20.Vec.key",
"Hacl.Spec.Chacha20.Vec.nonce",
"Hacl.Spec.Chacha20.Vec.counter",
"FStar.Seq.Properties.lemma_split",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.SEC",
"Prims.op_Addition",
"Prims.unit",
"Lib.Sequence.sub",
"Lib.Sequence.eq_intro",
"Lib.Sequence.lseq"... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val chacha20_init_scalar_lemma: k:key -> n:nonce -> c0:counter -> Lemma
(let uc = map secret chacha20_constants in
let uk = uints_from_bytes_le #U32 #SEC #8 k in
let uctr = create 1 (u32 c0) in
let un = uints_from_bytes_le #U32 #SEC #3 n in
Scalar.chacha20_init k n c0 == uc @| uk @| uctr @| un) | [] | Hacl.Spec.Chacha20.Equiv.chacha20_init_scalar_lemma | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k: Hacl.Spec.Chacha20.Vec.key ->
n: Hacl.Spec.Chacha20.Vec.nonce ->
c0: Hacl.Spec.Chacha20.Vec.counter
-> FStar.Pervasives.Lemma
(ensures
(let uc = Lib.Sequence.map Lib.IntTypes.secret Hacl.Spec.Chacha20.Vec.chacha20_constants in
let uk = Lib.ByteSequence.uints_from_bytes_le k in
... | {
"end_col": 54,
"end_line": 66,
"start_col": 39,
"start_line": 32
} |
FStar.Pervasives.Lemma | val encrypt_block_scalar_lemma_i:
#w:lanes
-> k:key
-> n:nonce
-> c0:counter
-> c:counter{w * c <= max_size_t /\ c0 + w <= max_size_t}
-> b_i:Scalar.block
-> i:nat{i < w} ->
Lemma
(let st_v0 = chacha20_init #w k n c0 in
let st0 = Scalar.chacha20_init k n c0 in
Scalar.chacha20_encrypt_block st0... | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let encrypt_block_scalar_lemma_i #w k n c0 c b i =
let st_v0 = chacha20_init #w k n c0 in
let st0 = Scalar.chacha20_init k n c0 in
chacha20_init_lemma_i #w k n c0 i;
assert ((transpose_state st_v0).[i] == Scalar.chacha20_init k n (c0 + i));
kb_equiv_lemma #w k n c0 c i | val encrypt_block_scalar_lemma_i:
#w:lanes
-> k:key
-> n:nonce
-> c0:counter
-> c:counter{w * c <= max_size_t /\ c0 + w <= max_size_t}
-> b_i:Scalar.block
-> i:nat{i < w} ->
Lemma
(let st_v0 = chacha20_init #w k n c0 in
let st0 = Scalar.chacha20_init k n c0 in
Scalar.chacha20_encrypt_block st0... | false | null | true | let st_v0 = chacha20_init #w k n c0 in
let st0 = Scalar.chacha20_init k n c0 in
chacha20_init_lemma_i #w k n c0 i;
assert ((transpose_state st_v0).[ i ] == Scalar.chacha20_init k n (c0 + i));
kb_equiv_lemma #w k n c0 c i | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Hacl.Spec.Chacha20.Vec.lanes",
"Hacl.Spec.Chacha20.Vec.key",
"Hacl.Spec.Chacha20.Vec.nonce",
"Hacl.Spec.Chacha20.Vec.counter",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Prims.op_Addition",
"Spec.Chacha20.block",
"Prims.nat",
"Pr... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val encrypt_block_scalar_lemma_i:
#w:lanes
-> k:key
-> n:nonce
-> c0:counter
-> c:counter{w * c <= max_size_t /\ c0 + w <= max_size_t}
-> b_i:Scalar.block
-> i:nat{i < w} ->
Lemma
(let st_v0 = chacha20_init #w k n c0 in
let st0 = Scalar.chacha20_init k n c0 in
Scalar.chacha20_encrypt_block st0... | [] | Hacl.Spec.Chacha20.Equiv.encrypt_block_scalar_lemma_i | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k: Hacl.Spec.Chacha20.Vec.key ->
n: Hacl.Spec.Chacha20.Vec.nonce ->
c0: Hacl.Spec.Chacha20.Vec.counter ->
c:
Hacl.Spec.Chacha20.Vec.counter
{w * c <= Lib.IntTypes.max_size_t /\ c0 + w <= Lib.IntTypes.max_size_t} ->
b_i: Spec.Chacha20.block ->
i: Prims.nat{i < w}
-> FStar.Pervasi... | {
"end_col": 30,
"end_line": 502,
"start_col": 50,
"start_line": 497
} |
FStar.Pervasives.Lemma | val xor_block_vec_lemma_i: #w:lanes -> k:state w -> b:blocks w -> i:nat{i < w * blocksize} -> Lemma
(let bs = w * 4 in
let j = i / bs in
let block = sub b (i / 4 * 4) 4 in
Seq.index (xor_block k b) i ==
Seq.index (uint_to_bytes_le ((uint_from_bytes_le block) ^. (Seq.index (vec_v k.[j]) (i % bs / 4)))) (i ... | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let xor_block_vec_lemma_i #w k b i =
let bs = w * 4 in
let j = i / bs in
let kb_j = vec_v k.[j] in
let b_j = sub b (i / bs * bs) bs in
let b_i = sub b_j (i % bs / 4 * 4) 4 in
let block = sub b (i / 4 * 4) 4 in
let ob = map2 (^.) (uints_from_bytes_le b_j) kb_j in
calc (==) {
Seq.index (xor_block k... | val xor_block_vec_lemma_i: #w:lanes -> k:state w -> b:blocks w -> i:nat{i < w * blocksize} -> Lemma
(let bs = w * 4 in
let j = i / bs in
let block = sub b (i / 4 * 4) 4 in
Seq.index (xor_block k b) i ==
Seq.index (uint_to_bytes_le ((uint_from_bytes_le block) ^. (Seq.index (vec_v k.[j]) (i % bs / 4)))) (i ... | false | null | true | let bs = w * 4 in
let j = i / bs in
let kb_j = vec_v k.[ j ] in
let b_j = sub b ((i / bs) * bs) bs in
let b_i = sub b_j ((i % bs / 4) * 4) 4 in
let block = sub b ((i / 4) * 4) 4 in
let ob = map2 ( ^. ) (uints_from_bytes_le b_j) kb_j in
calc ( == ) {
Seq.index (xor_block k b) i;
( == ) { index_map_blocks_multi (w * ... | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Hacl.Spec.Chacha20.Vec.lanes",
"Hacl.Spec.Chacha20.Vec.state",
"Hacl.Spec.Chacha20.Vec.blocks",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Mul.op_Star",
"Hacl.Spec.Chacha20.Equiv.blocksize",
"FStar.Calc.calc_finish",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val xor_block_vec_lemma_i: #w:lanes -> k:state w -> b:blocks w -> i:nat{i < w * blocksize} -> Lemma
(let bs = w * 4 in
let j = i / bs in
let block = sub b (i / 4 * 4) 4 in
Seq.index (xor_block k b) i ==
Seq.index (uint_to_bytes_le ((uint_from_bytes_le block) ^. (Seq.index (vec_v k.[j]) (i % bs / 4)))) (i ... | [] | Hacl.Spec.Chacha20.Equiv.xor_block_vec_lemma_i | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k: Hacl.Spec.Chacha20.Vec.state w ->
b: Hacl.Spec.Chacha20.Vec.blocks w ->
i: Prims.nat{i < w * Hacl.Spec.Chacha20.Equiv.blocksize}
-> FStar.Pervasives.Lemma
(ensures
(let bs = w * 4 in
let j = i / bs in
let block = Lib.Sequence.sub b ((i / 4) * 4) 4 in
FStar.Seq.Base.in... | {
"end_col": 5,
"end_line": 406,
"start_col": 36,
"start_line": 381
} |
FStar.Pervasives.Lemma | val lemma_chacha20_vec_equiv:
#w:lanes
-> k:key
-> n:nonce
-> c0:counter{c0 + w <= max_size_t}
-> msg:seq uint8{length msg <= max_size_t} ->
Lemma (chacha20_encrypt_bytes #w k n c0 msg `Seq.equal` Scalar.chacha20_encrypt_bytes k n c0 msg) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let lemma_chacha20_vec_equiv #w k n c0 msg =
let blocksize_v = w * blocksize in
let res = Scalar.chacha20_encrypt_bytes k n c0 msg in
let res_v = chacha20_encrypt_bytes #w k n c0 msg in
let st_v0 = chacha20_init #w k n c0 in
let st0 = Scalar.chacha20_init k n c0 in
let f_v = chacha20_encrypt_block st_v0 ... | val lemma_chacha20_vec_equiv:
#w:lanes
-> k:key
-> n:nonce
-> c0:counter{c0 + w <= max_size_t}
-> msg:seq uint8{length msg <= max_size_t} ->
Lemma (chacha20_encrypt_bytes #w k n c0 msg `Seq.equal` Scalar.chacha20_encrypt_bytes k n c0 msg)
let lemma_chacha20_vec_equiv #w k n c0 msg = | false | null | true | let blocksize_v = w * blocksize in
let res = Scalar.chacha20_encrypt_bytes k n c0 msg in
let res_v = chacha20_encrypt_bytes #w k n c0 msg in
let st_v0 = chacha20_init #w k n c0 in
let st0 = Scalar.chacha20_init k n c0 in
let f_v = chacha20_encrypt_block st_v0 in
let g_v = chacha20_encrypt_last st_v0 in
let f = Scalar.c... | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Hacl.Spec.Chacha20.Vec.lanes",
"Hacl.Spec.Chacha20.Vec.key",
"Hacl.Spec.Chacha20.Vec.nonce",
"Hacl.Spec.Chacha20.Vec.counter",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.seq",
"Lib.IntTypes.uint8",
"Lib.Sequence.length",
"Lib.Vec.Lem... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_chacha20_vec_equiv:
#w:lanes
-> k:key
-> n:nonce
-> c0:counter{c0 + w <= max_size_t}
-> msg:seq uint8{length msg <= max_size_t} ->
Lemma (chacha20_encrypt_bytes #w k n c0 msg `Seq.equal` Scalar.chacha20_encrypt_bytes k n c0 msg) | [] | Hacl.Spec.Chacha20.Equiv.lemma_chacha20_vec_equiv | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k: Hacl.Spec.Chacha20.Vec.key ->
n: Hacl.Spec.Chacha20.Vec.nonce ->
c0: Hacl.Spec.Chacha20.Vec.counter{c0 + w <= Lib.IntTypes.max_size_t} ->
msg: Lib.Sequence.seq Lib.IntTypes.uint8 {Lib.Sequence.length msg <= Lib.IntTypes.max_size_t}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.equal ... | {
"end_col": 66,
"end_line": 957,
"start_col": 44,
"start_line": 936
} |
FStar.Pervasives.Lemma | val chacha20_init_lemma_i: #w:lanes -> k:key -> n:nonce -> c0:counter{c0 + w <= max_size_t} -> i:nat{i < w} ->
Lemma ((transpose_state (chacha20_init #w k n c0)).[i] `Seq.equal` Scalar.chacha20_init k n (c0 + i)) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let chacha20_init_lemma_i #w k n c0 i =
let st1 = setup1 k n c0 in
assert (st1 == Scalar.chacha20_init k n c0);
assert (st1.[12] == u32 c0);
let st = map (vec_load_i w) st1 in
eq_intro (transpose_state st).[i] st1;
assert ((transpose_state st).[i] == st1);
let c = vec_counter U32 w in
assert ((vec_v c... | val chacha20_init_lemma_i: #w:lanes -> k:key -> n:nonce -> c0:counter{c0 + w <= max_size_t} -> i:nat{i < w} ->
Lemma ((transpose_state (chacha20_init #w k n c0)).[i] `Seq.equal` Scalar.chacha20_init k n (c0 + i))
let chacha20_init_lemma_i #w k n c0 i = | false | null | true | let st1 = setup1 k n c0 in
assert (st1 == Scalar.chacha20_init k n c0);
assert (st1.[ 12 ] == u32 c0);
let st = map (vec_load_i w) st1 in
eq_intro (transpose_state st).[ i ] st1;
assert ((transpose_state st).[ i ] == st1);
let c = vec_counter U32 w in
assert ((vec_v c).[ i ] == u32 i);
let res = st.[ 12 ] <- st.[ 12 ] ... | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Hacl.Spec.Chacha20.Vec.lanes",
"Hacl.Spec.Chacha20.Vec.key",
"Hacl.Spec.Chacha20.Vec.nonce",
"Hacl.Spec.Chacha20.Vec.counter",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Prims.nat",
"Prims.op_LessThan",
"Lib.Sequence.eq_intro",
"Lib.IntTypes.uint... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val chacha20_init_lemma_i: #w:lanes -> k:key -> n:nonce -> c0:counter{c0 + w <= max_size_t} -> i:nat{i < w} ->
Lemma ((transpose_state (chacha20_init #w k n c0)).[i] `Seq.equal` Scalar.chacha20_init k n (c0 + i)) | [] | Hacl.Spec.Chacha20.Equiv.chacha20_init_lemma_i | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k: Hacl.Spec.Chacha20.Vec.key ->
n: Hacl.Spec.Chacha20.Vec.nonce ->
c0: Hacl.Spec.Chacha20.Vec.counter{c0 + w <= Lib.IntTypes.max_size_t} ->
i: Prims.nat{i < w}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.equal (Hacl.Spec.Chacha20.Vec.transpose_state (Hacl.Spec.Chacha20.Vec.chacha20_i... | {
"end_col": 20,
"end_line": 336,
"start_col": 39,
"start_line": 313
} |
FStar.Pervasives.Lemma | val xor_block_lemma_i: #w:lanes -> k:state w -> b:blocks w -> i:nat{i < w * blocksize} -> Lemma
(let k_i = (transpose_state k).[i / blocksize] in
let b_i = sub b (i / blocksize * blocksize) blocksize in
(xor_block (transpose k) b).[i] == (Scalar.xor_block k_i b_i).[i % blocksize]) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let xor_block_lemma_i #w k b i =
let bs = w * 4 in
let j = i / bs in
let ki = (transpose_state k).[i / blocksize] in
let b_i = sub b (i / blocksize * blocksize) blocksize in
let block = sub b (i / 4 * 4) 4 in
calc (==) {
Seq.index (xor_block (transpose k) b) i;
(==) { xor_block_vec_lemma_i #w (tra... | val xor_block_lemma_i: #w:lanes -> k:state w -> b:blocks w -> i:nat{i < w * blocksize} -> Lemma
(let k_i = (transpose_state k).[i / blocksize] in
let b_i = sub b (i / blocksize * blocksize) blocksize in
(xor_block (transpose k) b).[i] == (Scalar.xor_block k_i b_i).[i % blocksize])
let xor_block_lemma_i #w k b i... | false | null | true | let bs = w * 4 in
let j = i / bs in
let ki = (transpose_state k).[ i / blocksize ] in
let b_i = sub b ((i / blocksize) * blocksize) blocksize in
let block = sub b ((i / 4) * 4) 4 in
calc ( == ) {
Seq.index (xor_block (transpose k) b) i;
( == ) { xor_block_vec_lemma_i #w (transpose k) b i }
Seq.index (uint_to_byte... | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Hacl.Spec.Chacha20.Vec.lanes",
"Hacl.Spec.Chacha20.Vec.state",
"Hacl.Spec.Chacha20.Vec.blocks",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Mul.op_Star",
"Hacl.Spec.Chacha20.Equiv.blocksize",
"FStar.Calc.calc_finish",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val xor_block_lemma_i: #w:lanes -> k:state w -> b:blocks w -> i:nat{i < w * blocksize} -> Lemma
(let k_i = (transpose_state k).[i / blocksize] in
let b_i = sub b (i / blocksize * blocksize) blocksize in
(xor_block (transpose k) b).[i] == (Scalar.xor_block k_i b_i).[i % blocksize]) | [] | Hacl.Spec.Chacha20.Equiv.xor_block_lemma_i | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k: Hacl.Spec.Chacha20.Vec.state w ->
b: Hacl.Spec.Chacha20.Vec.blocks w ->
i: Prims.nat{i < w * Hacl.Spec.Chacha20.Equiv.blocksize}
-> FStar.Pervasives.Lemma
(ensures
(let k_i =
(Hacl.Spec.Chacha20.Vec.transpose_state k).[ i / Hacl.Spec.Chacha20.Equiv.blocksize ]
in
le... | {
"end_col": 5,
"end_line": 477,
"start_col": 32,
"start_line": 454
} |
FStar.Pervasives.Lemma | val chacha20_map_blocks_multi_vec_equiv_pre_k:
#w:lanes
-> k:key
-> n:nonce
-> c0:counter{c0 + w <= max_size_t}
-> hi_fv:nat // n == hi_fv == len / (w * blocksize)
-> hi_f:size_nat{w * hi_fv <= hi_f}
-> i:nat{i < hi_fv}
-> b_v:lseq uint8 (w * blocksize)
-> j:nat{j < w * blocksize} ->
Lemma
(let... | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let chacha20_map_blocks_multi_vec_equiv_pre_k #w k n c0 hi_fv hi_f i b_v j =
encrypt_block_lemma_bs_i #w k n c0 i b_v j | val chacha20_map_blocks_multi_vec_equiv_pre_k:
#w:lanes
-> k:key
-> n:nonce
-> c0:counter{c0 + w <= max_size_t}
-> hi_fv:nat // n == hi_fv == len / (w * blocksize)
-> hi_f:size_nat{w * hi_fv <= hi_f}
-> i:nat{i < hi_fv}
-> b_v:lseq uint8 (w * blocksize)
-> j:nat{j < w * blocksize} ->
Lemma
(let... | false | null | true | encrypt_block_lemma_bs_i #w k n c0 i b_v j | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Hacl.Spec.Chacha20.Vec.lanes",
"Hacl.Spec.Chacha20.Vec.key",
"Hacl.Spec.Chacha20.Vec.nonce",
"Hacl.Spec.Chacha20.Vec.counter",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Prims.nat",
"Lib.IntTypes.size_nat",
"FStar.Mul.op_Star",
"Prims.op_LessThan... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val chacha20_map_blocks_multi_vec_equiv_pre_k:
#w:lanes
-> k:key
-> n:nonce
-> c0:counter{c0 + w <= max_size_t}
-> hi_fv:nat // n == hi_fv == len / (w * blocksize)
-> hi_f:size_nat{w * hi_fv <= hi_f}
-> i:nat{i < hi_fv}
-> b_v:lseq uint8 (w * blocksize)
-> j:nat{j < w * blocksize} ->
Lemma
(let... | [] | Hacl.Spec.Chacha20.Equiv.chacha20_map_blocks_multi_vec_equiv_pre_k | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k: Hacl.Spec.Chacha20.Vec.key ->
n: Hacl.Spec.Chacha20.Vec.nonce ->
c0: Hacl.Spec.Chacha20.Vec.counter{c0 + w <= Lib.IntTypes.max_size_t} ->
hi_fv: Prims.nat ->
hi_f: Lib.IntTypes.size_nat{w * hi_fv <= hi_f} ->
i: Prims.nat{i < hi_fv} ->
b_v: Lib.Sequence.lseq Lib.IntTypes.uint8 (w * Hacl.S... | {
"end_col": 44,
"end_line": 569,
"start_col": 2,
"start_line": 569
} |
FStar.Pervasives.Lemma | val chacha20_map_blocks_vec_equiv_pre_k0:
#w:lanes
-> k:key
-> n:nonce
-> c0:counter{c0 + w <= max_size_t}
-> hi_fv:size_nat{w * hi_fv + w <= max_size_t} // n == hi_fv == len / (w * blocksize)
-> rem:nat{rem < w * blocksize}
-> b_v:lseq uint8 rem
-> j:nat{j < rem / blocksize * blocksize} ->
Lemma
... | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let chacha20_map_blocks_vec_equiv_pre_k0 #w k n c0 hi_fv rem b_v j =
let st_v0 = chacha20_init #w k n c0 in
let st0 = Scalar.chacha20_init k n c0 in
let g_v = chacha20_encrypt_last st_v0 in
let f = Scalar.chacha20_encrypt_block st0 in
let g = Scalar.chacha20_encrypt_last st0 in
let blocksize_v = w * blocks... | val chacha20_map_blocks_vec_equiv_pre_k0:
#w:lanes
-> k:key
-> n:nonce
-> c0:counter{c0 + w <= max_size_t}
-> hi_fv:size_nat{w * hi_fv + w <= max_size_t} // n == hi_fv == len / (w * blocksize)
-> rem:nat{rem < w * blocksize}
-> b_v:lseq uint8 rem
-> j:nat{j < rem / blocksize * blocksize} ->
Lemma
... | false | null | true | let st_v0 = chacha20_init #w k n c0 in
let st0 = Scalar.chacha20_init k n c0 in
let g_v = chacha20_encrypt_last st_v0 in
let f = Scalar.chacha20_encrypt_block st0 in
let g = Scalar.chacha20_encrypt_last st0 in
let blocksize_v = w * blocksize in
let plain_v = create blocksize_v (u8 0) in
let plain_v = update_sub plain_v... | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Hacl.Spec.Chacha20.Vec.lanes",
"Hacl.Spec.Chacha20.Vec.key",
"Hacl.Spec.Chacha20.Vec.nonce",
"Hacl.Spec.Chacha20.Vec.counter",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Lib.IntTypes.size_nat",
"FStar.Mul.op_Star",
"Prims.nat",
"Prims.op_LessThan... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val chacha20_map_blocks_vec_equiv_pre_k0:
#w:lanes
-> k:key
-> n:nonce
-> c0:counter{c0 + w <= max_size_t}
-> hi_fv:size_nat{w * hi_fv + w <= max_size_t} // n == hi_fv == len / (w * blocksize)
-> rem:nat{rem < w * blocksize}
-> b_v:lseq uint8 rem
-> j:nat{j < rem / blocksize * blocksize} ->
Lemma
... | [] | Hacl.Spec.Chacha20.Equiv.chacha20_map_blocks_vec_equiv_pre_k0 | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k: Hacl.Spec.Chacha20.Vec.key ->
n: Hacl.Spec.Chacha20.Vec.nonce ->
c0: Hacl.Spec.Chacha20.Vec.counter{c0 + w <= Lib.IntTypes.max_size_t} ->
hi_fv: Lib.IntTypes.size_nat{w * hi_fv + w <= Lib.IntTypes.max_size_t} ->
rem: Prims.nat{rem < w * Hacl.Spec.Chacha20.Equiv.blocksize} ->
b_v: Lib.Sequenc... | {
"end_col": 5,
"end_line": 851,
"start_col": 68,
"start_line": 830
} |
FStar.Pervasives.Lemma | val encrypt_block_lemma_bs_i:
#w:lanes
-> k:key
-> n:nonce
-> c0:counter{c0 + w <= max_size_t}
-> c:counter{w * c <= max_size_t}
-> b_v:blocks w
-> j:nat{j < w * blocksize} ->
Lemma
(let st_v0 = chacha20_init #w k n c0 in
let st0 = Scalar.chacha20_init k n c0 in
Math.Lemmas.cancel_mul_div w bl... | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let encrypt_block_lemma_bs_i #w k n c0 c b_v j =
let st_v0 = chacha20_init #w k n c0 in
let st0 = Scalar.chacha20_init k n c0 in
Math.Lemmas.cancel_mul_div w blocksize;
let b = SeqLemmas.get_block_s #uint8 #(w * blocksize) blocksize b_v j in
encrypt_block_lemma_st0_i #w st_v0 c b_v j;
div_mul_lt blocksize j... | val encrypt_block_lemma_bs_i:
#w:lanes
-> k:key
-> n:nonce
-> c0:counter{c0 + w <= max_size_t}
-> c:counter{w * c <= max_size_t}
-> b_v:blocks w
-> j:nat{j < w * blocksize} ->
Lemma
(let st_v0 = chacha20_init #w k n c0 in
let st0 = Scalar.chacha20_init k n c0 in
Math.Lemmas.cancel_mul_div w bl... | false | null | true | let st_v0 = chacha20_init #w k n c0 in
let st0 = Scalar.chacha20_init k n c0 in
Math.Lemmas.cancel_mul_div w blocksize;
let b = SeqLemmas.get_block_s #uint8 #(w * blocksize) blocksize b_v j in
encrypt_block_lemma_st0_i #w st_v0 c b_v j;
div_mul_lt blocksize j w;
encrypt_block_scalar_lemma_i #w k n c0 c b (j / blocksize... | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Hacl.Spec.Chacha20.Vec.lanes",
"Hacl.Spec.Chacha20.Vec.key",
"Hacl.Spec.Chacha20.Vec.nonce",
"Hacl.Spec.Chacha20.Vec.counter",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"FStar.Mul.op_Star",
"Hacl.Spec.Chacha20.Vec.blocks",
"Prims.nat",
"Prims.op_... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val encrypt_block_lemma_bs_i:
#w:lanes
-> k:key
-> n:nonce
-> c0:counter{c0 + w <= max_size_t}
-> c:counter{w * c <= max_size_t}
-> b_v:blocks w
-> j:nat{j < w * blocksize} ->
Lemma
(let st_v0 = chacha20_init #w k n c0 in
let st0 = Scalar.chacha20_init k n c0 in
Math.Lemmas.cancel_mul_div w bl... | [] | Hacl.Spec.Chacha20.Equiv.encrypt_block_lemma_bs_i | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k: Hacl.Spec.Chacha20.Vec.key ->
n: Hacl.Spec.Chacha20.Vec.nonce ->
c0: Hacl.Spec.Chacha20.Vec.counter{c0 + w <= Lib.IntTypes.max_size_t} ->
c: Hacl.Spec.Chacha20.Vec.counter{w * c <= Lib.IntTypes.max_size_t} ->
b_v: Hacl.Spec.Chacha20.Vec.blocks w ->
j: Prims.nat{j < w * Hacl.Spec.Chacha20.Equ... | {
"end_col": 60,
"end_line": 548,
"start_col": 48,
"start_line": 541
} |
FStar.Pervasives.Lemma | val chacha20_map_blocks_vec_equiv_pre_k1:
#w:lanes
-> k:key
-> n:nonce
-> c0:counter{c0 + w <= max_size_t}
-> hi_fv:size_nat{w * hi_fv + w <= max_size_t} // n == hi_fv == len / (w * blocksize)
-> rem:nat{rem < w * blocksize}
-> b_v:lseq uint8 rem
-> j:nat{rem / blocksize * blocksize <= j /\ j < rem} -... | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let chacha20_map_blocks_vec_equiv_pre_k1 #w k n c0 hi_fv rem b_v j =
let st_v0 = chacha20_init #w k n c0 in
let st0 = Scalar.chacha20_init k n c0 in
let f_v = chacha20_encrypt_block st_v0 in
let g_v = chacha20_encrypt_last st_v0 in
let f = Scalar.chacha20_encrypt_block st0 in
let g = Scalar.chacha20_encrypt... | val chacha20_map_blocks_vec_equiv_pre_k1:
#w:lanes
-> k:key
-> n:nonce
-> c0:counter{c0 + w <= max_size_t}
-> hi_fv:size_nat{w * hi_fv + w <= max_size_t} // n == hi_fv == len / (w * blocksize)
-> rem:nat{rem < w * blocksize}
-> b_v:lseq uint8 rem
-> j:nat{rem / blocksize * blocksize <= j /\ j < rem} -... | false | null | true | let st_v0 = chacha20_init #w k n c0 in
let st0 = Scalar.chacha20_init k n c0 in
let f_v = chacha20_encrypt_block st_v0 in
let g_v = chacha20_encrypt_last st_v0 in
let f = Scalar.chacha20_encrypt_block st0 in
let g = Scalar.chacha20_encrypt_last st0 in
let blocksize_v = w * blocksize in
let plain_v = create blocksize_v ... | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Hacl.Spec.Chacha20.Vec.lanes",
"Hacl.Spec.Chacha20.Vec.key",
"Hacl.Spec.Chacha20.Vec.nonce",
"Hacl.Spec.Chacha20.Vec.counter",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Lib.IntTypes.size_nat",
"FStar.Mul.op_Star",
"Prims.nat",
"Prims.op_LessThan... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val chacha20_map_blocks_vec_equiv_pre_k1:
#w:lanes
-> k:key
-> n:nonce
-> c0:counter{c0 + w <= max_size_t}
-> hi_fv:size_nat{w * hi_fv + w <= max_size_t} // n == hi_fv == len / (w * blocksize)
-> rem:nat{rem < w * blocksize}
-> b_v:lseq uint8 rem
-> j:nat{rem / blocksize * blocksize <= j /\ j < rem} -... | [] | Hacl.Spec.Chacha20.Equiv.chacha20_map_blocks_vec_equiv_pre_k1 | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k: Hacl.Spec.Chacha20.Vec.key ->
n: Hacl.Spec.Chacha20.Vec.nonce ->
c0: Hacl.Spec.Chacha20.Vec.counter{c0 + w <= Lib.IntTypes.max_size_t} ->
hi_fv: Lib.IntTypes.size_nat{w * hi_fv + w <= Lib.IntTypes.max_size_t} ->
rem: Prims.nat{rem < w * Hacl.Spec.Chacha20.Equiv.blocksize} ->
b_v: Lib.Sequenc... | {
"end_col": 5,
"end_line": 898,
"start_col": 68,
"start_line": 871
} |
FStar.Pervasives.Lemma | val line_lemma_i:
#w:lanes
-> a:idx -> b:idx -> d:idx
-> s:rotval U32 -> m:state w
-> i:nat{i < w} ->
Lemma ((transpose_state (line #w a b d s m)).[i] `Seq.equal` Scalar.line a b d s (transpose_state #w m).[i]) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Chacha20.Vec",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence.Lemmas",
"short_module": "SeqLemmas"
},
{
"abbrev": true,
"full_module": "Lib.Vec.Lemmas",
"short_module": "VecLemmas"
},
{
"abbrev":... | false | let line_lemma_i #w a b d s m0 i =
let m0_s = (transpose_state #w m0).[i] in
let m1 = m0.[a] <- m0.[a] +| m0.[b] in
let m1_s = m0_s.[a] <- m0_s.[a] +. m0_s.[b] in
eq_intro (transpose_state m1).[i] m1_s;
let m2 = m1.[d] <- (m1.[d] ^| m1.[a]) <<<| s in
let m2_s = m1_s.[d] <- (m1_s.[d] ^. m1_s.[a]) <<<. s in
... | val line_lemma_i:
#w:lanes
-> a:idx -> b:idx -> d:idx
-> s:rotval U32 -> m:state w
-> i:nat{i < w} ->
Lemma ((transpose_state (line #w a b d s m)).[i] `Seq.equal` Scalar.line a b d s (transpose_state #w m).[i])
let line_lemma_i #w a b d s m0 i = | false | null | true | let m0_s = (transpose_state #w m0).[ i ] in
let m1 = m0.[ a ] <- m0.[ a ] +| m0.[ b ] in
let m1_s = m0_s.[ a ] <- m0_s.[ a ] +. m0_s.[ b ] in
eq_intro (transpose_state m1).[ i ] m1_s;
let m2 = m1.[ d ] <- (m1.[ d ] ^| m1.[ a ]) <<<| s in
let m2_s = m1_s.[ d ] <- (m1_s.[ d ] ^. m1_s.[ a ]) <<<. s in
eq_intro (transpose_... | {
"checked_file": "Hacl.Spec.Chacha20.Equiv.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Vec.Lemmas.fsti.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntVector.fsti.checked",
... | [
"lemma"
] | [
"Hacl.Spec.Chacha20.Vec.lanes",
"Hacl.Spec.Chacha20.Vec.idx",
"Lib.IntTypes.rotval",
"Lib.IntTypes.U32",
"Hacl.Spec.Chacha20.Vec.state",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.Sequence.eq_intro",
"Lib.IntTypes.uint32",
"Lib.Sequence.op_String_Access",
"Lib.Sequence.lseq",
"Hacl.... | [] | module Hacl.Spec.Chacha20.Equiv
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.IntVector
module Scalar = Spec.Chacha20
module Lemmas = Hacl.Spec.Chacha20.Lemmas
module VecLemmas = Lib.Vec.Lemmas
module SeqLemmas = Lib.Sequence.Lemmas
open Hacl.Spec.Chacha20.Vec
#reset-options "--... | false | false | Hacl.Spec.Chacha20.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val line_lemma_i:
#w:lanes
-> a:idx -> b:idx -> d:idx
-> s:rotval U32 -> m:state w
-> i:nat{i < w} ->
Lemma ((transpose_state (line #w a b d s m)).[i] `Seq.equal` Scalar.line a b d s (transpose_state #w m).[i]) | [] | Hacl.Spec.Chacha20.Equiv.line_lemma_i | {
"file_name": "code/chacha20/Hacl.Spec.Chacha20.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Hacl.Spec.Chacha20.Vec.idx ->
b: Hacl.Spec.Chacha20.Vec.idx ->
d: Hacl.Spec.Chacha20.Vec.idx ->
s: Lib.IntTypes.rotval Lib.IntTypes.U32 ->
m: Hacl.Spec.Chacha20.Vec.state w ->
i: Prims.nat{i < w}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.equal (Hacl.Spec.Chacha20.Vec.tran... | {
"end_col": 40,
"end_line": 156,
"start_col": 34,
"start_line": 149
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastWide",
"short_module": "FW"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastHybrid",
"short_module": "FH"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
... | false | let t64_no_mod = TD_Buffer TUInt64 TUInt64 ({modified=false; strict_disjointness=false; taint=MS.Secret}) | let t64_no_mod = | false | null | false | TD_Buffer TUInt64 TUInt64 ({ modified = false; strict_disjointness = false; taint = MS.Secret }) | {
"checked_file": "Vale.Stdcalls.X64.Fmul.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Intero... | [
"total"
] | [
"Vale.Interop.Base.TD_Buffer",
"Vale.Arch.HeapTypes_s.TUInt64",
"Vale.Interop.Base.Mkbuffer_qualifiers",
"Vale.Arch.HeapTypes_s.Secret"
] | [] | module Vale.Stdcalls.X64.Fmul
open FStar.Mul
val z3rlimit_hack (x:nat) : squash (x < x + x + 1)
#reset-options "--z3rlimit 50"
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X6... | false | true | Vale.Stdcalls.X64.Fmul.fsti | {
"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_el... | null | val t64_no_mod : Vale.Interop.Base.td | [] | Vale.Stdcalls.X64.Fmul.t64_no_mod | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.Fmul.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.Interop.Base.td | {
"end_col": 105,
"end_line": 43,
"start_col": 17,
"start_line": 43
} | |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastWide",
"short_module": "FW"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastHybrid",
"short_module": "FH"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
... | false | let code_Fmul1 = FH.va_code_Fmul1_stdcall IA.win | let code_Fmul1 = | false | null | false | FH.va_code_Fmul1_stdcall IA.win | {
"checked_file": "Vale.Stdcalls.X64.Fmul.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Intero... | [
"total"
] | [
"Vale.Curve25519.X64.FastHybrid.va_code_Fmul1_stdcall",
"Vale.Interop.Assumptions.win"
] | [] | module Vale.Stdcalls.X64.Fmul
open FStar.Mul
val z3rlimit_hack (x:nat) : squash (x < x + x + 1)
#reset-options "--z3rlimit 50"
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X6... | false | true | Vale.Stdcalls.X64.Fmul.fsti | {
"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_el... | null | val code_Fmul1 : Vale.X64.Decls.va_code | [] | Vale.Stdcalls.X64.Fmul.code_Fmul1 | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.Fmul.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Decls.va_code | {
"end_col": 48,
"end_line": 280,
"start_col": 17,
"start_line": 280
} | |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastWide",
"short_module": "FW"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastHybrid",
"short_module": "FH"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
... | false | let t64_mod = TD_Buffer TUInt64 TUInt64 default_bq | let t64_mod = | false | null | false | TD_Buffer TUInt64 TUInt64 default_bq | {
"checked_file": "Vale.Stdcalls.X64.Fmul.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Intero... | [
"total"
] | [
"Vale.Interop.Base.TD_Buffer",
"Vale.Arch.HeapTypes_s.TUInt64",
"Vale.Interop.Base.default_bq"
] | [] | module Vale.Stdcalls.X64.Fmul
open FStar.Mul
val z3rlimit_hack (x:nat) : squash (x < x + x + 1)
#reset-options "--z3rlimit 50"
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X6... | false | true | Vale.Stdcalls.X64.Fmul.fsti | {
"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_el... | null | val t64_mod : Vale.Interop.Base.td | [] | Vale.Stdcalls.X64.Fmul.t64_mod | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.Fmul.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.Interop.Base.td | {
"end_col": 50,
"end_line": 41,
"start_col": 14,
"start_line": 41
} | |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastWide",
"short_module": "FW"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastHybrid",
"short_module": "FH"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
... | false | let b64 = buf_t TUInt64 TUInt64 | let b64 = | false | null | false | buf_t TUInt64 TUInt64 | {
"checked_file": "Vale.Stdcalls.X64.Fmul.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Intero... | [
"total"
] | [
"Vale.Interop.Base.buf_t",
"Vale.Arch.HeapTypes_s.TUInt64"
] | [] | module Vale.Stdcalls.X64.Fmul
open FStar.Mul
val z3rlimit_hack (x:nat) : squash (x < x + x + 1)
#reset-options "--z3rlimit 50"
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X6... | false | true | Vale.Stdcalls.X64.Fmul.fsti | {
"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_el... | null | val b64 : Type0 | [] | Vale.Stdcalls.X64.Fmul.b64 | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.Fmul.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 31,
"end_line": 39,
"start_col": 10,
"start_line": 39
} | |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastWide",
"short_module": "FW"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastHybrid",
"short_module": "FH"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
... | false | let tuint64 = TD_Base TUInt64 | let tuint64 = | false | null | false | TD_Base TUInt64 | {
"checked_file": "Vale.Stdcalls.X64.Fmul.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Intero... | [
"total"
] | [
"Vale.Interop.Base.TD_Base",
"Vale.Arch.HeapTypes_s.TUInt64"
] | [] | module Vale.Stdcalls.X64.Fmul
open FStar.Mul
val z3rlimit_hack (x:nat) : squash (x < x + x + 1)
#reset-options "--z3rlimit 50"
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X6... | false | true | Vale.Stdcalls.X64.Fmul.fsti | {
"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_el... | null | val tuint64 : Vale.Interop.Base.td | [] | Vale.Stdcalls.X64.Fmul.tuint64 | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.Fmul.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.Interop.Base.td | {
"end_col": 29,
"end_line": 45,
"start_col": 14,
"start_line": 45
} | |
Prims.Tot | val fmul_pre:VSig.vale_pre fmul_dom | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastWide",
"short_module": "FW"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastHybrid",
"short_module": "FH"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
... | false | let fmul_pre : VSig.vale_pre fmul_dom =
fun (c:V.va_code)
(tmp:b64)
(f1:b64)
(out:b64)
(f2:b64)
(va_s0:V.va_state) ->
FW.va_req_Fmul_stdcall c va_s0 IA.win
(as_vale_buffer tmp) (as_vale_buffer f1) (as_vale_buffer out) (as_vale_buffer f2) | val fmul_pre:VSig.vale_pre fmul_dom
let fmul_pre:VSig.vale_pre fmul_dom = | false | null | false | fun (c: V.va_code) (tmp: b64) (f1: b64) (out: b64) (f2: b64) (va_s0: V.va_state) ->
FW.va_req_Fmul_stdcall c
va_s0
IA.win
(as_vale_buffer tmp)
(as_vale_buffer f1)
(as_vale_buffer out)
(as_vale_buffer f2) | {
"checked_file": "Vale.Stdcalls.X64.Fmul.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Intero... | [
"total"
] | [
"Vale.X64.Decls.va_code",
"Vale.Stdcalls.X64.Fmul.b64",
"Vale.X64.Decls.va_state",
"Vale.Curve25519.X64.FastWide.va_req_Fmul_stdcall",
"Vale.Interop.Assumptions.win",
"Vale.X64.MemoryAdapters.as_vale_buffer",
"Vale.Arch.HeapTypes_s.TUInt64",
"Prims.prop"
] | [] | module Vale.Stdcalls.X64.Fmul
open FStar.Mul
val z3rlimit_hack (x:nat) : squash (x < x + x + 1)
#reset-options "--z3rlimit 50"
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X6... | false | true | Vale.Stdcalls.X64.Fmul.fsti | {
"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_el... | null | val fmul_pre:VSig.vale_pre fmul_dom | [] | Vale.Stdcalls.X64.Fmul.fmul_pre | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.Fmul.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.AsLowStar.ValeSig.vale_pre Vale.Stdcalls.X64.Fmul.fmul_dom | {
"end_col": 89,
"end_line": 63,
"start_col": 2,
"start_line": 56
} |
Prims.Tot | val fmul_post:VSig.vale_post fmul_dom | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastWide",
"short_module": "FW"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastHybrid",
"short_module": "FH"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
... | false | let fmul_post : VSig.vale_post fmul_dom =
fun (c:V.va_code)
(tmp:b64)
(f1:b64)
(out:b64)
(f2:b64)
(va_s0:V.va_state)
(va_s1:V.va_state)
(f:V.va_fuel) ->
FW.va_ens_Fmul_stdcall c va_s0 IA.win (as_vale_buffer tmp) (as_vale_buffer f1) (as_vale_buffer out) (as_vale_buffer f2) va_s1 f | val fmul_post:VSig.vale_post fmul_dom
let fmul_post:VSig.vale_post fmul_dom = | false | null | false | fun
(c: V.va_code)
(tmp: b64)
(f1: b64)
(out: b64)
(f2: b64)
(va_s0: V.va_state)
(va_s1: V.va_state)
(f: V.va_fuel)
->
FW.va_ens_Fmul_stdcall c
va_s0
IA.win
(as_vale_buffer tmp)
(as_vale_buffer f1)
(as_vale_buffer out)
(as_vale_buffer f2)
va_s1
f | {
"checked_file": "Vale.Stdcalls.X64.Fmul.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Intero... | [
"total"
] | [
"Vale.X64.Decls.va_code",
"Vale.Stdcalls.X64.Fmul.b64",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_fuel",
"Vale.Curve25519.X64.FastWide.va_ens_Fmul_stdcall",
"Vale.Interop.Assumptions.win",
"Vale.X64.MemoryAdapters.as_vale_buffer",
"Vale.Arch.HeapTypes_s.TUInt64",
"Prims.prop"
] | [] | module Vale.Stdcalls.X64.Fmul
open FStar.Mul
val z3rlimit_hack (x:nat) : squash (x < x + x + 1)
#reset-options "--z3rlimit 50"
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X6... | false | true | Vale.Stdcalls.X64.Fmul.fsti | {
"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_el... | null | val fmul_post:VSig.vale_post fmul_dom | [] | Vale.Stdcalls.X64.Fmul.fmul_post | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.Fmul.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.AsLowStar.ValeSig.vale_post Vale.Stdcalls.X64.Fmul.fmul_dom | {
"end_col": 133,
"end_line": 75,
"start_col": 2,
"start_line": 67
} |
Prims.Tot | val fmul2_pre:VSig.vale_pre fmul_dom | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastWide",
"short_module": "FW"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastHybrid",
"short_module": "FH"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
... | false | let fmul2_pre : VSig.vale_pre fmul_dom =
fun (c:V.va_code)
(tmp:b64)
(f1:b64)
(out:b64)
(f2:b64)
(va_s0:V.va_state) ->
FW.va_req_Fmul2_stdcall c va_s0 IA.win
(as_vale_buffer tmp) (as_vale_buffer f1) (as_vale_buffer out) (as_vale_buffer f2) | val fmul2_pre:VSig.vale_pre fmul_dom
let fmul2_pre:VSig.vale_pre fmul_dom = | false | null | false | fun (c: V.va_code) (tmp: b64) (f1: b64) (out: b64) (f2: b64) (va_s0: V.va_state) ->
FW.va_req_Fmul2_stdcall c
va_s0
IA.win
(as_vale_buffer tmp)
(as_vale_buffer f1)
(as_vale_buffer out)
(as_vale_buffer f2) | {
"checked_file": "Vale.Stdcalls.X64.Fmul.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Intero... | [
"total"
] | [
"Vale.X64.Decls.va_code",
"Vale.Stdcalls.X64.Fmul.b64",
"Vale.X64.Decls.va_state",
"Vale.Curve25519.X64.FastWide.va_req_Fmul2_stdcall",
"Vale.Interop.Assumptions.win",
"Vale.X64.MemoryAdapters.as_vale_buffer",
"Vale.Arch.HeapTypes_s.TUInt64",
"Prims.prop"
] | [] | module Vale.Stdcalls.X64.Fmul
open FStar.Mul
val z3rlimit_hack (x:nat) : squash (x < x + x + 1)
#reset-options "--z3rlimit 50"
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X6... | false | true | Vale.Stdcalls.X64.Fmul.fsti | {
"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_el... | null | val fmul2_pre:VSig.vale_pre fmul_dom | [] | Vale.Stdcalls.X64.Fmul.fmul2_pre | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.Fmul.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.AsLowStar.ValeSig.vale_pre Vale.Stdcalls.X64.Fmul.fmul_dom | {
"end_col": 89,
"end_line": 142,
"start_col": 2,
"start_line": 135
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastWide",
"short_module": "FW"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastHybrid",
"short_module": "FH"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
... | false | let code_Fmul = FW.va_code_Fmul_stdcall IA.win | let code_Fmul = | false | null | false | FW.va_code_Fmul_stdcall IA.win | {
"checked_file": "Vale.Stdcalls.X64.Fmul.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Intero... | [
"total"
] | [
"Vale.Curve25519.X64.FastWide.va_code_Fmul_stdcall",
"Vale.Interop.Assumptions.win"
] | [] | module Vale.Stdcalls.X64.Fmul
open FStar.Mul
val z3rlimit_hack (x:nat) : squash (x < x + x + 1)
#reset-options "--z3rlimit 50"
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X6... | false | true | Vale.Stdcalls.X64.Fmul.fsti | {
"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_el... | null | val code_Fmul : Vale.X64.Decls.va_code | [] | Vale.Stdcalls.X64.Fmul.code_Fmul | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.Fmul.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Decls.va_code | {
"end_col": 46,
"end_line": 118,
"start_col": 16,
"start_line": 118
} | |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastWide",
"short_module": "FW"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastHybrid",
"short_module": "FH"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
... | false | let uint64 = UInt64.t | let uint64 = | false | null | false | UInt64.t | {
"checked_file": "Vale.Stdcalls.X64.Fmul.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Intero... | [
"total"
] | [
"FStar.UInt64.t"
] | [] | module Vale.Stdcalls.X64.Fmul
open FStar.Mul
val z3rlimit_hack (x:nat) : squash (x < x + x + 1)
#reset-options "--z3rlimit 50"
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X6... | false | true | Vale.Stdcalls.X64.Fmul.fsti | {
"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_el... | null | val uint64 : Prims.eqtype | [] | Vale.Stdcalls.X64.Fmul.uint64 | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.Fmul.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.eqtype | {
"end_col": 21,
"end_line": 30,
"start_col": 13,
"start_line": 30
} | |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastWide",
"short_module": "FW"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastHybrid",
"short_module": "FH"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
... | false | let code_Fmul2 = FW.va_code_Fmul2_stdcall IA.win | let code_Fmul2 = | false | null | false | FW.va_code_Fmul2_stdcall IA.win | {
"checked_file": "Vale.Stdcalls.X64.Fmul.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Intero... | [
"total"
] | [
"Vale.Curve25519.X64.FastWide.va_code_Fmul2_stdcall",
"Vale.Interop.Assumptions.win"
] | [] | module Vale.Stdcalls.X64.Fmul
open FStar.Mul
val z3rlimit_hack (x:nat) : squash (x < x + x + 1)
#reset-options "--z3rlimit 50"
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X6... | false | true | Vale.Stdcalls.X64.Fmul.fsti | {
"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_el... | null | val code_Fmul2 : Vale.X64.Decls.va_code | [] | Vale.Stdcalls.X64.Fmul.code_Fmul2 | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.Fmul.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Decls.va_code | {
"end_col": 48,
"end_line": 197,
"start_col": 17,
"start_line": 197
} | |
Prims.Tot | val fmul2_post:VSig.vale_post fmul_dom | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastWide",
"short_module": "FW"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastHybrid",
"short_module": "FH"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
... | false | let fmul2_post : VSig.vale_post fmul_dom =
fun (c:V.va_code)
(tmp:b64)
(f1:b64)
(out:b64)
(f2:b64)
(va_s0:V.va_state)
(va_s1:V.va_state)
(f:V.va_fuel) ->
FW.va_ens_Fmul2_stdcall c va_s0 IA.win (as_vale_buffer tmp) (as_vale_buffer f1) (as_vale_buffer out) (as_vale_buffer f2) va_s1 f | val fmul2_post:VSig.vale_post fmul_dom
let fmul2_post:VSig.vale_post fmul_dom = | false | null | false | fun
(c: V.va_code)
(tmp: b64)
(f1: b64)
(out: b64)
(f2: b64)
(va_s0: V.va_state)
(va_s1: V.va_state)
(f: V.va_fuel)
->
FW.va_ens_Fmul2_stdcall c
va_s0
IA.win
(as_vale_buffer tmp)
(as_vale_buffer f1)
(as_vale_buffer out)
(as_vale_buffer f2)
va_s1
f | {
"checked_file": "Vale.Stdcalls.X64.Fmul.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Intero... | [
"total"
] | [
"Vale.X64.Decls.va_code",
"Vale.Stdcalls.X64.Fmul.b64",
"Vale.X64.Decls.va_state",
"Vale.X64.Decls.va_fuel",
"Vale.Curve25519.X64.FastWide.va_ens_Fmul2_stdcall",
"Vale.Interop.Assumptions.win",
"Vale.X64.MemoryAdapters.as_vale_buffer",
"Vale.Arch.HeapTypes_s.TUInt64",
"Prims.prop"
] | [] | module Vale.Stdcalls.X64.Fmul
open FStar.Mul
val z3rlimit_hack (x:nat) : squash (x < x + x + 1)
#reset-options "--z3rlimit 50"
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X6... | false | true | Vale.Stdcalls.X64.Fmul.fsti | {
"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_el... | null | val fmul2_post:VSig.vale_post fmul_dom | [] | Vale.Stdcalls.X64.Fmul.fmul2_post | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.Fmul.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.AsLowStar.ValeSig.vale_post Vale.Stdcalls.X64.Fmul.fmul_dom | {
"end_col": 134,
"end_line": 154,
"start_col": 2,
"start_line": 146
} |
Prims.Tot | val as_t (#a: Type) (x: normal a) : a | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastWide",
"short_module": "FW"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastHybrid",
"short_module": "FH"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
... | false | let as_t (#a:Type) (x:normal a) : a = x | val as_t (#a: Type) (x: normal a) : a
let as_t (#a: Type) (x: normal a) : a = | false | null | false | x | {
"checked_file": "Vale.Stdcalls.X64.Fmul.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Intero... | [
"total"
] | [
"Vale.Interop.Base.normal"
] | [] | module Vale.Stdcalls.X64.Fmul
open FStar.Mul
val z3rlimit_hack (x:nat) : squash (x < x + x + 1)
#reset-options "--z3rlimit 50"
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X6... | false | false | Vale.Stdcalls.X64.Fmul.fsti | {
"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_el... | null | val as_t (#a: Type) (x: normal a) : a | [] | Vale.Stdcalls.X64.Fmul.as_t | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.Fmul.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Vale.Interop.Base.normal a -> a | {
"end_col": 39,
"end_line": 34,
"start_col": 38,
"start_line": 34
} |
Prims.Tot | val as_normal_t (#a: Type) (x: a) : normal a | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastWide",
"short_module": "FW"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastHybrid",
"short_module": "FH"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
... | false | let as_normal_t (#a:Type) (x:a) : normal a = x | val as_normal_t (#a: Type) (x: a) : normal a
let as_normal_t (#a: Type) (x: a) : normal a = | false | null | false | x | {
"checked_file": "Vale.Stdcalls.X64.Fmul.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Intero... | [
"total"
] | [
"Vale.Interop.Base.normal"
] | [] | module Vale.Stdcalls.X64.Fmul
open FStar.Mul
val z3rlimit_hack (x:nat) : squash (x < x + x + 1)
#reset-options "--z3rlimit 50"
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X6... | false | false | Vale.Stdcalls.X64.Fmul.fsti | {
"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_el... | null | val as_normal_t (#a: Type) (x: a) : normal a | [] | Vale.Stdcalls.X64.Fmul.as_normal_t | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.Fmul.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: a -> Vale.Interop.Base.normal a | {
"end_col": 46,
"end_line": 36,
"start_col": 45,
"start_line": 36
} |
Prims.Tot | val fmul_dom:IX64.arity_ok_stdcall td | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastWide",
"short_module": "FW"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastHybrid",
"short_module": "FH"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
... | false | let fmul_dom: IX64.arity_ok_stdcall td =
let y = [t64_mod; t64_no_mod; t64_mod; t64_no_mod] in
assert_norm (List.length y = 4);
y | val fmul_dom:IX64.arity_ok_stdcall td
let fmul_dom:IX64.arity_ok_stdcall td = | false | null | false | let y = [t64_mod; t64_no_mod; t64_mod; t64_no_mod] in
assert_norm (List.length y = 4);
y | {
"checked_file": "Vale.Stdcalls.X64.Fmul.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Intero... | [
"total"
] | [
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.List.Tot.Base.length",
"Vale.Interop.Base.td",
"Prims.list",
"Prims.Cons",
"Vale.Stdcalls.X64.Fmul.t64_mod",
"Vale.Stdcalls.X64.Fmul.t64_no_mod",
"Prims.Nil"
] | [] | module Vale.Stdcalls.X64.Fmul
open FStar.Mul
val z3rlimit_hack (x:nat) : squash (x < x + x + 1)
#reset-options "--z3rlimit 50"
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X6... | false | true | Vale.Stdcalls.X64.Fmul.fsti | {
"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_el... | null | val fmul_dom:IX64.arity_ok_stdcall td | [] | Vale.Stdcalls.X64.Fmul.fmul_dom | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.Fmul.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.Interop.X64.arity_ok_stdcall Vale.Interop.Base.td | {
"end_col": 3,
"end_line": 51,
"start_col": 40,
"start_line": 48
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastWide",
"short_module": "FW"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastHybrid",
"short_module": "FH"
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
... | false | let lowstar_fmul_t =
assert_norm (List.length fmul_dom + List.length ([]<:list arg) <= 4);
IX64.as_lowstar_sig_t_weak_stdcall
code_Fmul
fmul_dom
[]
_
_
(W.mk_prediction code_Fmul fmul_dom [] (fmul_lemma code_Fmul IA.win)) | let lowstar_fmul_t = | false | null | false | assert_norm (List.length fmul_dom + List.length ([] <: list arg) <= 4);
IX64.as_lowstar_sig_t_weak_stdcall code_Fmul
fmul_dom
[]
_
_
(W.mk_prediction code_Fmul fmul_dom [] (fmul_lemma code_Fmul IA.win)) | {
"checked_file": "Vale.Stdcalls.X64.Fmul.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Intero... | [
"total"
] | [
"Vale.Interop.X64.as_lowstar_sig_t_weak_stdcall",
"Vale.Stdcalls.X64.Fmul.code_Fmul",
"Vale.Stdcalls.X64.Fmul.fmul_dom",
"Prims.Nil",
"Vale.Interop.Base.arg",
"Vale.AsLowStar.Wrapper.pre_rel_generic",
"Vale.Interop.X64.max_stdcall",
"Vale.Interop.X64.arg_reg_stdcall",
"Vale.Stdcalls.X64.Fmul.fmul_pr... | [] | module Vale.Stdcalls.X64.Fmul
open FStar.Mul
val z3rlimit_hack (x:nat) : squash (x < x + x + 1)
#reset-options "--z3rlimit 50"
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X6... | false | true | Vale.Stdcalls.X64.Fmul.fsti | {
"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_el... | null | val lowstar_fmul_t : Type0 | [] | Vale.Stdcalls.X64.Fmul.lowstar_fmul_t | {
"file_name": "vale/code/arch/x64/interop/Vale.Stdcalls.X64.Fmul.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 73,
"end_line": 130,
"start_col": 2,
"start_line": 123
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.