Datasets:

microsoft

/

FStarDataSet

like 2

Follow

Microsoft 4,773

Prims.Tot

val generate_sha2_512: generate_st SHA2_512

let generate_sha2_512 = mk_generate EverCrypt.HMAC.compute_sha2_512

val generate_sha2_512: generate_st SHA2_512 let generate_sha2_512 =

mk_generate EverCrypt.HMAC.compute_sha2_512

module EverCrypt.DRBG open FStar.HyperStack.ST open Lib.IntTypes open Spec.Hash.Definitions module HS = FStar.HyperStack module B = LowStar.Buffer module S = Spec.HMAC_DRBG open Hacl.HMAC_DRBG open Lib.RandomBuffer.System open LowStar.BufferOps friend Hacl.HMAC_DRBG friend EverCrypt.HMAC #set-options "--max_ifuel 0 --max_fuel 0 --z3rlimit 50" /// Some duplication from Hacl.HMAC_DRBG because we don't want clients to depend on it /// /// Respects EverCrypt convention and reverses order of buf_len, buf arguments [@CAbstractStruct] noeq type state_s: supported_alg -> Type0 = | SHA1_s : state SHA1 -> state_s SHA1 | SHA2_256_s: state SHA2_256 -> state_s SHA2_256 | SHA2_384_s: state SHA2_384 -> state_s SHA2_384 | SHA2_512_s: state SHA2_512 -> state_s SHA2_512 let invert_state_s (a:supported_alg): Lemma (requires True) (ensures inversion (state_s a)) [ SMTPat (state_s a) ] = allow_inversion (state_s a) /// Only call this function in extracted code with a known `a` inline_for_extraction noextract let p #a (s:state_s a) : Hacl.HMAC_DRBG.state a = match a with | SHA1 -> let SHA1_s p = s in p | SHA2_256 -> let SHA2_256_s p = s in p | SHA2_384 -> let SHA2_384_s p = s in p | SHA2_512 -> let SHA2_512_s p = s in p let freeable_s #a st = freeable (p st) let footprint_s #a st = footprint (p st) let invariant_s #a st h = invariant (p st) h let repr #a st h = let st = B.get h st 0 in repr (p st) h let loc_includes_union_l_footprint_s #a l1 l2 st = B.loc_includes_union_l l1 l2 (footprint_s st) let invariant_loc_in_footprint #a st m = () let frame_invariant #a l st h0 h1 = () /// State allocation // Would like to specialize alloca in each branch, but two calls to StackInline // functions in the same block lead to variable redefinitions at extraction. let alloca a = let st = match a with | SHA1 -> SHA1_s (alloca a) | SHA2_256 -> SHA2_256_s (alloca a) | SHA2_384 -> SHA2_384_s (alloca a) | SHA2_512 -> SHA2_512_s (alloca a) in B.alloca st 1ul let create_in a r = let st = match a with | SHA1 -> SHA1_s (create_in SHA1 r) | SHA2_256 -> SHA2_256_s (create_in SHA2_256 r) | SHA2_384 -> SHA2_384_s (create_in SHA2_384 r) | SHA2_512 -> SHA2_512_s (create_in SHA2_512 r) in B.malloc r st 1ul let create a = create_in a HS.root /// Instantiate function inline_for_extraction noextract val mk_instantiate: #a:supported_alg -> EverCrypt.HMAC.compute_st a -> instantiate_st a let mk_instantiate #a hmac st personalization_string personalization_string_len = if personalization_string_len >. max_personalization_string_length then false else let entropy_input_len = min_length a in let nonce_len = min_length a /. 2ul in let min_entropy = entropy_input_len +! nonce_len in push_frame(); assert_norm (range (v min_entropy) U32); let entropy = B.alloca (u8 0) min_entropy in let ok = randombytes entropy min_entropy in let result = if not ok then false else begin let entropy_input = B.sub entropy 0ul entropy_input_len in let nonce = B.sub entropy entropy_input_len nonce_len in S.hmac_input_bound a; let st_s = !*st in mk_instantiate hmac (p st_s) entropy_input_len entropy_input nonce_len nonce personalization_string_len personalization_string; true end in pop_frame(); result (** @type: true *) val instantiate_sha1 : instantiate_st SHA1 (** @type: true *) val instantiate_sha2_256: instantiate_st SHA2_256 (** @type: true *) val instantiate_sha2_384: instantiate_st SHA2_384 (** @type: true *) val instantiate_sha2_512: instantiate_st SHA2_512 let instantiate_sha1 = mk_instantiate EverCrypt.HMAC.compute_sha1 let instantiate_sha2_256 = mk_instantiate EverCrypt.HMAC.compute_sha2_256 let instantiate_sha2_384 = mk_instantiate EverCrypt.HMAC.compute_sha2_384 let instantiate_sha2_512 = mk_instantiate EverCrypt.HMAC.compute_sha2_512 /// Reseed function inline_for_extraction noextract val mk_reseed: #a:supported_alg -> EverCrypt.HMAC.compute_st a -> reseed_st a let mk_reseed #a hmac st additional_input additional_input_len = if additional_input_len >. max_additional_input_length then false else let entropy_input_len = min_length a in push_frame(); let entropy_input = B.alloca (u8 0) entropy_input_len in let ok = randombytes entropy_input entropy_input_len in let result = if not ok then false else begin S.hmac_input_bound a; let st_s = !*st in mk_reseed hmac (p st_s) entropy_input_len entropy_input additional_input_len additional_input; true end in pop_frame(); result (** @type: true *) val reseed_sha1 : reseed_st SHA1 (** @type: true *) val reseed_sha2_256: reseed_st SHA2_256 (** @type: true *) val reseed_sha2_384: reseed_st SHA2_384 (** @type: true *) val reseed_sha2_512: reseed_st SHA2_512 let reseed_sha1 = mk_reseed EverCrypt.HMAC.compute_sha1 let reseed_sha2_256 = mk_reseed EverCrypt.HMAC.compute_sha2_256 let reseed_sha2_384 = mk_reseed EverCrypt.HMAC.compute_sha2_384 let reseed_sha2_512 = mk_reseed EverCrypt.HMAC.compute_sha2_512 /// Generate function inline_for_extraction noextract val mk_generate: #a:supported_alg -> EverCrypt.HMAC.compute_st a -> generate_st a let mk_generate #a hmac output st n additional_input additional_input_len = if additional_input_len >. max_additional_input_length || n >. max_output_length then false else ( push_frame(); let ok = mk_reseed hmac st additional_input additional_input_len in let result = if not ok then false else begin let st_s = !*st in let b = mk_generate hmac output (p st_s) n additional_input_len additional_input in b (* This used to be true, which is fishy *) end in let h1 = get () in pop_frame(); let h2 = get () in frame_invariant (B.loc_all_regions_from false (HS.get_tip h1)) st h1 h2; result ) (** @type: true *) val generate_sha1 : generate_st SHA1 (** @type: true *) val generate_sha2_256: generate_st SHA2_256 (** @type: true *) val generate_sha2_384: generate_st SHA2_384 (** @type: true *) val generate_sha2_512: generate_st SHA2_512 let generate_sha1 = mk_generate EverCrypt.HMAC.compute_sha1 let generate_sha2_256 = mk_generate EverCrypt.HMAC.compute_sha2_256

EverCrypt.DRBG.fst

val generate_sha2_512: generate_st SHA2_512

EverCrypt.DRBG.generate_sha2_512

EverCrypt.DRBG.generate_st Spec.Hash.Definitions.SHA2_512

Prims.Tot

val mk_uninstantiate: a:supported_alg -> uninstantiate_st a

let mk_uninstantiate a st = let st_s:state_s a = !*st in let s:Hacl.HMAC_DRBG.state a = p st_s in let k:B.buffer uint8 = s.k in let v:B.buffer uint8 = s.v in let ctr:B.buffer size_t = s.reseed_counter in assert (B.disjoint k v /\ B.disjoint k ctr /\ B.disjoint v ctr); assert (B.loc_disjoint (B.loc_addr_of_buffer st) (footprint_s st_s)); Lib.Memzero0.memzero k (hash_len a); Lib.Memzero0.memzero v (hash_len a); ctr.(0ul) <- 0ul; B.free k; B.free v; B.free ctr; B.free st

val mk_uninstantiate: a:supported_alg -> uninstantiate_st a let mk_uninstantiate a st =

let st_s:state_s a = !*st in let s:Hacl.HMAC_DRBG.state a = p st_s in let k:B.buffer uint8 = s.k in let v:B.buffer uint8 = s.v in let ctr:B.buffer size_t = s.reseed_counter in assert (B.disjoint k v /\ B.disjoint k ctr /\ B.disjoint v ctr); assert (B.loc_disjoint (B.loc_addr_of_buffer st) (footprint_s st_s)); Lib.Memzero0.memzero k (hash_len a); Lib.Memzero0.memzero v (hash_len a); ctr.(0ul) <- 0ul; B.free k; B.free v; B.free ctr; B.free st

module EverCrypt.DRBG open FStar.HyperStack.ST open Lib.IntTypes open Spec.Hash.Definitions module HS = FStar.HyperStack module B = LowStar.Buffer module S = Spec.HMAC_DRBG open Hacl.HMAC_DRBG open Lib.RandomBuffer.System open LowStar.BufferOps friend Hacl.HMAC_DRBG friend EverCrypt.HMAC #set-options "--max_ifuel 0 --max_fuel 0 --z3rlimit 50" /// Some duplication from Hacl.HMAC_DRBG because we don't want clients to depend on it /// /// Respects EverCrypt convention and reverses order of buf_len, buf arguments [@CAbstractStruct] noeq type state_s: supported_alg -> Type0 = | SHA1_s : state SHA1 -> state_s SHA1 | SHA2_256_s: state SHA2_256 -> state_s SHA2_256 | SHA2_384_s: state SHA2_384 -> state_s SHA2_384 | SHA2_512_s: state SHA2_512 -> state_s SHA2_512 let invert_state_s (a:supported_alg): Lemma (requires True) (ensures inversion (state_s a)) [ SMTPat (state_s a) ] = allow_inversion (state_s a) /// Only call this function in extracted code with a known `a` inline_for_extraction noextract let p #a (s:state_s a) : Hacl.HMAC_DRBG.state a = match a with | SHA1 -> let SHA1_s p = s in p | SHA2_256 -> let SHA2_256_s p = s in p | SHA2_384 -> let SHA2_384_s p = s in p | SHA2_512 -> let SHA2_512_s p = s in p let freeable_s #a st = freeable (p st) let footprint_s #a st = footprint (p st) let invariant_s #a st h = invariant (p st) h let repr #a st h = let st = B.get h st 0 in repr (p st) h let loc_includes_union_l_footprint_s #a l1 l2 st = B.loc_includes_union_l l1 l2 (footprint_s st) let invariant_loc_in_footprint #a st m = () let frame_invariant #a l st h0 h1 = () /// State allocation // Would like to specialize alloca in each branch, but two calls to StackInline // functions in the same block lead to variable redefinitions at extraction. let alloca a = let st = match a with | SHA1 -> SHA1_s (alloca a) | SHA2_256 -> SHA2_256_s (alloca a) | SHA2_384 -> SHA2_384_s (alloca a) | SHA2_512 -> SHA2_512_s (alloca a) in B.alloca st 1ul let create_in a r = let st = match a with | SHA1 -> SHA1_s (create_in SHA1 r) | SHA2_256 -> SHA2_256_s (create_in SHA2_256 r) | SHA2_384 -> SHA2_384_s (create_in SHA2_384 r) | SHA2_512 -> SHA2_512_s (create_in SHA2_512 r) in B.malloc r st 1ul let create a = create_in a HS.root /// Instantiate function inline_for_extraction noextract val mk_instantiate: #a:supported_alg -> EverCrypt.HMAC.compute_st a -> instantiate_st a let mk_instantiate #a hmac st personalization_string personalization_string_len = if personalization_string_len >. max_personalization_string_length then false else let entropy_input_len = min_length a in let nonce_len = min_length a /. 2ul in let min_entropy = entropy_input_len +! nonce_len in push_frame(); assert_norm (range (v min_entropy) U32); let entropy = B.alloca (u8 0) min_entropy in let ok = randombytes entropy min_entropy in let result = if not ok then false else begin let entropy_input = B.sub entropy 0ul entropy_input_len in let nonce = B.sub entropy entropy_input_len nonce_len in S.hmac_input_bound a; let st_s = !*st in mk_instantiate hmac (p st_s) entropy_input_len entropy_input nonce_len nonce personalization_string_len personalization_string; true end in pop_frame(); result (** @type: true *) val instantiate_sha1 : instantiate_st SHA1 (** @type: true *) val instantiate_sha2_256: instantiate_st SHA2_256 (** @type: true *) val instantiate_sha2_384: instantiate_st SHA2_384 (** @type: true *) val instantiate_sha2_512: instantiate_st SHA2_512 let instantiate_sha1 = mk_instantiate EverCrypt.HMAC.compute_sha1 let instantiate_sha2_256 = mk_instantiate EverCrypt.HMAC.compute_sha2_256 let instantiate_sha2_384 = mk_instantiate EverCrypt.HMAC.compute_sha2_384 let instantiate_sha2_512 = mk_instantiate EverCrypt.HMAC.compute_sha2_512 /// Reseed function inline_for_extraction noextract val mk_reseed: #a:supported_alg -> EverCrypt.HMAC.compute_st a -> reseed_st a let mk_reseed #a hmac st additional_input additional_input_len = if additional_input_len >. max_additional_input_length then false else let entropy_input_len = min_length a in push_frame(); let entropy_input = B.alloca (u8 0) entropy_input_len in let ok = randombytes entropy_input entropy_input_len in let result = if not ok then false else begin S.hmac_input_bound a; let st_s = !*st in mk_reseed hmac (p st_s) entropy_input_len entropy_input additional_input_len additional_input; true end in pop_frame(); result (** @type: true *) val reseed_sha1 : reseed_st SHA1 (** @type: true *) val reseed_sha2_256: reseed_st SHA2_256 (** @type: true *) val reseed_sha2_384: reseed_st SHA2_384 (** @type: true *) val reseed_sha2_512: reseed_st SHA2_512 let reseed_sha1 = mk_reseed EverCrypt.HMAC.compute_sha1 let reseed_sha2_256 = mk_reseed EverCrypt.HMAC.compute_sha2_256 let reseed_sha2_384 = mk_reseed EverCrypt.HMAC.compute_sha2_384 let reseed_sha2_512 = mk_reseed EverCrypt.HMAC.compute_sha2_512 /// Generate function inline_for_extraction noextract val mk_generate: #a:supported_alg -> EverCrypt.HMAC.compute_st a -> generate_st a let mk_generate #a hmac output st n additional_input additional_input_len = if additional_input_len >. max_additional_input_length || n >. max_output_length then false else ( push_frame(); let ok = mk_reseed hmac st additional_input additional_input_len in let result = if not ok then false else begin let st_s = !*st in let b = mk_generate hmac output (p st_s) n additional_input_len additional_input in b (* This used to be true, which is fishy *) end in let h1 = get () in pop_frame(); let h2 = get () in frame_invariant (B.loc_all_regions_from false (HS.get_tip h1)) st h1 h2; result ) (** @type: true *) val generate_sha1 : generate_st SHA1 (** @type: true *) val generate_sha2_256: generate_st SHA2_256 (** @type: true *) val generate_sha2_384: generate_st SHA2_384 (** @type: true *) val generate_sha2_512: generate_st SHA2_512 let generate_sha1 = mk_generate EverCrypt.HMAC.compute_sha1 let generate_sha2_256 = mk_generate EverCrypt.HMAC.compute_sha2_256 let generate_sha2_384 = mk_generate EverCrypt.HMAC.compute_sha2_384 let generate_sha2_512 = mk_generate EverCrypt.HMAC.compute_sha2_512 /// Uninstantiate function inline_for_extraction noextract

EverCrypt.DRBG.fst

val mk_uninstantiate: a:supported_alg -> uninstantiate_st a

EverCrypt.DRBG.mk_uninstantiate

a: Hacl.HMAC_DRBG.supported_alg -> EverCrypt.DRBG.uninstantiate_st a

FStar.HyperStack.ST.StackInline

val alloca: a:supported_alg -> StackInline (state a) (requires fun _ -> True) (ensures fun h0 st h1 -> B.modifies B.loc_none h0 h1 /\ B.fresh_loc (footprint st h1) h0 h1 /\ B.(loc_includes (loc_region_only true (HS.get_tip h1)) (footprint st h1)) /\ invariant st h1)

let alloca a = let st = match a with | SHA1 -> SHA1_s (alloca a) | SHA2_256 -> SHA2_256_s (alloca a) | SHA2_384 -> SHA2_384_s (alloca a) | SHA2_512 -> SHA2_512_s (alloca a) in B.alloca st 1ul

val alloca: a:supported_alg -> StackInline (state a) (requires fun _ -> True) (ensures fun h0 st h1 -> B.modifies B.loc_none h0 h1 /\ B.fresh_loc (footprint st h1) h0 h1 /\ B.(loc_includes (loc_region_only true (HS.get_tip h1)) (footprint st h1)) /\ invariant st h1) let alloca a =

let st = match a with | SHA1 -> SHA1_s (alloca a) | SHA2_256 -> SHA2_256_s (alloca a) | SHA2_384 -> SHA2_384_s (alloca a) | SHA2_512 -> SHA2_512_s (alloca a) in B.alloca st 1ul

module EverCrypt.DRBG open FStar.HyperStack.ST open Lib.IntTypes open Spec.Hash.Definitions module HS = FStar.HyperStack module B = LowStar.Buffer module S = Spec.HMAC_DRBG open Hacl.HMAC_DRBG open Lib.RandomBuffer.System open LowStar.BufferOps friend Hacl.HMAC_DRBG friend EverCrypt.HMAC #set-options "--max_ifuel 0 --max_fuel 0 --z3rlimit 50" /// Some duplication from Hacl.HMAC_DRBG because we don't want clients to depend on it /// /// Respects EverCrypt convention and reverses order of buf_len, buf arguments [@CAbstractStruct] noeq type state_s: supported_alg -> Type0 = | SHA1_s : state SHA1 -> state_s SHA1 | SHA2_256_s: state SHA2_256 -> state_s SHA2_256 | SHA2_384_s: state SHA2_384 -> state_s SHA2_384 | SHA2_512_s: state SHA2_512 -> state_s SHA2_512 let invert_state_s (a:supported_alg): Lemma (requires True) (ensures inversion (state_s a)) [ SMTPat (state_s a) ] = allow_inversion (state_s a) /// Only call this function in extracted code with a known `a` inline_for_extraction noextract let p #a (s:state_s a) : Hacl.HMAC_DRBG.state a = match a with | SHA1 -> let SHA1_s p = s in p | SHA2_256 -> let SHA2_256_s p = s in p | SHA2_384 -> let SHA2_384_s p = s in p | SHA2_512 -> let SHA2_512_s p = s in p let freeable_s #a st = freeable (p st) let footprint_s #a st = footprint (p st) let invariant_s #a st h = invariant (p st) h let repr #a st h = let st = B.get h st 0 in repr (p st) h let loc_includes_union_l_footprint_s #a l1 l2 st = B.loc_includes_union_l l1 l2 (footprint_s st) let invariant_loc_in_footprint #a st m = () let frame_invariant #a l st h0 h1 = () /// State allocation // Would like to specialize alloca in each branch, but two calls to StackInline

EverCrypt.DRBG.fst

val alloca: a:supported_alg -> StackInline (state a) (requires fun _ -> True) (ensures fun h0 st h1 -> B.modifies B.loc_none h0 h1 /\ B.fresh_loc (footprint st h1) h0 h1 /\ B.(loc_includes (loc_region_only true (HS.get_tip h1)) (footprint st h1)) /\ invariant st h1)

EverCrypt.DRBG.alloca

a: Hacl.HMAC_DRBG.supported_alg -> FStar.HyperStack.ST.StackInline (EverCrypt.DRBG.state a)

FStar.HyperStack.ST.ST

val create_in: a:supported_alg -> r:HS.rid -> ST (state a) (requires fun _ -> is_eternal_region r) (ensures fun h0 st h1 -> B.modifies B.loc_none h0 h1 /\ B.fresh_loc (footprint st h1) h0 h1 /\ B.(loc_includes (loc_region_only true r) (footprint st h1)) /\ invariant st h1 /\ freeable st h1)

let create_in a r = let st = match a with | SHA1 -> SHA1_s (create_in SHA1 r) | SHA2_256 -> SHA2_256_s (create_in SHA2_256 r) | SHA2_384 -> SHA2_384_s (create_in SHA2_384 r) | SHA2_512 -> SHA2_512_s (create_in SHA2_512 r) in B.malloc r st 1ul

val create_in: a:supported_alg -> r:HS.rid -> ST (state a) (requires fun _ -> is_eternal_region r) (ensures fun h0 st h1 -> B.modifies B.loc_none h0 h1 /\ B.fresh_loc (footprint st h1) h0 h1 /\ B.(loc_includes (loc_region_only true r) (footprint st h1)) /\ invariant st h1 /\ freeable st h1) let create_in a r =

let st = match a with | SHA1 -> SHA1_s (create_in SHA1 r) | SHA2_256 -> SHA2_256_s (create_in SHA2_256 r) | SHA2_384 -> SHA2_384_s (create_in SHA2_384 r) | SHA2_512 -> SHA2_512_s (create_in SHA2_512 r) in B.malloc r st 1ul

module EverCrypt.DRBG open FStar.HyperStack.ST open Lib.IntTypes open Spec.Hash.Definitions module HS = FStar.HyperStack module B = LowStar.Buffer module S = Spec.HMAC_DRBG open Hacl.HMAC_DRBG open Lib.RandomBuffer.System open LowStar.BufferOps friend Hacl.HMAC_DRBG friend EverCrypt.HMAC #set-options "--max_ifuel 0 --max_fuel 0 --z3rlimit 50" /// Some duplication from Hacl.HMAC_DRBG because we don't want clients to depend on it /// /// Respects EverCrypt convention and reverses order of buf_len, buf arguments [@CAbstractStruct] noeq type state_s: supported_alg -> Type0 = | SHA1_s : state SHA1 -> state_s SHA1 | SHA2_256_s: state SHA2_256 -> state_s SHA2_256 | SHA2_384_s: state SHA2_384 -> state_s SHA2_384 | SHA2_512_s: state SHA2_512 -> state_s SHA2_512 let invert_state_s (a:supported_alg): Lemma (requires True) (ensures inversion (state_s a)) [ SMTPat (state_s a) ] = allow_inversion (state_s a) /// Only call this function in extracted code with a known `a` inline_for_extraction noextract let p #a (s:state_s a) : Hacl.HMAC_DRBG.state a = match a with | SHA1 -> let SHA1_s p = s in p | SHA2_256 -> let SHA2_256_s p = s in p | SHA2_384 -> let SHA2_384_s p = s in p | SHA2_512 -> let SHA2_512_s p = s in p let freeable_s #a st = freeable (p st) let footprint_s #a st = footprint (p st) let invariant_s #a st h = invariant (p st) h let repr #a st h = let st = B.get h st 0 in repr (p st) h let loc_includes_union_l_footprint_s #a l1 l2 st = B.loc_includes_union_l l1 l2 (footprint_s st) let invariant_loc_in_footprint #a st m = () let frame_invariant #a l st h0 h1 = () /// State allocation // Would like to specialize alloca in each branch, but two calls to StackInline // functions in the same block lead to variable redefinitions at extraction. let alloca a = let st = match a with | SHA1 -> SHA1_s (alloca a) | SHA2_256 -> SHA2_256_s (alloca a) | SHA2_384 -> SHA2_384_s (alloca a) | SHA2_512 -> SHA2_512_s (alloca a) in B.alloca st 1ul

EverCrypt.DRBG.fst

val create_in: a:supported_alg -> r:HS.rid -> ST (state a) (requires fun _ -> is_eternal_region r) (ensures fun h0 st h1 -> B.modifies B.loc_none h0 h1 /\ B.fresh_loc (footprint st h1) h0 h1 /\ B.(loc_includes (loc_region_only true r) (footprint st h1)) /\ invariant st h1 /\ freeable st h1)

EverCrypt.DRBG.create_in

a: Hacl.HMAC_DRBG.supported_alg -> r: FStar.Monotonic.HyperHeap.rid -> FStar.HyperStack.ST.ST (EverCrypt.DRBG.state a)

Prims.Tot

val mk_reseed: #a:supported_alg -> EverCrypt.HMAC.compute_st a -> reseed_st a

let mk_reseed #a hmac st additional_input additional_input_len = if additional_input_len >. max_additional_input_length then false else let entropy_input_len = min_length a in push_frame(); let entropy_input = B.alloca (u8 0) entropy_input_len in let ok = randombytes entropy_input entropy_input_len in let result = if not ok then false else begin S.hmac_input_bound a; let st_s = !*st in mk_reseed hmac (p st_s) entropy_input_len entropy_input additional_input_len additional_input; true end in pop_frame(); result

val mk_reseed: #a:supported_alg -> EverCrypt.HMAC.compute_st a -> reseed_st a let mk_reseed #a hmac st additional_input additional_input_len =

if additional_input_len >. max_additional_input_length then false else let entropy_input_len = min_length a in push_frame (); let entropy_input = B.alloca (u8 0) entropy_input_len in let ok = randombytes entropy_input entropy_input_len in let result = if not ok then false else (S.hmac_input_bound a; let st_s = !*st in mk_reseed hmac (p st_s) entropy_input_len entropy_input additional_input_len additional_input; true) in pop_frame (); result

module EverCrypt.DRBG open FStar.HyperStack.ST open Lib.IntTypes open Spec.Hash.Definitions module HS = FStar.HyperStack module B = LowStar.Buffer module S = Spec.HMAC_DRBG open Hacl.HMAC_DRBG open Lib.RandomBuffer.System open LowStar.BufferOps friend Hacl.HMAC_DRBG friend EverCrypt.HMAC #set-options "--max_ifuel 0 --max_fuel 0 --z3rlimit 50" /// Some duplication from Hacl.HMAC_DRBG because we don't want clients to depend on it /// /// Respects EverCrypt convention and reverses order of buf_len, buf arguments [@CAbstractStruct] noeq type state_s: supported_alg -> Type0 = | SHA1_s : state SHA1 -> state_s SHA1 | SHA2_256_s: state SHA2_256 -> state_s SHA2_256 | SHA2_384_s: state SHA2_384 -> state_s SHA2_384 | SHA2_512_s: state SHA2_512 -> state_s SHA2_512 let invert_state_s (a:supported_alg): Lemma (requires True) (ensures inversion (state_s a)) [ SMTPat (state_s a) ] = allow_inversion (state_s a) /// Only call this function in extracted code with a known `a` inline_for_extraction noextract let p #a (s:state_s a) : Hacl.HMAC_DRBG.state a = match a with | SHA1 -> let SHA1_s p = s in p | SHA2_256 -> let SHA2_256_s p = s in p | SHA2_384 -> let SHA2_384_s p = s in p | SHA2_512 -> let SHA2_512_s p = s in p let freeable_s #a st = freeable (p st) let footprint_s #a st = footprint (p st) let invariant_s #a st h = invariant (p st) h let repr #a st h = let st = B.get h st 0 in repr (p st) h let loc_includes_union_l_footprint_s #a l1 l2 st = B.loc_includes_union_l l1 l2 (footprint_s st) let invariant_loc_in_footprint #a st m = () let frame_invariant #a l st h0 h1 = () /// State allocation // Would like to specialize alloca in each branch, but two calls to StackInline // functions in the same block lead to variable redefinitions at extraction. let alloca a = let st = match a with | SHA1 -> SHA1_s (alloca a) | SHA2_256 -> SHA2_256_s (alloca a) | SHA2_384 -> SHA2_384_s (alloca a) | SHA2_512 -> SHA2_512_s (alloca a) in B.alloca st 1ul let create_in a r = let st = match a with | SHA1 -> SHA1_s (create_in SHA1 r) | SHA2_256 -> SHA2_256_s (create_in SHA2_256 r) | SHA2_384 -> SHA2_384_s (create_in SHA2_384 r) | SHA2_512 -> SHA2_512_s (create_in SHA2_512 r) in B.malloc r st 1ul let create a = create_in a HS.root /// Instantiate function inline_for_extraction noextract val mk_instantiate: #a:supported_alg -> EverCrypt.HMAC.compute_st a -> instantiate_st a let mk_instantiate #a hmac st personalization_string personalization_string_len = if personalization_string_len >. max_personalization_string_length then false else let entropy_input_len = min_length a in let nonce_len = min_length a /. 2ul in let min_entropy = entropy_input_len +! nonce_len in push_frame(); assert_norm (range (v min_entropy) U32); let entropy = B.alloca (u8 0) min_entropy in let ok = randombytes entropy min_entropy in let result = if not ok then false else begin let entropy_input = B.sub entropy 0ul entropy_input_len in let nonce = B.sub entropy entropy_input_len nonce_len in S.hmac_input_bound a; let st_s = !*st in mk_instantiate hmac (p st_s) entropy_input_len entropy_input nonce_len nonce personalization_string_len personalization_string; true end in pop_frame(); result (** @type: true *) val instantiate_sha1 : instantiate_st SHA1 (** @type: true *) val instantiate_sha2_256: instantiate_st SHA2_256 (** @type: true *) val instantiate_sha2_384: instantiate_st SHA2_384 (** @type: true *) val instantiate_sha2_512: instantiate_st SHA2_512 let instantiate_sha1 = mk_instantiate EverCrypt.HMAC.compute_sha1 let instantiate_sha2_256 = mk_instantiate EverCrypt.HMAC.compute_sha2_256 let instantiate_sha2_384 = mk_instantiate EverCrypt.HMAC.compute_sha2_384 let instantiate_sha2_512 = mk_instantiate EverCrypt.HMAC.compute_sha2_512 /// Reseed function inline_for_extraction noextract val mk_reseed: #a:supported_alg -> EverCrypt.HMAC.compute_st a -> reseed_st a

EverCrypt.DRBG.fst

val mk_reseed: #a:supported_alg -> EverCrypt.HMAC.compute_st a -> reseed_st a

EverCrypt.DRBG.mk_reseed

hmac: EverCrypt.HMAC.compute_st a -> EverCrypt.DRBG.reseed_st a

Prims.Tot

val mk_instantiate: #a:supported_alg -> EverCrypt.HMAC.compute_st a -> instantiate_st a

let mk_instantiate #a hmac st personalization_string personalization_string_len = if personalization_string_len >. max_personalization_string_length then false else let entropy_input_len = min_length a in let nonce_len = min_length a /. 2ul in let min_entropy = entropy_input_len +! nonce_len in push_frame(); assert_norm (range (v min_entropy) U32); let entropy = B.alloca (u8 0) min_entropy in let ok = randombytes entropy min_entropy in let result = if not ok then false else begin let entropy_input = B.sub entropy 0ul entropy_input_len in let nonce = B.sub entropy entropy_input_len nonce_len in S.hmac_input_bound a; let st_s = !*st in mk_instantiate hmac (p st_s) entropy_input_len entropy_input nonce_len nonce personalization_string_len personalization_string; true end in pop_frame(); result

val mk_instantiate: #a:supported_alg -> EverCrypt.HMAC.compute_st a -> instantiate_st a let mk_instantiate #a hmac st personalization_string personalization_string_len =

if personalization_string_len >. max_personalization_string_length then false else let entropy_input_len = min_length a in let nonce_len = min_length a /. 2ul in let min_entropy = entropy_input_len +! nonce_len in push_frame (); assert_norm (range (v min_entropy) U32); let entropy = B.alloca (u8 0) min_entropy in let ok = randombytes entropy min_entropy in let result = if not ok then false else let entropy_input = B.sub entropy 0ul entropy_input_len in let nonce = B.sub entropy entropy_input_len nonce_len in S.hmac_input_bound a; let st_s = !*st in mk_instantiate hmac (p st_s) entropy_input_len entropy_input nonce_len nonce personalization_string_len personalization_string; true in pop_frame (); result

module EverCrypt.DRBG open FStar.HyperStack.ST open Lib.IntTypes open Spec.Hash.Definitions module HS = FStar.HyperStack module B = LowStar.Buffer module S = Spec.HMAC_DRBG open Hacl.HMAC_DRBG open Lib.RandomBuffer.System open LowStar.BufferOps friend Hacl.HMAC_DRBG friend EverCrypt.HMAC #set-options "--max_ifuel 0 --max_fuel 0 --z3rlimit 50" /// Some duplication from Hacl.HMAC_DRBG because we don't want clients to depend on it /// /// Respects EverCrypt convention and reverses order of buf_len, buf arguments [@CAbstractStruct] noeq type state_s: supported_alg -> Type0 = | SHA1_s : state SHA1 -> state_s SHA1 | SHA2_256_s: state SHA2_256 -> state_s SHA2_256 | SHA2_384_s: state SHA2_384 -> state_s SHA2_384 | SHA2_512_s: state SHA2_512 -> state_s SHA2_512 let invert_state_s (a:supported_alg): Lemma (requires True) (ensures inversion (state_s a)) [ SMTPat (state_s a) ] = allow_inversion (state_s a) /// Only call this function in extracted code with a known `a` inline_for_extraction noextract let p #a (s:state_s a) : Hacl.HMAC_DRBG.state a = match a with | SHA1 -> let SHA1_s p = s in p | SHA2_256 -> let SHA2_256_s p = s in p | SHA2_384 -> let SHA2_384_s p = s in p | SHA2_512 -> let SHA2_512_s p = s in p let freeable_s #a st = freeable (p st) let footprint_s #a st = footprint (p st) let invariant_s #a st h = invariant (p st) h let repr #a st h = let st = B.get h st 0 in repr (p st) h let loc_includes_union_l_footprint_s #a l1 l2 st = B.loc_includes_union_l l1 l2 (footprint_s st) let invariant_loc_in_footprint #a st m = () let frame_invariant #a l st h0 h1 = () /// State allocation // Would like to specialize alloca in each branch, but two calls to StackInline // functions in the same block lead to variable redefinitions at extraction. let alloca a = let st = match a with | SHA1 -> SHA1_s (alloca a) | SHA2_256 -> SHA2_256_s (alloca a) | SHA2_384 -> SHA2_384_s (alloca a) | SHA2_512 -> SHA2_512_s (alloca a) in B.alloca st 1ul let create_in a r = let st = match a with | SHA1 -> SHA1_s (create_in SHA1 r) | SHA2_256 -> SHA2_256_s (create_in SHA2_256 r) | SHA2_384 -> SHA2_384_s (create_in SHA2_384 r) | SHA2_512 -> SHA2_512_s (create_in SHA2_512 r) in B.malloc r st 1ul let create a = create_in a HS.root /// Instantiate function inline_for_extraction noextract val mk_instantiate: #a:supported_alg -> EverCrypt.HMAC.compute_st a -> instantiate_st a

EverCrypt.DRBG.fst

val mk_instantiate: #a:supported_alg -> EverCrypt.HMAC.compute_st a -> instantiate_st a

EverCrypt.DRBG.mk_instantiate

hmac: EverCrypt.HMAC.compute_st a -> EverCrypt.DRBG.instantiate_st a

Prims.Tot

val mk_generate: #a:supported_alg -> EverCrypt.HMAC.compute_st a -> generate_st a

let mk_generate #a hmac output st n additional_input additional_input_len = if additional_input_len >. max_additional_input_length || n >. max_output_length then false else ( push_frame(); let ok = mk_reseed hmac st additional_input additional_input_len in let result = if not ok then false else begin let st_s = !*st in let b = mk_generate hmac output (p st_s) n additional_input_len additional_input in b (* This used to be true, which is fishy *) end in let h1 = get () in pop_frame(); let h2 = get () in frame_invariant (B.loc_all_regions_from false (HS.get_tip h1)) st h1 h2; result )

val mk_generate: #a:supported_alg -> EverCrypt.HMAC.compute_st a -> generate_st a let mk_generate #a hmac output st n additional_input additional_input_len =

if additional_input_len >. max_additional_input_length || n >. max_output_length then false else (push_frame (); let ok = mk_reseed hmac st additional_input additional_input_len in let result = if not ok then false else let st_s = !*st in let b = mk_generate hmac output (p st_s) n additional_input_len additional_input in b in let h1 = get () in pop_frame (); let h2 = get () in frame_invariant (B.loc_all_regions_from false (HS.get_tip h1)) st h1 h2; result)

module EverCrypt.DRBG open FStar.HyperStack.ST open Lib.IntTypes open Spec.Hash.Definitions module HS = FStar.HyperStack module B = LowStar.Buffer module S = Spec.HMAC_DRBG open Hacl.HMAC_DRBG open Lib.RandomBuffer.System open LowStar.BufferOps friend Hacl.HMAC_DRBG friend EverCrypt.HMAC #set-options "--max_ifuel 0 --max_fuel 0 --z3rlimit 50" /// Some duplication from Hacl.HMAC_DRBG because we don't want clients to depend on it /// /// Respects EverCrypt convention and reverses order of buf_len, buf arguments [@CAbstractStruct] noeq type state_s: supported_alg -> Type0 = | SHA1_s : state SHA1 -> state_s SHA1 | SHA2_256_s: state SHA2_256 -> state_s SHA2_256 | SHA2_384_s: state SHA2_384 -> state_s SHA2_384 | SHA2_512_s: state SHA2_512 -> state_s SHA2_512 let invert_state_s (a:supported_alg): Lemma (requires True) (ensures inversion (state_s a)) [ SMTPat (state_s a) ] = allow_inversion (state_s a) /// Only call this function in extracted code with a known `a` inline_for_extraction noextract let p #a (s:state_s a) : Hacl.HMAC_DRBG.state a = match a with | SHA1 -> let SHA1_s p = s in p | SHA2_256 -> let SHA2_256_s p = s in p | SHA2_384 -> let SHA2_384_s p = s in p | SHA2_512 -> let SHA2_512_s p = s in p let freeable_s #a st = freeable (p st) let footprint_s #a st = footprint (p st) let invariant_s #a st h = invariant (p st) h let repr #a st h = let st = B.get h st 0 in repr (p st) h let loc_includes_union_l_footprint_s #a l1 l2 st = B.loc_includes_union_l l1 l2 (footprint_s st) let invariant_loc_in_footprint #a st m = () let frame_invariant #a l st h0 h1 = () /// State allocation // Would like to specialize alloca in each branch, but two calls to StackInline // functions in the same block lead to variable redefinitions at extraction. let alloca a = let st = match a with | SHA1 -> SHA1_s (alloca a) | SHA2_256 -> SHA2_256_s (alloca a) | SHA2_384 -> SHA2_384_s (alloca a) | SHA2_512 -> SHA2_512_s (alloca a) in B.alloca st 1ul let create_in a r = let st = match a with | SHA1 -> SHA1_s (create_in SHA1 r) | SHA2_256 -> SHA2_256_s (create_in SHA2_256 r) | SHA2_384 -> SHA2_384_s (create_in SHA2_384 r) | SHA2_512 -> SHA2_512_s (create_in SHA2_512 r) in B.malloc r st 1ul let create a = create_in a HS.root /// Instantiate function inline_for_extraction noextract val mk_instantiate: #a:supported_alg -> EverCrypt.HMAC.compute_st a -> instantiate_st a let mk_instantiate #a hmac st personalization_string personalization_string_len = if personalization_string_len >. max_personalization_string_length then false else let entropy_input_len = min_length a in let nonce_len = min_length a /. 2ul in let min_entropy = entropy_input_len +! nonce_len in push_frame(); assert_norm (range (v min_entropy) U32); let entropy = B.alloca (u8 0) min_entropy in let ok = randombytes entropy min_entropy in let result = if not ok then false else begin let entropy_input = B.sub entropy 0ul entropy_input_len in let nonce = B.sub entropy entropy_input_len nonce_len in S.hmac_input_bound a; let st_s = !*st in mk_instantiate hmac (p st_s) entropy_input_len entropy_input nonce_len nonce personalization_string_len personalization_string; true end in pop_frame(); result (** @type: true *) val instantiate_sha1 : instantiate_st SHA1 (** @type: true *) val instantiate_sha2_256: instantiate_st SHA2_256 (** @type: true *) val instantiate_sha2_384: instantiate_st SHA2_384 (** @type: true *) val instantiate_sha2_512: instantiate_st SHA2_512 let instantiate_sha1 = mk_instantiate EverCrypt.HMAC.compute_sha1 let instantiate_sha2_256 = mk_instantiate EverCrypt.HMAC.compute_sha2_256 let instantiate_sha2_384 = mk_instantiate EverCrypt.HMAC.compute_sha2_384 let instantiate_sha2_512 = mk_instantiate EverCrypt.HMAC.compute_sha2_512 /// Reseed function inline_for_extraction noextract val mk_reseed: #a:supported_alg -> EverCrypt.HMAC.compute_st a -> reseed_st a let mk_reseed #a hmac st additional_input additional_input_len = if additional_input_len >. max_additional_input_length then false else let entropy_input_len = min_length a in push_frame(); let entropy_input = B.alloca (u8 0) entropy_input_len in let ok = randombytes entropy_input entropy_input_len in let result = if not ok then false else begin S.hmac_input_bound a; let st_s = !*st in mk_reseed hmac (p st_s) entropy_input_len entropy_input additional_input_len additional_input; true end in pop_frame(); result (** @type: true *) val reseed_sha1 : reseed_st SHA1 (** @type: true *) val reseed_sha2_256: reseed_st SHA2_256 (** @type: true *) val reseed_sha2_384: reseed_st SHA2_384 (** @type: true *) val reseed_sha2_512: reseed_st SHA2_512 let reseed_sha1 = mk_reseed EverCrypt.HMAC.compute_sha1 let reseed_sha2_256 = mk_reseed EverCrypt.HMAC.compute_sha2_256 let reseed_sha2_384 = mk_reseed EverCrypt.HMAC.compute_sha2_384 let reseed_sha2_512 = mk_reseed EverCrypt.HMAC.compute_sha2_512 /// Generate function inline_for_extraction noextract val mk_generate: #a:supported_alg -> EverCrypt.HMAC.compute_st a -> generate_st a

EverCrypt.DRBG.fst

val mk_generate: #a:supported_alg -> EverCrypt.HMAC.compute_st a -> generate_st a

EverCrypt.DRBG.mk_generate

hmac: EverCrypt.HMAC.compute_st a -> EverCrypt.DRBG.generate_st a

Prims.Tot

val sealBase: sealBase_st cs True

let sealBase = hpke_sealBase_higher #cs True IAEAD.aead_encrypt_cp256 setupBaseS

val sealBase: sealBase_st cs True let sealBase =

hpke_sealBase_higher #cs True IAEAD.aead_encrypt_cp256 setupBaseS

module Hacl.HPKE.P256_CP256_SHA256 open Hacl.Meta.HPKE module IDH = Hacl.HPKE.Interface.DH module IHK = Hacl.HPKE.Interface.HKDF module IHash = Hacl.HPKE.Interface.Hash module IAEAD = Hacl.HPKE.Interface.AEAD friend Hacl.Meta.HPKE #set-options "--fuel 0 --ifuel 0" let setupBaseS = hpke_setupBaseS_higher #cs True IHK.hkdf_expand256 IHK.hkdf_extract256 IDH.secret_to_public_p256 IDH.dh_p256 IHK.hkdf_expand256 IHK.hkdf_extract256 let setupBaseR = hpke_setupBaseR_higher #cs True IHK.hkdf_expand256 IHK.hkdf_extract256 IDH.dh_p256 IHK.hkdf_expand256 IHK.hkdf_extract256 IDH.secret_to_public_p256

Hacl.HPKE.P256_CP256_SHA256.fst

val sealBase: sealBase_st cs True

Hacl.HPKE.P256_CP256_SHA256.sealBase

Hacl.Impl.HPKE.sealBase_st Hacl.HPKE.P256_CP256_SHA256.cs Prims.l_True

Prims.Tot

val openBase: openBase_st cs True

let openBase = hpke_openBase_higher #cs True IAEAD.aead_decrypt_cp256 setupBaseR

val openBase: openBase_st cs True let openBase =

hpke_openBase_higher #cs True IAEAD.aead_decrypt_cp256 setupBaseR

module Hacl.HPKE.P256_CP256_SHA256 open Hacl.Meta.HPKE module IDH = Hacl.HPKE.Interface.DH module IHK = Hacl.HPKE.Interface.HKDF module IHash = Hacl.HPKE.Interface.Hash module IAEAD = Hacl.HPKE.Interface.AEAD friend Hacl.Meta.HPKE #set-options "--fuel 0 --ifuel 0" let setupBaseS = hpke_setupBaseS_higher #cs True IHK.hkdf_expand256 IHK.hkdf_extract256 IDH.secret_to_public_p256 IDH.dh_p256 IHK.hkdf_expand256 IHK.hkdf_extract256 let setupBaseR = hpke_setupBaseR_higher #cs True IHK.hkdf_expand256 IHK.hkdf_extract256 IDH.dh_p256 IHK.hkdf_expand256 IHK.hkdf_extract256 IDH.secret_to_public_p256 let sealBase = hpke_sealBase_higher #cs True IAEAD.aead_encrypt_cp256 setupBaseS

Hacl.HPKE.P256_CP256_SHA256.fst

val openBase: openBase_st cs True

Hacl.HPKE.P256_CP256_SHA256.openBase

Hacl.Impl.HPKE.openBase_st Hacl.HPKE.P256_CP256_SHA256.cs Prims.l_True

Prims.Tot

val setupBaseS: setupBaseS_st cs True

let setupBaseS = hpke_setupBaseS_higher #cs True IHK.hkdf_expand256 IHK.hkdf_extract256 IDH.secret_to_public_p256 IDH.dh_p256 IHK.hkdf_expand256 IHK.hkdf_extract256

val setupBaseS: setupBaseS_st cs True let setupBaseS =

hpke_setupBaseS_higher #cs True IHK.hkdf_expand256 IHK.hkdf_extract256 IDH.secret_to_public_p256 IDH.dh_p256 IHK.hkdf_expand256 IHK.hkdf_extract256

module Hacl.HPKE.P256_CP256_SHA256 open Hacl.Meta.HPKE module IDH = Hacl.HPKE.Interface.DH module IHK = Hacl.HPKE.Interface.HKDF module IHash = Hacl.HPKE.Interface.Hash module IAEAD = Hacl.HPKE.Interface.AEAD friend Hacl.Meta.HPKE #set-options "--fuel 0 --ifuel 0"

Hacl.HPKE.P256_CP256_SHA256.fst

val setupBaseS: setupBaseS_st cs True

Hacl.HPKE.P256_CP256_SHA256.setupBaseS

Hacl.Impl.HPKE.setupBaseS_st Hacl.HPKE.P256_CP256_SHA256.cs Prims.l_True

Prims.Tot

val setupBaseR: setupBaseR_st cs True

let setupBaseR = hpke_setupBaseR_higher #cs True IHK.hkdf_expand256 IHK.hkdf_extract256 IDH.dh_p256 IHK.hkdf_expand256 IHK.hkdf_extract256 IDH.secret_to_public_p256

val setupBaseR: setupBaseR_st cs True let setupBaseR =

hpke_setupBaseR_higher #cs True IHK.hkdf_expand256 IHK.hkdf_extract256 IDH.dh_p256 IHK.hkdf_expand256 IHK.hkdf_extract256 IDH.secret_to_public_p256

module Hacl.HPKE.P256_CP256_SHA256 open Hacl.Meta.HPKE module IDH = Hacl.HPKE.Interface.DH module IHK = Hacl.HPKE.Interface.HKDF module IHash = Hacl.HPKE.Interface.Hash module IAEAD = Hacl.HPKE.Interface.AEAD friend Hacl.Meta.HPKE #set-options "--fuel 0 --ifuel 0" let setupBaseS = hpke_setupBaseS_higher #cs True IHK.hkdf_expand256 IHK.hkdf_extract256 IDH.secret_to_public_p256 IDH.dh_p256 IHK.hkdf_expand256 IHK.hkdf_extract256

Hacl.HPKE.P256_CP256_SHA256.fst

val setupBaseR: setupBaseR_st cs True

Hacl.HPKE.P256_CP256_SHA256.setupBaseR

Hacl.Impl.HPKE.setupBaseR_st Hacl.HPKE.P256_CP256_SHA256.cs Prims.l_True

Prims.Tot

val parse_der_length_payload_kind_weak:parser_kind

let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None

val parse_der_length_payload_kind_weak:parser_kind let parse_der_length_payload_kind_weak:parser_kind =

strong_parser_kind 0 126 None

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction

LowParse.Spec.DER.fst

val parse_der_length_payload_kind_weak:parser_kind

LowParse.Spec.DER.parse_der_length_payload_kind_weak

LowParse.Spec.Base.parser_kind

Prims.Tot

val parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t{min <= max}) : Tot parser_kind

let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max)

val parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t{min <= max}) : Tot parser_kind let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t{min <= max}) : Tot parser_kind =

and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max)

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } )

LowParse.Spec.DER.fst

val parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t{min <= max}) : Tot parser_kind

LowParse.Spec.DER.parse_bounded_der_length_kind

min: LowParse.Spec.DER.der_length_t -> max: LowParse.Spec.DER.der_length_t{min <= max} -> LowParse.Spec.Base.parser_kind

Prims.Tot

val parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t{min <= max}) (x: U8.t) : Tot bool

let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max

val parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t{min <= max}) (x: U8.t) : Tot bool let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t{min <= max}) (x: U8.t) : Tot bool =

let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t)

LowParse.Spec.DER.fst

val parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t{min <= max}) (x: U8.t) : Tot bool

LowParse.Spec.DER.parse_bounded_der_length_tag_cond

min: LowParse.Spec.DER.der_length_t -> max: LowParse.Spec.DER.der_length_t{min <= max} -> x: FStar.UInt8.t -> Prims.bool

Prims.Tot

val parse_der_length_weak_kind:parser_kind

let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak

val parse_der_length_weak_kind:parser_kind let parse_der_length_weak_kind:parser_kind =

and_then_kind parse_u8_kind parse_der_length_payload_kind_weak

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None

LowParse.Spec.DER.fst

val parse_der_length_weak_kind:parser_kind

LowParse.Spec.DER.parse_der_length_weak_kind

LowParse.Spec.Base.parser_kind

Prims.Tot

val der_length_max_eq : squash (der_length_max == pow2 (8 * 126) - 1)

let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1)

val der_length_max_eq : squash (der_length_max == pow2 (8 * 126) - 1) let der_length_max_eq =

assert_norm (der_length_max == pow2 (8 * 126) - 1)

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`())))

LowParse.Spec.DER.fst

val der_length_max_eq : squash (der_length_max == pow2 (8 * 126) - 1)

LowParse.Spec.DER.der_length_max_eq

Prims.squash (LowParse.Spec.DER.der_length_max == Prims.pow2 (8 * 126) - 1)

FStar.Pervasives.Lemma

val synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))]

let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' )

val synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] =

synth_injective_intro' (synth_be_int len) (fun (x: Seq.lseq byte len) (x': Seq.lseq byte len) -> E.be_to_n_inj x x')

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))]

LowParse.Spec.DER.fst

val synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))]

LowParse.Spec.DER.synth_be_int_injective

len: Prims.nat -> FStar.Pervasives.Lemma (ensures LowParse.Spec.Combinators.synth_injective (LowParse.Spec.DER.synth_be_int len)) [SMTPat (LowParse.Spec.Combinators.synth_injective (LowParse.Spec.DER.synth_be_int len))]

Prims.Tot

val synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len)

let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b

val synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) =

E.lemma_be_to_n_is_bounded b; E.be_to_n b

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len)

LowParse.Spec.DER.fst

val synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len)

LowParse.Spec.DER.synth_be_int

len: Prims.nat -> b: FStar.Seq.Properties.lseq LowParse.Bytes.byte len -> LowParse.Spec.DER.lint len

Prims.Tot

val parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t{min <= max}) : Tot parser_kind

let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None

val parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t{min <= max}) : Tot parser_kind let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t{min <= max}) : Tot parser_kind =

[@@ inline_let ]let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } )

LowParse.Spec.DER.fst

val parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t{min <= max}) : Tot parser_kind

LowParse.Spec.DER.parse_bounded_der_length_payload_kind

min: LowParse.Spec.DER.der_length_t -> max: LowParse.Spec.DER.der_length_t{min <= max} -> LowParse.Spec.Base.parser_kind

Prims.Tot

val parse_der_length_payload32 (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length32 x))

let parse_der_length_payload32 x : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length32 x)) = parse_der_length_payload x `parse_synth` synth_der_length_payload32 x

val parse_der_length_payload32 (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length32 x)) let parse_der_length_payload32 x : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length32 x)) =

(parse_der_length_payload x) `parse_synth` (synth_der_length_payload32 x)

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y let synth_der_length_greater_inverse (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) : Lemma (synth_inverse (synth_der_length_greater x len) (synth_der_length_greater_recip x len)) = () private let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } ) = (serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () ) let tag_of_der_length_lt_128_eta (x:U8.t{U8.v x < 128}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_lt_128 y <: Lemma (U8.v x == y) let tag_of_der_length_invalid_eta (x:U8.t{U8.v x == 128 \/ U8.v x == 255}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_invalid y <: Lemma False let tag_of_der_length_eq_129_eta (x:U8.t{U8.v x == 129}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_eq_129 y <: Lemma (synth_der_length_129 x (synth_der_length_129_recip x y) == y) let serialize_der_length_payload (x: U8.t) : Tot (serializer (parse_der_length_payload x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_ret (x' <: refine_with_tag tag_of_der_length x) (tag_of_der_length_lt_128_eta x)) end else if x = 128uy || x = 255uy then fail_serializer (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) (tag_of_der_length_invalid_eta x) else if x = 129uy then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_synth (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) ) end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? serialize_weaken (parse_der_length_payload_kind x) (serialize_der_length_payload_greater x len) end let serialize_der_length_weak : serializer parse_der_length_weak = serialize_tagged_union serialize_u8 tag_of_der_length (fun x -> serialize_weaken parse_der_length_payload_kind_weak (serialize_der_length_payload x)) #push-options "--max_ifuel 6 --z3rlimit 64" let serialize_der_length_weak_unfold (y: der_length_t) : Lemma (let res = serialize serialize_der_length_weak y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = let x = tag_of_der_length y in serialize_u8_spec x; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy || x = 255uy then tag_of_der_length_invalid y else if x = 129uy then begin tag_of_der_length_eq_129 y; assert (U8.v (synth_der_length_129_recip x y) == y); let s1 = serialize ( serialize_synth #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x))) y in serialize_synth_eq' #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) y s1 () (serialize serialize_u8 (synth_der_length_129_recip x y)) () ; serialize_u8_spec (U8.uint_to_t y); () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? assert ( serialize (serialize_der_length_payload x) y == serialize (serialize_der_length_payload_greater x len) y ); serialize_synth_eq' #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () y (serialize (serialize_der_length_payload_greater x len) y) (_ by (FStar.Tactics.trefl ())) (serialize (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (synth_der_length_greater_recip x len y) ) () ; serialize_synth_eq _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () (synth_der_length_greater_recip x len y); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); () end; () #pop-options let serialize_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length_weak min max)) = serialize_synth _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () let serialize_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length min max)) = Classical.forall_intro (parse_bounded_der_length_eq min max); serialize_ext _ (serialize_bounded_der_length_weak min max) (parse_bounded_der_length min max) let serialize_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (y: bounded_int min max) : Lemma (let res = serialize (serialize_bounded_der_length min max) y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = serialize_synth_eq _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () y; serialize_der_length_weak_unfold y (* 32-bit spec *) module U32 = FStar.UInt32 let der_length_payload_size_of_tag_inv32 (x: der_length_t) : Lemma (requires (x < 4294967296)) (ensures ( tag_of_der_length x == ( if x < 128 then U8.uint_to_t x else if x < 256 then 129uy else if x < 65536 then 130uy else if x < 16777216 then 131uy else 132uy ))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126); assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); if x < 256 then log256_unique x 1 else if x < 65536 then log256_unique x 2 else if x < 16777216 then log256_unique x 3 else log256_unique x 4 let synth_der_length_payload32 (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) (y: refine_with_tag tag_of_der_length x) : GTot (refine_with_tag tag_of_der_length32 x) = let _ = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in if y >= 128 then begin Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end in U32.uint_to_t y let synth_der_length_payload32_injective (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) : Lemma (synth_injective (synth_der_length_payload32 x)) [SMTPat (synth_injective (synth_der_length_payload32 x))] = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in synth_injective_intro' (synth_der_length_payload32 x) (fun (y1 y2: refine_with_tag tag_of_der_length x) -> if y1 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y1 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y1) == 128 + log256 y1) end; if y2 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y2 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y2) == 128 + log256 y2) end ) let parse_der_length_payload32 x

LowParse.Spec.DER.fst

val parse_der_length_payload32 (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length32 x))

LowParse.Spec.DER.parse_der_length_payload32

x: FStar.UInt8.t{LowParse.Spec.DER.der_length_payload_size_of_tag x <= 4} -> LowParse.Spec.Base.parser (LowParse.Spec.DER.parse_der_length_payload_kind x) (LowParse.Spec.Base.refine_with_tag LowParse.Spec.DER.tag_of_der_length32 x)

Prims.Tot

val serialize_bounded_der_length (min: der_length_t) (max: der_length_t{min <= max}) : Tot (serializer (parse_bounded_der_length min max))

let serialize_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length min max)) = Classical.forall_intro (parse_bounded_der_length_eq min max); serialize_ext _ (serialize_bounded_der_length_weak min max) (parse_bounded_der_length min max)

val serialize_bounded_der_length (min: der_length_t) (max: der_length_t{min <= max}) : Tot (serializer (parse_bounded_der_length min max)) let serialize_bounded_der_length (min: der_length_t) (max: der_length_t{min <= max}) : Tot (serializer (parse_bounded_der_length min max)) =

Classical.forall_intro (parse_bounded_der_length_eq min max); serialize_ext _ (serialize_bounded_der_length_weak min max) (parse_bounded_der_length min max)

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y let synth_der_length_greater_inverse (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) : Lemma (synth_inverse (synth_der_length_greater x len) (synth_der_length_greater_recip x len)) = () private let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } ) = (serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () ) let tag_of_der_length_lt_128_eta (x:U8.t{U8.v x < 128}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_lt_128 y <: Lemma (U8.v x == y) let tag_of_der_length_invalid_eta (x:U8.t{U8.v x == 128 \/ U8.v x == 255}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_invalid y <: Lemma False let tag_of_der_length_eq_129_eta (x:U8.t{U8.v x == 129}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_eq_129 y <: Lemma (synth_der_length_129 x (synth_der_length_129_recip x y) == y) let serialize_der_length_payload (x: U8.t) : Tot (serializer (parse_der_length_payload x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_ret (x' <: refine_with_tag tag_of_der_length x) (tag_of_der_length_lt_128_eta x)) end else if x = 128uy || x = 255uy then fail_serializer (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) (tag_of_der_length_invalid_eta x) else if x = 129uy then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_synth (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) ) end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? serialize_weaken (parse_der_length_payload_kind x) (serialize_der_length_payload_greater x len) end let serialize_der_length_weak : serializer parse_der_length_weak = serialize_tagged_union serialize_u8 tag_of_der_length (fun x -> serialize_weaken parse_der_length_payload_kind_weak (serialize_der_length_payload x)) #push-options "--max_ifuel 6 --z3rlimit 64" let serialize_der_length_weak_unfold (y: der_length_t) : Lemma (let res = serialize serialize_der_length_weak y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = let x = tag_of_der_length y in serialize_u8_spec x; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy || x = 255uy then tag_of_der_length_invalid y else if x = 129uy then begin tag_of_der_length_eq_129 y; assert (U8.v (synth_der_length_129_recip x y) == y); let s1 = serialize ( serialize_synth #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x))) y in serialize_synth_eq' #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) y s1 () (serialize serialize_u8 (synth_der_length_129_recip x y)) () ; serialize_u8_spec (U8.uint_to_t y); () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? assert ( serialize (serialize_der_length_payload x) y == serialize (serialize_der_length_payload_greater x len) y ); serialize_synth_eq' #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () y (serialize (serialize_der_length_payload_greater x len) y) (_ by (FStar.Tactics.trefl ())) (serialize (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (synth_der_length_greater_recip x len y) ) () ; serialize_synth_eq _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () (synth_der_length_greater_recip x len y); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); () end; () #pop-options let serialize_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length_weak min max)) = serialize_synth _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () let serialize_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max })

LowParse.Spec.DER.fst

val serialize_bounded_der_length (min: der_length_t) (max: der_length_t{min <= max}) : Tot (serializer (parse_bounded_der_length min max))

LowParse.Spec.DER.serialize_bounded_der_length

min: LowParse.Spec.DER.der_length_t -> max: LowParse.Spec.DER.der_length_t{min <= max} -> LowParse.Spec.Base.serializer (LowParse.Spec.DER.parse_bounded_der_length min max)

Prims.Tot

val tag_of_bounded_der_length (min: der_length_t) (max: der_length_t{min <= max}) (x: bounded_int min max) : Tot (y: U8.t{parse_bounded_der_length_tag_cond min max y == true})

let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x

val tag_of_bounded_der_length (min: der_length_t) (max: der_length_t{min <= max}) (x: bounded_int min max) : Tot (y: U8.t{parse_bounded_der_length_tag_cond min max y == true}) let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t{min <= max}) (x: bounded_int min max) : Tot (y: U8.t{parse_bounded_der_length_tag_cond min max y == true}) =

[@@ inline_let ]let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max)

LowParse.Spec.DER.fst

val tag_of_bounded_der_length (min: der_length_t) (max: der_length_t{min <= max}) (x: bounded_int min max) : Tot (y: U8.t{parse_bounded_der_length_tag_cond min max y == true})

LowParse.Spec.DER.tag_of_bounded_der_length

min: LowParse.Spec.DER.der_length_t -> max: LowParse.Spec.DER.der_length_t{min <= max} -> x: LowParse.Spec.DER.bounded_int min max -> y: FStar.UInt8.t{LowParse.Spec.DER.parse_bounded_der_length_tag_cond min max y == true}

Prims.Tot

val parse_bounded_der_length (min: der_length_t) (max: der_length_t{min <= max}) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max))

let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max)

val parse_bounded_der_length (min: der_length_t) (max: der_length_t{min <= max}) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) let parse_bounded_der_length (min: der_length_t) (max: der_length_t{min <= max}) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) =

parse_tagged_union (parse_u8 `parse_filter` (parse_bounded_der_length_tag_cond min max)) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max)

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max })

LowParse.Spec.DER.fst

val parse_bounded_der_length (min: der_length_t) (max: der_length_t{min <= max}) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max))

LowParse.Spec.DER.parse_bounded_der_length

min: LowParse.Spec.DER.der_length_t -> max: LowParse.Spec.DER.der_length_t{min <= max} -> LowParse.Spec.Base.parser (LowParse.Spec.DER.parse_bounded_der_length_kind min max) (LowParse.Spec.DER.bounded_int min max)

FStar.Pervasives.Lemma

let tag_of_der_length_eq_129_eta (x:U8.t{U8.v x == 129}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_eq_129 y <: Lemma (synth_der_length_129 x (synth_der_length_129_recip x y) == y)

let tag_of_der_length_eq_129_eta (x: U8.t{U8.v x == 129}) =

fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_eq_129 y <: Lemma (synth_der_length_129 x (synth_der_length_129_recip x y) == y)

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y let synth_der_length_greater_inverse (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) : Lemma (synth_inverse (synth_der_length_greater x len) (synth_der_length_greater_recip x len)) = () private let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } ) = (serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () ) let tag_of_der_length_lt_128_eta (x:U8.t{U8.v x < 128}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_lt_128 y <: Lemma (U8.v x == y) let tag_of_der_length_invalid_eta (x:U8.t{U8.v x == 128 \/ U8.v x == 255}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_invalid y <: Lemma False

LowParse.Spec.DER.fst

val tag_of_der_length_eq_129_eta : x: FStar.UInt8.t{FStar.UInt8.v x == 129} -> y: LowParse.Spec.Base.refine_with_tag LowParse.Spec.DER.tag_of_der_length x -> FStar.Pervasives.Lemma (ensures LowParse.Spec.DER.synth_der_length_129 x (LowParse.Spec.DER.synth_der_length_129_recip x y) == y)

LowParse.Spec.DER.tag_of_der_length_eq_129_eta

x: FStar.UInt8.t{FStar.UInt8.v x == 129} -> y: LowParse.Spec.Base.refine_with_tag LowParse.Spec.DER.tag_of_der_length x -> FStar.Pervasives.Lemma (ensures LowParse.Spec.DER.synth_der_length_129 x (LowParse.Spec.DER.synth_der_length_129_recip x y) == y)

Prims.Tot

val parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t{min <= max}) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max))

let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max))

val parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t{min <= max}) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t{min <= max}) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) =

(parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) `parse_synth` (fun (y: der_length_t{min <= y && y <= max}) -> (y <: bounded_int min max))

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max })

LowParse.Spec.DER.fst

val parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t{min <= max}) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max))

LowParse.Spec.DER.parse_bounded_der_length_weak

min: LowParse.Spec.DER.der_length_t -> max: LowParse.Spec.DER.der_length_t{min <= max} -> LowParse.Spec.Base.parser (LowParse.Spec.Combinators.parse_filter_kind LowParse.Spec.DER.parse_der_length_weak_kind ) (LowParse.Spec.DER.bounded_int min max)

Prims.GTot

val synth_der_length_129_recip (x: U8.t{x == 129uy}) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t{U8.v y >= 128})

let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y

val synth_der_length_129_recip (x: U8.t{x == 129uy}) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t{U8.v y >= 128}) let synth_der_length_129_recip (x: U8.t{x == 129uy}) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t{U8.v y >= 128}) =

tag_of_der_length_eq_129 y; U8.uint_to_t y

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x)

LowParse.Spec.DER.fst

val synth_der_length_129_recip (x: U8.t{x == 129uy}) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t{U8.v y >= 128})

LowParse.Spec.DER.synth_der_length_129_recip

x: FStar.UInt8.t{x == 129uy} -> y: LowParse.Spec.Base.refine_with_tag LowParse.Spec.DER.tag_of_der_length x -> Prims.GTot (y: FStar.UInt8.t{FStar.UInt8.v y >= 128})

FStar.Pervasives.Lemma

val log256_le (x1 x2: nat) : Lemma (requires (0 < x1 /\ x1 <= x2)) (ensures (log256 x1 <= log256 x2))

let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2)

val log256_le (x1 x2: nat) : Lemma (requires (0 < x1 /\ x1 <= x2)) (ensures (log256 x1 <= log256 x2)) let log256_le x1 x2 =

Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2)

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1

LowParse.Spec.DER.fst

val log256_le (x1 x2: nat) : Lemma (requires (0 < x1 /\ x1 <= x2)) (ensures (log256 x1 <= log256 x2))

LowParse.Spec.DER.log256_le

x1: Prims.nat -> x2: Prims.nat -> FStar.Pervasives.Lemma (requires 0 < x1 /\ x1 <= x2) (ensures LowParse.Spec.DER.log256 x1 <= LowParse.Spec.DER.log256 x2)

FStar.Pervasives.Lemma

val parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t{min <= max}) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input))

let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end

val parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t{min <= max}) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t{min <= max}) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) =

parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max)

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma

LowParse.Spec.DER.fst

val parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t{min <= max}) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input))

LowParse.Spec.DER.parse_bounded_der_length_eq

min: LowParse.Spec.DER.der_length_t -> max: LowParse.Spec.DER.der_length_t{min <= max} -> input: LowParse.Bytes.bytes -> FStar.Pervasives.Lemma (ensures LowParse.Spec.Base.parse (LowParse.Spec.DER.parse_bounded_der_length min max) input == LowParse.Spec.Base.parse (LowParse.Spec.DER.parse_bounded_der_length_weak min max) input)

Prims.Tot

val serialize_bounded_der_length_weak (min: der_length_t) (max: der_length_t{min <= max}) : Tot (serializer (parse_bounded_der_length_weak min max))

let serialize_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length_weak min max)) = serialize_synth _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) ()

val serialize_bounded_der_length_weak (min: der_length_t) (max: der_length_t{min <= max}) : Tot (serializer (parse_bounded_der_length_weak min max)) let serialize_bounded_der_length_weak (min: der_length_t) (max: der_length_t{min <= max}) : Tot (serializer (parse_bounded_der_length_weak min max)) =

serialize_synth _ (fun (y: der_length_t{min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max)) (fun (y: bounded_int min max) -> (y <: (y: der_length_t{min <= y && y <= max}))) ()

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y let synth_der_length_greater_inverse (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) : Lemma (synth_inverse (synth_der_length_greater x len) (synth_der_length_greater_recip x len)) = () private let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } ) = (serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () ) let tag_of_der_length_lt_128_eta (x:U8.t{U8.v x < 128}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_lt_128 y <: Lemma (U8.v x == y) let tag_of_der_length_invalid_eta (x:U8.t{U8.v x == 128 \/ U8.v x == 255}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_invalid y <: Lemma False let tag_of_der_length_eq_129_eta (x:U8.t{U8.v x == 129}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_eq_129 y <: Lemma (synth_der_length_129 x (synth_der_length_129_recip x y) == y) let serialize_der_length_payload (x: U8.t) : Tot (serializer (parse_der_length_payload x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_ret (x' <: refine_with_tag tag_of_der_length x) (tag_of_der_length_lt_128_eta x)) end else if x = 128uy || x = 255uy then fail_serializer (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) (tag_of_der_length_invalid_eta x) else if x = 129uy then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_synth (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) ) end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? serialize_weaken (parse_der_length_payload_kind x) (serialize_der_length_payload_greater x len) end let serialize_der_length_weak : serializer parse_der_length_weak = serialize_tagged_union serialize_u8 tag_of_der_length (fun x -> serialize_weaken parse_der_length_payload_kind_weak (serialize_der_length_payload x)) #push-options "--max_ifuel 6 --z3rlimit 64" let serialize_der_length_weak_unfold (y: der_length_t) : Lemma (let res = serialize serialize_der_length_weak y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = let x = tag_of_der_length y in serialize_u8_spec x; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy || x = 255uy then tag_of_der_length_invalid y else if x = 129uy then begin tag_of_der_length_eq_129 y; assert (U8.v (synth_der_length_129_recip x y) == y); let s1 = serialize ( serialize_synth #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x))) y in serialize_synth_eq' #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) y s1 () (serialize serialize_u8 (synth_der_length_129_recip x y)) () ; serialize_u8_spec (U8.uint_to_t y); () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? assert ( serialize (serialize_der_length_payload x) y == serialize (serialize_der_length_payload_greater x len) y ); serialize_synth_eq' #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () y (serialize (serialize_der_length_payload_greater x len) y) (_ by (FStar.Tactics.trefl ())) (serialize (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (synth_der_length_greater_recip x len y) ) () ; serialize_synth_eq _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () (synth_der_length_greater_recip x len y); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); () end; () #pop-options let serialize_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max })

LowParse.Spec.DER.fst

val serialize_bounded_der_length_weak (min: der_length_t) (max: der_length_t{min <= max}) : Tot (serializer (parse_bounded_der_length_weak min max))

LowParse.Spec.DER.serialize_bounded_der_length_weak

min: LowParse.Spec.DER.der_length_t -> max: LowParse.Spec.DER.der_length_t{min <= max} -> LowParse.Spec.Base.serializer (LowParse.Spec.DER.parse_bounded_der_length_weak min max)

Prims.Tot

let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } ) = (serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () )

let serialize_der_length_payload_greater (x: U8.t{not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy)}) (len: nat{len == U8.v x - 128}) =

(serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) ()) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater_recip x len) ())

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y let synth_der_length_greater_inverse (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) : Lemma (synth_inverse (synth_der_length_greater x len) (synth_der_length_greater_recip x len)) = () private let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } )

LowParse.Spec.DER.fst

val serialize_der_length_payload_greater : x: FStar.UInt8.t {Prims.op_Negation (FStar.UInt8.v x < 128 || x = 128uy || x = 255uy || x = 129uy)} -> len: Prims.nat{len == FStar.UInt8.v x - 128} -> LowParse.Spec.Base.serializer (LowParse.Spec.Combinators.parse_synth (LowParse.Spec.Combinators.parse_filter (LowParse.Spec.Combinators.parse_synth (LowParse.Spec.SeqBytes.Base.parse_seq_flbytes len ) (LowParse.Spec.DER.synth_be_int len)) (fun y -> y >= Prims.pow2 (8 * (len - 1)))) (LowParse.Spec.DER.synth_der_length_greater x len))

LowParse.Spec.DER.serialize_der_length_payload_greater

x: FStar.UInt8.t {Prims.op_Negation (FStar.UInt8.v x < 128 || x = 128uy || x = 255uy || x = 129uy)} -> len: Prims.nat{len == FStar.UInt8.v x - 128} -> LowParse.Spec.Base.serializer (LowParse.Spec.Combinators.parse_synth (LowParse.Spec.Combinators.parse_filter (LowParse.Spec.Combinators.parse_synth (LowParse.Spec.SeqBytes.Base.parse_seq_flbytes len ) (LowParse.Spec.DER.synth_be_int len)) (fun y -> y >= Prims.pow2 (8 * (len - 1)))) (LowParse.Spec.DER.synth_der_length_greater x len))

FStar.Pervasives.Lemma

let tag_of_der_length_lt_128_eta (x:U8.t{U8.v x < 128}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_lt_128 y <: Lemma (U8.v x == y)

let tag_of_der_length_lt_128_eta (x: U8.t{U8.v x < 128}) =

fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_lt_128 y <: Lemma (U8.v x == y)

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y let synth_der_length_greater_inverse (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) : Lemma (synth_inverse (synth_der_length_greater x len) (synth_der_length_greater_recip x len)) = () private let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } ) = (serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () )

LowParse.Spec.DER.fst

val tag_of_der_length_lt_128_eta : x: FStar.UInt8.t{FStar.UInt8.v x < 128} -> y: LowParse.Spec.Base.refine_with_tag LowParse.Spec.DER.tag_of_der_length x -> FStar.Pervasives.Lemma (ensures FStar.UInt8.v x == y)

LowParse.Spec.DER.tag_of_der_length_lt_128_eta

x: FStar.UInt8.t{FStar.UInt8.v x < 128} -> y: LowParse.Spec.Base.refine_with_tag LowParse.Spec.DER.tag_of_der_length x -> FStar.Pervasives.Lemma (ensures FStar.UInt8.v x == y)

FStar.Pervasives.Lemma

val log256_unique (x: nat) (y: nat) : Lemma (requires ( x > 0 /\ y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y) )) (ensures (y == log256 x))

let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y)

val log256_unique (x: nat) (y: nat) : Lemma (requires ( x > 0 /\ y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y) )) (ensures (y == log256 x)) let log256_unique x y =

Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y)

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x

LowParse.Spec.DER.fst

val log256_unique (x: nat) (y: nat) : Lemma (requires ( x > 0 /\ y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y) )) (ensures (y == log256 x))

LowParse.Spec.DER.log256_unique

x: Prims.nat -> y: Prims.nat -> FStar.Pervasives.Lemma (requires x > 0 /\ y > 0 /\ Prims.pow2 (8 * (y - 1)) <= x /\ x < Prims.pow2 (8 * y)) (ensures y == LowParse.Spec.DER.log256 x)

Prims.Tot

val serialize_der_length_weak:serializer parse_der_length_weak

let serialize_der_length_weak : serializer parse_der_length_weak = serialize_tagged_union serialize_u8 tag_of_der_length (fun x -> serialize_weaken parse_der_length_payload_kind_weak (serialize_der_length_payload x))

val serialize_der_length_weak:serializer parse_der_length_weak let serialize_der_length_weak:serializer parse_der_length_weak =

serialize_tagged_union serialize_u8 tag_of_der_length (fun x -> serialize_weaken parse_der_length_payload_kind_weak (serialize_der_length_payload x))

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y let synth_der_length_greater_inverse (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) : Lemma (synth_inverse (synth_der_length_greater x len) (synth_der_length_greater_recip x len)) = () private let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } ) = (serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () ) let tag_of_der_length_lt_128_eta (x:U8.t{U8.v x < 128}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_lt_128 y <: Lemma (U8.v x == y) let tag_of_der_length_invalid_eta (x:U8.t{U8.v x == 128 \/ U8.v x == 255}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_invalid y <: Lemma False let tag_of_der_length_eq_129_eta (x:U8.t{U8.v x == 129}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_eq_129 y <: Lemma (synth_der_length_129 x (synth_der_length_129_recip x y) == y) let serialize_der_length_payload (x: U8.t) : Tot (serializer (parse_der_length_payload x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_ret (x' <: refine_with_tag tag_of_der_length x) (tag_of_der_length_lt_128_eta x)) end else if x = 128uy || x = 255uy then fail_serializer (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) (tag_of_der_length_invalid_eta x) else if x = 129uy then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_synth (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) ) end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? serialize_weaken (parse_der_length_payload_kind x) (serialize_der_length_payload_greater x len) end

LowParse.Spec.DER.fst

val serialize_der_length_weak:serializer parse_der_length_weak

LowParse.Spec.DER.serialize_der_length_weak

LowParse.Spec.Base.serializer LowParse.Spec.DER.parse_der_length_weak

Prims.Tot

val parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t{min <= max}) (x: U8.t{parse_bounded_der_length_tag_cond min max x == true}) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x))

let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)))

val parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t{min <= max}) (x: U8.t{parse_bounded_der_length_tag_cond min max x == true}) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t{min <= max}) (x: U8.t{parse_bounded_der_length_tag_cond min max x == true}) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) =

weaken (parse_bounded_der_length_payload_kind min max) (((parse_der_length_payload x) `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x {min <= y && y <= max}) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)))

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } )

LowParse.Spec.DER.fst

val parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t{min <= max}) (x: U8.t{parse_bounded_der_length_tag_cond min max x == true}) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x))

LowParse.Spec.DER.parse_bounded_der_length_payload

min: LowParse.Spec.DER.der_length_t -> max: LowParse.Spec.DER.der_length_t{min <= max} -> x: FStar.UInt8.t{LowParse.Spec.DER.parse_bounded_der_length_tag_cond min max x == true} -> LowParse.Spec.Base.parser (LowParse.Spec.DER.parse_bounded_der_length_payload_kind min max) (LowParse.Spec.Base.refine_with_tag (LowParse.Spec.DER.tag_of_bounded_der_length min max) x)

Prims.GTot

val synth_bounded_der_length32_recip (min: der_length_t) (max: der_length_t{min <= max /\ max < 4294967296}) (x: bounded_int32 min max) : GTot (bounded_int min max)

let synth_bounded_der_length32_recip (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) (x: bounded_int32 min max) : GTot (bounded_int min max) = U32.v x

val synth_bounded_der_length32_recip (min: der_length_t) (max: der_length_t{min <= max /\ max < 4294967296}) (x: bounded_int32 min max) : GTot (bounded_int min max) let synth_bounded_der_length32_recip (min: der_length_t) (max: der_length_t{min <= max /\ max < 4294967296}) (x: bounded_int32 min max) : GTot (bounded_int min max) =

U32.v x

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y let synth_der_length_greater_inverse (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) : Lemma (synth_inverse (synth_der_length_greater x len) (synth_der_length_greater_recip x len)) = () private let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } ) = (serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () ) let tag_of_der_length_lt_128_eta (x:U8.t{U8.v x < 128}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_lt_128 y <: Lemma (U8.v x == y) let tag_of_der_length_invalid_eta (x:U8.t{U8.v x == 128 \/ U8.v x == 255}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_invalid y <: Lemma False let tag_of_der_length_eq_129_eta (x:U8.t{U8.v x == 129}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_eq_129 y <: Lemma (synth_der_length_129 x (synth_der_length_129_recip x y) == y) let serialize_der_length_payload (x: U8.t) : Tot (serializer (parse_der_length_payload x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_ret (x' <: refine_with_tag tag_of_der_length x) (tag_of_der_length_lt_128_eta x)) end else if x = 128uy || x = 255uy then fail_serializer (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) (tag_of_der_length_invalid_eta x) else if x = 129uy then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_synth (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) ) end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? serialize_weaken (parse_der_length_payload_kind x) (serialize_der_length_payload_greater x len) end let serialize_der_length_weak : serializer parse_der_length_weak = serialize_tagged_union serialize_u8 tag_of_der_length (fun x -> serialize_weaken parse_der_length_payload_kind_weak (serialize_der_length_payload x)) #push-options "--max_ifuel 6 --z3rlimit 64" let serialize_der_length_weak_unfold (y: der_length_t) : Lemma (let res = serialize serialize_der_length_weak y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = let x = tag_of_der_length y in serialize_u8_spec x; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy || x = 255uy then tag_of_der_length_invalid y else if x = 129uy then begin tag_of_der_length_eq_129 y; assert (U8.v (synth_der_length_129_recip x y) == y); let s1 = serialize ( serialize_synth #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x))) y in serialize_synth_eq' #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) y s1 () (serialize serialize_u8 (synth_der_length_129_recip x y)) () ; serialize_u8_spec (U8.uint_to_t y); () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? assert ( serialize (serialize_der_length_payload x) y == serialize (serialize_der_length_payload_greater x len) y ); serialize_synth_eq' #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () y (serialize (serialize_der_length_payload_greater x len) y) (_ by (FStar.Tactics.trefl ())) (serialize (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (synth_der_length_greater_recip x len y) ) () ; serialize_synth_eq _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () (synth_der_length_greater_recip x len y); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); () end; () #pop-options let serialize_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length_weak min max)) = serialize_synth _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () let serialize_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length min max)) = Classical.forall_intro (parse_bounded_der_length_eq min max); serialize_ext _ (serialize_bounded_der_length_weak min max) (parse_bounded_der_length min max) let serialize_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (y: bounded_int min max) : Lemma (let res = serialize (serialize_bounded_der_length min max) y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = serialize_synth_eq _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () y; serialize_der_length_weak_unfold y (* 32-bit spec *) module U32 = FStar.UInt32 let der_length_payload_size_of_tag_inv32 (x: der_length_t) : Lemma (requires (x < 4294967296)) (ensures ( tag_of_der_length x == ( if x < 128 then U8.uint_to_t x else if x < 256 then 129uy else if x < 65536 then 130uy else if x < 16777216 then 131uy else 132uy ))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126); assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); if x < 256 then log256_unique x 1 else if x < 65536 then log256_unique x 2 else if x < 16777216 then log256_unique x 3 else log256_unique x 4 let synth_der_length_payload32 (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) (y: refine_with_tag tag_of_der_length x) : GTot (refine_with_tag tag_of_der_length32 x) = let _ = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in if y >= 128 then begin Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end in U32.uint_to_t y let synth_der_length_payload32_injective (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) : Lemma (synth_injective (synth_der_length_payload32 x)) [SMTPat (synth_injective (synth_der_length_payload32 x))] = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in synth_injective_intro' (synth_der_length_payload32 x) (fun (y1 y2: refine_with_tag tag_of_der_length x) -> if y1 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y1 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y1) == 128 + log256 y1) end; if y2 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y2 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y2) == 128 + log256 y2) end ) let parse_der_length_payload32 x : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length32 x)) = parse_der_length_payload x `parse_synth` synth_der_length_payload32 x let be_int_of_bounded_integer (len: integer_size) (x: nat { x < pow2 (8 * len) } ) : GTot (bounded_integer len) = integer_size_values len; assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); U32.uint_to_t x let be_int_of_bounded_integer_injective (len: integer_size) : Lemma (synth_injective (be_int_of_bounded_integer len)) [SMTPat (synth_injective (be_int_of_bounded_integer len))] // FIXME: WHY WHY WHY does this pattern NEVER trigger? = integer_size_values len; assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296) #push-options "--max_ifuel 4 --z3rlimit 16" let parse_seq_flbytes_synth_be_int_eq (len: integer_size) (input: bytes) : Lemma ( let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse ( parse_synth #_ #(lint len) #(bounded_integer len) (parse_synth #_ #(Seq.lseq byte len) #(lint len) (parse_seq_flbytes len) (synth_be_int len) ) (be_int_of_bounded_integer len) ) input == parse (parse_bounded_integer len) input) = let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse_synth_eq (parse_seq_flbytes len `parse_synth` synth_be_int len) (be_int_of_bounded_integer len) input; parse_synth_eq (parse_seq_flbytes len) (synth_be_int len) input; parser_kind_prop_equiv (parse_bounded_integer_kind len) (parse_bounded_integer len); parse_bounded_integer_spec len input let parse_der_length_payload32_unfold x input = parse_synth_eq (parse_der_length_payload x) (synth_der_length_payload32 x) input; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 (8 * 1) == 256); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in begin match parse (parse_der_length_payload x) input with | None -> () | Some (y, _) -> if y >= 128 then begin Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end end; parse_der_length_payload_unfold x input; if U8.v x < 128 then () // tag_of_der_length (U8.v x) == x /\ y == Some (Cast.uint8_to_uint32 x, 0) else if x = 128uy || x = 255uy then () // y == None else if x = 129uy then () else begin let len : nat = U8.v x - 128 in assert (2 <= len /\ len <= 4); let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse_seq_flbytes_synth_be_int_eq len input; integer_size_values len; parse_synth_eq #_ #(lint len) #(bounded_integer len) (parse_synth #_ #(Seq.lseq byte len) #(lint len) (parse_seq_flbytes len) (synth_be_int len)) (be_int_of_bounded_integer len) input end #pop-options let log256_eq x = log256_unique x (log256' x) let synth_bounded_der_length32 (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) (x: bounded_int min max) : Tot (bounded_int32 min max) = U32.uint_to_t x let parse_bounded_der_length32 (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) : Tot (parser (parse_bounded_der_length32_kind min max) (bounded_int32 min max)) = parse_bounded_der_length min max `parse_synth` synth_bounded_der_length32 min max #push-options "--z3rlimit 50" let parse_bounded_der_length32_unfold min max input = parse_synth_eq (parse_bounded_der_length min max) (synth_bounded_der_length32 min max) input; parse_bounded_der_length_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in assert_norm (4294967296 <= der_length_max); der_length_payload_size_le max 4294967295; assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); log256_unique 4294967295 4; parse_synth_eq (parse_der_length_payload x) (synth_der_length_payload32 x) input' ; match parse (parse_der_length_payload x) input' with | None -> () | Some (y, _) -> if y >= 128 then begin assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end else () #pop-options let synth_bounded_der_length32_recip (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) (x: bounded_int32 min max)

LowParse.Spec.DER.fst

val synth_bounded_der_length32_recip (min: der_length_t) (max: der_length_t{min <= max /\ max < 4294967296}) (x: bounded_int32 min max) : GTot (bounded_int min max)

LowParse.Spec.DER.synth_bounded_der_length32_recip

min: LowParse.Spec.DER.der_length_t -> max: LowParse.Spec.DER.der_length_t{min <= max /\ max < 4294967296} -> x: LowParse.Spec.BoundedInt.bounded_int32 min max -> Prims.GTot (LowParse.Spec.DER.bounded_int min max)

FStar.Pervasives.Lemma

val be_int_of_bounded_integer_injective (len: integer_size) : Lemma (synth_injective (be_int_of_bounded_integer len)) [SMTPat (synth_injective (be_int_of_bounded_integer len))]

let be_int_of_bounded_integer_injective (len: integer_size) : Lemma (synth_injective (be_int_of_bounded_integer len)) [SMTPat (synth_injective (be_int_of_bounded_integer len))] // FIXME: WHY WHY WHY does this pattern NEVER trigger? = integer_size_values len; assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296)

val be_int_of_bounded_integer_injective (len: integer_size) : Lemma (synth_injective (be_int_of_bounded_integer len)) [SMTPat (synth_injective (be_int_of_bounded_integer len))] let be_int_of_bounded_integer_injective (len: integer_size) : Lemma (synth_injective (be_int_of_bounded_integer len)) [SMTPat (synth_injective (be_int_of_bounded_integer len))] =

integer_size_values len; assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296)

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y let synth_der_length_greater_inverse (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) : Lemma (synth_inverse (synth_der_length_greater x len) (synth_der_length_greater_recip x len)) = () private let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } ) = (serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () ) let tag_of_der_length_lt_128_eta (x:U8.t{U8.v x < 128}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_lt_128 y <: Lemma (U8.v x == y) let tag_of_der_length_invalid_eta (x:U8.t{U8.v x == 128 \/ U8.v x == 255}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_invalid y <: Lemma False let tag_of_der_length_eq_129_eta (x:U8.t{U8.v x == 129}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_eq_129 y <: Lemma (synth_der_length_129 x (synth_der_length_129_recip x y) == y) let serialize_der_length_payload (x: U8.t) : Tot (serializer (parse_der_length_payload x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_ret (x' <: refine_with_tag tag_of_der_length x) (tag_of_der_length_lt_128_eta x)) end else if x = 128uy || x = 255uy then fail_serializer (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) (tag_of_der_length_invalid_eta x) else if x = 129uy then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_synth (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) ) end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? serialize_weaken (parse_der_length_payload_kind x) (serialize_der_length_payload_greater x len) end let serialize_der_length_weak : serializer parse_der_length_weak = serialize_tagged_union serialize_u8 tag_of_der_length (fun x -> serialize_weaken parse_der_length_payload_kind_weak (serialize_der_length_payload x)) #push-options "--max_ifuel 6 --z3rlimit 64" let serialize_der_length_weak_unfold (y: der_length_t) : Lemma (let res = serialize serialize_der_length_weak y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = let x = tag_of_der_length y in serialize_u8_spec x; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy || x = 255uy then tag_of_der_length_invalid y else if x = 129uy then begin tag_of_der_length_eq_129 y; assert (U8.v (synth_der_length_129_recip x y) == y); let s1 = serialize ( serialize_synth #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x))) y in serialize_synth_eq' #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) y s1 () (serialize serialize_u8 (synth_der_length_129_recip x y)) () ; serialize_u8_spec (U8.uint_to_t y); () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? assert ( serialize (serialize_der_length_payload x) y == serialize (serialize_der_length_payload_greater x len) y ); serialize_synth_eq' #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () y (serialize (serialize_der_length_payload_greater x len) y) (_ by (FStar.Tactics.trefl ())) (serialize (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (synth_der_length_greater_recip x len y) ) () ; serialize_synth_eq _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () (synth_der_length_greater_recip x len y); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); () end; () #pop-options let serialize_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length_weak min max)) = serialize_synth _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () let serialize_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length min max)) = Classical.forall_intro (parse_bounded_der_length_eq min max); serialize_ext _ (serialize_bounded_der_length_weak min max) (parse_bounded_der_length min max) let serialize_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (y: bounded_int min max) : Lemma (let res = serialize (serialize_bounded_der_length min max) y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = serialize_synth_eq _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () y; serialize_der_length_weak_unfold y (* 32-bit spec *) module U32 = FStar.UInt32 let der_length_payload_size_of_tag_inv32 (x: der_length_t) : Lemma (requires (x < 4294967296)) (ensures ( tag_of_der_length x == ( if x < 128 then U8.uint_to_t x else if x < 256 then 129uy else if x < 65536 then 130uy else if x < 16777216 then 131uy else 132uy ))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126); assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); if x < 256 then log256_unique x 1 else if x < 65536 then log256_unique x 2 else if x < 16777216 then log256_unique x 3 else log256_unique x 4 let synth_der_length_payload32 (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) (y: refine_with_tag tag_of_der_length x) : GTot (refine_with_tag tag_of_der_length32 x) = let _ = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in if y >= 128 then begin Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end in U32.uint_to_t y let synth_der_length_payload32_injective (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) : Lemma (synth_injective (synth_der_length_payload32 x)) [SMTPat (synth_injective (synth_der_length_payload32 x))] = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in synth_injective_intro' (synth_der_length_payload32 x) (fun (y1 y2: refine_with_tag tag_of_der_length x) -> if y1 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y1 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y1) == 128 + log256 y1) end; if y2 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y2 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y2) == 128 + log256 y2) end ) let parse_der_length_payload32 x : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length32 x)) = parse_der_length_payload x `parse_synth` synth_der_length_payload32 x let be_int_of_bounded_integer (len: integer_size) (x: nat { x < pow2 (8 * len) } ) : GTot (bounded_integer len) = integer_size_values len; assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); U32.uint_to_t x let be_int_of_bounded_integer_injective (len: integer_size) : Lemma (synth_injective (be_int_of_bounded_integer len))

LowParse.Spec.DER.fst

val be_int_of_bounded_integer_injective (len: integer_size) : Lemma (synth_injective (be_int_of_bounded_integer len)) [SMTPat (synth_injective (be_int_of_bounded_integer len))]

LowParse.Spec.DER.be_int_of_bounded_integer_injective

len: LowParse.Spec.BoundedInt.integer_size -> FStar.Pervasives.Lemma (ensures LowParse.Spec.Combinators.synth_injective (LowParse.Spec.DER.be_int_of_bounded_integer len)) [ SMTPat (LowParse.Spec.Combinators.synth_injective (LowParse.Spec.DER.be_int_of_bounded_integer len)) ]

Prims.Tot

val log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)})

let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end

val log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) let rec log256 (x: nat{x > 0}) : Tot (y: nat{y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) =

assert_norm (pow2 8 == 256); if x < 256 then 1 else let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 })

LowParse.Spec.DER.fst

val log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)})

LowParse.Spec.DER.log256

x: Prims.nat{x > 0} -> y: Prims.nat{y > 0 /\ Prims.pow2 (8 * (y - 1)) <= x /\ x < Prims.pow2 (8 * y)}

Prims.Tot

val parse_bounded_der_length32 (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) : Tot (parser (parse_bounded_der_length32_kind min max) (bounded_int32 min max))

let parse_bounded_der_length32 (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) : Tot (parser (parse_bounded_der_length32_kind min max) (bounded_int32 min max)) = parse_bounded_der_length min max `parse_synth` synth_bounded_der_length32 min max

val parse_bounded_der_length32 (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) : Tot (parser (parse_bounded_der_length32_kind min max) (bounded_int32 min max)) let parse_bounded_der_length32 (min: der_length_t) (max: der_length_t{min <= max /\ max < 4294967296}) : Tot (parser (parse_bounded_der_length32_kind min max) (bounded_int32 min max)) =

(parse_bounded_der_length min max) `parse_synth` (synth_bounded_der_length32 min max)

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y let synth_der_length_greater_inverse (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) : Lemma (synth_inverse (synth_der_length_greater x len) (synth_der_length_greater_recip x len)) = () private let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } ) = (serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () ) let tag_of_der_length_lt_128_eta (x:U8.t{U8.v x < 128}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_lt_128 y <: Lemma (U8.v x == y) let tag_of_der_length_invalid_eta (x:U8.t{U8.v x == 128 \/ U8.v x == 255}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_invalid y <: Lemma False let tag_of_der_length_eq_129_eta (x:U8.t{U8.v x == 129}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_eq_129 y <: Lemma (synth_der_length_129 x (synth_der_length_129_recip x y) == y) let serialize_der_length_payload (x: U8.t) : Tot (serializer (parse_der_length_payload x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_ret (x' <: refine_with_tag tag_of_der_length x) (tag_of_der_length_lt_128_eta x)) end else if x = 128uy || x = 255uy then fail_serializer (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) (tag_of_der_length_invalid_eta x) else if x = 129uy then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_synth (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) ) end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? serialize_weaken (parse_der_length_payload_kind x) (serialize_der_length_payload_greater x len) end let serialize_der_length_weak : serializer parse_der_length_weak = serialize_tagged_union serialize_u8 tag_of_der_length (fun x -> serialize_weaken parse_der_length_payload_kind_weak (serialize_der_length_payload x)) #push-options "--max_ifuel 6 --z3rlimit 64" let serialize_der_length_weak_unfold (y: der_length_t) : Lemma (let res = serialize serialize_der_length_weak y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = let x = tag_of_der_length y in serialize_u8_spec x; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy || x = 255uy then tag_of_der_length_invalid y else if x = 129uy then begin tag_of_der_length_eq_129 y; assert (U8.v (synth_der_length_129_recip x y) == y); let s1 = serialize ( serialize_synth #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x))) y in serialize_synth_eq' #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) y s1 () (serialize serialize_u8 (synth_der_length_129_recip x y)) () ; serialize_u8_spec (U8.uint_to_t y); () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? assert ( serialize (serialize_der_length_payload x) y == serialize (serialize_der_length_payload_greater x len) y ); serialize_synth_eq' #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () y (serialize (serialize_der_length_payload_greater x len) y) (_ by (FStar.Tactics.trefl ())) (serialize (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (synth_der_length_greater_recip x len y) ) () ; serialize_synth_eq _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () (synth_der_length_greater_recip x len y); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); () end; () #pop-options let serialize_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length_weak min max)) = serialize_synth _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () let serialize_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length min max)) = Classical.forall_intro (parse_bounded_der_length_eq min max); serialize_ext _ (serialize_bounded_der_length_weak min max) (parse_bounded_der_length min max) let serialize_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (y: bounded_int min max) : Lemma (let res = serialize (serialize_bounded_der_length min max) y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = serialize_synth_eq _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () y; serialize_der_length_weak_unfold y (* 32-bit spec *) module U32 = FStar.UInt32 let der_length_payload_size_of_tag_inv32 (x: der_length_t) : Lemma (requires (x < 4294967296)) (ensures ( tag_of_der_length x == ( if x < 128 then U8.uint_to_t x else if x < 256 then 129uy else if x < 65536 then 130uy else if x < 16777216 then 131uy else 132uy ))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126); assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); if x < 256 then log256_unique x 1 else if x < 65536 then log256_unique x 2 else if x < 16777216 then log256_unique x 3 else log256_unique x 4 let synth_der_length_payload32 (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) (y: refine_with_tag tag_of_der_length x) : GTot (refine_with_tag tag_of_der_length32 x) = let _ = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in if y >= 128 then begin Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end in U32.uint_to_t y let synth_der_length_payload32_injective (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) : Lemma (synth_injective (synth_der_length_payload32 x)) [SMTPat (synth_injective (synth_der_length_payload32 x))] = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in synth_injective_intro' (synth_der_length_payload32 x) (fun (y1 y2: refine_with_tag tag_of_der_length x) -> if y1 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y1 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y1) == 128 + log256 y1) end; if y2 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y2 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y2) == 128 + log256 y2) end ) let parse_der_length_payload32 x : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length32 x)) = parse_der_length_payload x `parse_synth` synth_der_length_payload32 x let be_int_of_bounded_integer (len: integer_size) (x: nat { x < pow2 (8 * len) } ) : GTot (bounded_integer len) = integer_size_values len; assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); U32.uint_to_t x let be_int_of_bounded_integer_injective (len: integer_size) : Lemma (synth_injective (be_int_of_bounded_integer len)) [SMTPat (synth_injective (be_int_of_bounded_integer len))] // FIXME: WHY WHY WHY does this pattern NEVER trigger? = integer_size_values len; assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296) #push-options "--max_ifuel 4 --z3rlimit 16" let parse_seq_flbytes_synth_be_int_eq (len: integer_size) (input: bytes) : Lemma ( let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse ( parse_synth #_ #(lint len) #(bounded_integer len) (parse_synth #_ #(Seq.lseq byte len) #(lint len) (parse_seq_flbytes len) (synth_be_int len) ) (be_int_of_bounded_integer len) ) input == parse (parse_bounded_integer len) input) = let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse_synth_eq (parse_seq_flbytes len `parse_synth` synth_be_int len) (be_int_of_bounded_integer len) input; parse_synth_eq (parse_seq_flbytes len) (synth_be_int len) input; parser_kind_prop_equiv (parse_bounded_integer_kind len) (parse_bounded_integer len); parse_bounded_integer_spec len input let parse_der_length_payload32_unfold x input = parse_synth_eq (parse_der_length_payload x) (synth_der_length_payload32 x) input; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 (8 * 1) == 256); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in begin match parse (parse_der_length_payload x) input with | None -> () | Some (y, _) -> if y >= 128 then begin Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end end; parse_der_length_payload_unfold x input; if U8.v x < 128 then () // tag_of_der_length (U8.v x) == x /\ y == Some (Cast.uint8_to_uint32 x, 0) else if x = 128uy || x = 255uy then () // y == None else if x = 129uy then () else begin let len : nat = U8.v x - 128 in assert (2 <= len /\ len <= 4); let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse_seq_flbytes_synth_be_int_eq len input; integer_size_values len; parse_synth_eq #_ #(lint len) #(bounded_integer len) (parse_synth #_ #(Seq.lseq byte len) #(lint len) (parse_seq_flbytes len) (synth_be_int len)) (be_int_of_bounded_integer len) input end #pop-options let log256_eq x = log256_unique x (log256' x) let synth_bounded_der_length32 (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) (x: bounded_int min max) : Tot (bounded_int32 min max) = U32.uint_to_t x let parse_bounded_der_length32 (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 })

LowParse.Spec.DER.fst

val parse_bounded_der_length32 (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) : Tot (parser (parse_bounded_der_length32_kind min max) (bounded_int32 min max))

LowParse.Spec.DER.parse_bounded_der_length32

min: LowParse.Spec.DER.der_length_t -> max: LowParse.Spec.DER.der_length_t{min <= max /\ max < 4294967296} -> LowParse.Spec.Base.parser (LowParse.Spec.DER.parse_bounded_der_length32_kind min max) (LowParse.Spec.BoundedInt.bounded_int32 min max)

Prims.GTot

val be_int_of_bounded_integer (len: integer_size) (x: nat{x < pow2 (8 * len)}) : GTot (bounded_integer len)

let be_int_of_bounded_integer (len: integer_size) (x: nat { x < pow2 (8 * len) } ) : GTot (bounded_integer len) = integer_size_values len; assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); U32.uint_to_t x

val be_int_of_bounded_integer (len: integer_size) (x: nat{x < pow2 (8 * len)}) : GTot (bounded_integer len) let be_int_of_bounded_integer (len: integer_size) (x: nat{x < pow2 (8 * len)}) : GTot (bounded_integer len) =

integer_size_values len; assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); U32.uint_to_t x

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y let synth_der_length_greater_inverse (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) : Lemma (synth_inverse (synth_der_length_greater x len) (synth_der_length_greater_recip x len)) = () private let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } ) = (serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () ) let tag_of_der_length_lt_128_eta (x:U8.t{U8.v x < 128}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_lt_128 y <: Lemma (U8.v x == y) let tag_of_der_length_invalid_eta (x:U8.t{U8.v x == 128 \/ U8.v x == 255}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_invalid y <: Lemma False let tag_of_der_length_eq_129_eta (x:U8.t{U8.v x == 129}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_eq_129 y <: Lemma (synth_der_length_129 x (synth_der_length_129_recip x y) == y) let serialize_der_length_payload (x: U8.t) : Tot (serializer (parse_der_length_payload x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_ret (x' <: refine_with_tag tag_of_der_length x) (tag_of_der_length_lt_128_eta x)) end else if x = 128uy || x = 255uy then fail_serializer (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) (tag_of_der_length_invalid_eta x) else if x = 129uy then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_synth (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) ) end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? serialize_weaken (parse_der_length_payload_kind x) (serialize_der_length_payload_greater x len) end let serialize_der_length_weak : serializer parse_der_length_weak = serialize_tagged_union serialize_u8 tag_of_der_length (fun x -> serialize_weaken parse_der_length_payload_kind_weak (serialize_der_length_payload x)) #push-options "--max_ifuel 6 --z3rlimit 64" let serialize_der_length_weak_unfold (y: der_length_t) : Lemma (let res = serialize serialize_der_length_weak y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = let x = tag_of_der_length y in serialize_u8_spec x; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy || x = 255uy then tag_of_der_length_invalid y else if x = 129uy then begin tag_of_der_length_eq_129 y; assert (U8.v (synth_der_length_129_recip x y) == y); let s1 = serialize ( serialize_synth #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x))) y in serialize_synth_eq' #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) y s1 () (serialize serialize_u8 (synth_der_length_129_recip x y)) () ; serialize_u8_spec (U8.uint_to_t y); () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? assert ( serialize (serialize_der_length_payload x) y == serialize (serialize_der_length_payload_greater x len) y ); serialize_synth_eq' #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () y (serialize (serialize_der_length_payload_greater x len) y) (_ by (FStar.Tactics.trefl ())) (serialize (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (synth_der_length_greater_recip x len y) ) () ; serialize_synth_eq _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () (synth_der_length_greater_recip x len y); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); () end; () #pop-options let serialize_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length_weak min max)) = serialize_synth _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () let serialize_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length min max)) = Classical.forall_intro (parse_bounded_der_length_eq min max); serialize_ext _ (serialize_bounded_der_length_weak min max) (parse_bounded_der_length min max) let serialize_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (y: bounded_int min max) : Lemma (let res = serialize (serialize_bounded_der_length min max) y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = serialize_synth_eq _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () y; serialize_der_length_weak_unfold y (* 32-bit spec *) module U32 = FStar.UInt32 let der_length_payload_size_of_tag_inv32 (x: der_length_t) : Lemma (requires (x < 4294967296)) (ensures ( tag_of_der_length x == ( if x < 128 then U8.uint_to_t x else if x < 256 then 129uy else if x < 65536 then 130uy else if x < 16777216 then 131uy else 132uy ))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126); assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); if x < 256 then log256_unique x 1 else if x < 65536 then log256_unique x 2 else if x < 16777216 then log256_unique x 3 else log256_unique x 4 let synth_der_length_payload32 (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) (y: refine_with_tag tag_of_der_length x) : GTot (refine_with_tag tag_of_der_length32 x) = let _ = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in if y >= 128 then begin Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end in U32.uint_to_t y let synth_der_length_payload32_injective (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) : Lemma (synth_injective (synth_der_length_payload32 x)) [SMTPat (synth_injective (synth_der_length_payload32 x))] = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in synth_injective_intro' (synth_der_length_payload32 x) (fun (y1 y2: refine_with_tag tag_of_der_length x) -> if y1 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y1 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y1) == 128 + log256 y1) end; if y2 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y2 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y2) == 128 + log256 y2) end ) let parse_der_length_payload32 x : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length32 x)) = parse_der_length_payload x `parse_synth` synth_der_length_payload32 x let be_int_of_bounded_integer (len: integer_size) (x: nat { x < pow2 (8 * len) } )

LowParse.Spec.DER.fst

val be_int_of_bounded_integer (len: integer_size) (x: nat{x < pow2 (8 * len)}) : GTot (bounded_integer len)

LowParse.Spec.DER.be_int_of_bounded_integer

len: LowParse.Spec.BoundedInt.integer_size -> x: Prims.nat{x < Prims.pow2 (8 * len)} -> Prims.GTot (LowParse.Spec.BoundedInt.bounded_integer len)

FStar.Pervasives.Lemma

val parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t{min <= max}) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None))

let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else ()

val parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t{min <= max}) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None)) let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t{min <= max}) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None)) =

parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t{parse_bounded_der_length_tag_cond min max x == true})) input'

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None

LowParse.Spec.DER.fst

val parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t{min <= max}) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None))

LowParse.Spec.DER.parse_bounded_der_length_unfold

min: LowParse.Spec.DER.der_length_t -> max: LowParse.Spec.DER.der_length_t{min <= max} -> input: LowParse.Bytes.bytes -> FStar.Pervasives.Lemma (ensures LowParse.Spec.Base.parse (LowParse.Spec.DER.parse_bounded_der_length min max) input == (match LowParse.Spec.Base.parse LowParse.Spec.Int.parse_u8 input with | FStar.Pervasives.Native.None #_ -> FStar.Pervasives.Native.None | FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ x consumed_x) -> let len = LowParse.Spec.DER.der_length_payload_size_of_tag x in (match LowParse.Spec.DER.der_length_payload_size min <= len && len <= LowParse.Spec.DER.der_length_payload_size max with | true -> let input' = FStar.Seq.Base.slice input consumed_x (FStar.Seq.Base.length input) in (match LowParse.Spec.Base.parse (LowParse.Spec.DER.parse_der_length_payload x) input' with | FStar.Pervasives.Native.None #_ -> FStar.Pervasives.Native.None | FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ y consumed_y) -> (match min <= y && y <= max with | true -> FStar.Pervasives.Native.Some (y, consumed_x + consumed_y) | _ -> FStar.Pervasives.Native.None) <: FStar.Pervasives.Native.option (LowParse.Spec.DER.bounded_int min max * LowParse.Spec.Base.consumed_length input)) <: FStar.Pervasives.Native.option (LowParse.Spec.DER.bounded_int min max * LowParse.Spec.Base.consumed_length input) | _ -> FStar.Pervasives.Native.None) <: FStar.Pervasives.Native.option (LowParse.Spec.DER.bounded_int min max * LowParse.Spec.Base.consumed_length input)))

FStar.Pervasives.Lemma

val parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t{min <= max}) (x: U8.t{parse_bounded_der_length_tag_cond min max x == true}) (input': bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == (match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None))

let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input'

val parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t{min <= max}) (x: U8.t{parse_bounded_der_length_tag_cond min max x == true}) (input': bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == (match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None)) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t{min <= max}) (x: U8.t{parse_bounded_der_length_tag_cond min max x == true}) (input': bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == (match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None)) =

parse_synth_eq ((parse_der_length_payload x) `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x {min <= y && y <= max}) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input'; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input'

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None ))

LowParse.Spec.DER.fst

val parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t{min <= max}) (x: U8.t{parse_bounded_der_length_tag_cond min max x == true}) (input': bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == (match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None))

LowParse.Spec.DER.parse_bounded_der_length_payload_unfold

min: LowParse.Spec.DER.der_length_t -> max: LowParse.Spec.DER.der_length_t{min <= max} -> x: FStar.UInt8.t{LowParse.Spec.DER.parse_bounded_der_length_tag_cond min max x == true} -> input': LowParse.Bytes.bytes -> FStar.Pervasives.Lemma (ensures LowParse.Spec.Base.parse (LowParse.Spec.DER.parse_bounded_der_length_payload min max x) input' == (match LowParse.Spec.Base.parse (LowParse.Spec.DER.parse_der_length_payload x) input' with | FStar.Pervasives.Native.None #_ -> FStar.Pervasives.Native.None | FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ y consumed_y) -> (match min <= y && y <= max with | true -> FStar.Pervasives.Native.Some (y, consumed_y) | _ -> FStar.Pervasives.Native.None) <: FStar.Pervasives.Native.option (LowParse.Spec.Base.refine_with_tag (LowParse.Spec.DER.tag_of_bounded_der_length min max) x * LowParse.Spec.Base.consumed_length input')))

FStar.Pervasives.Lemma

val parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t{min <= max}) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None))

let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input

val parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t{min <= max}) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None)) let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t{min <= max}) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None)) =

parse_tagged_union_eq (parse_u8 `parse_filter` (parse_bounded_der_length_tag_cond min max)) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None

LowParse.Spec.DER.fst

val parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t{min <= max}) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None))

LowParse.Spec.DER.parse_bounded_der_length_unfold_aux

min: LowParse.Spec.DER.der_length_t -> max: LowParse.Spec.DER.der_length_t{min <= max} -> input: LowParse.Bytes.bytes -> FStar.Pervasives.Lemma (ensures LowParse.Spec.Base.parse (LowParse.Spec.DER.parse_bounded_der_length min max) input == (match LowParse.Spec.Base.parse LowParse.Spec.Int.parse_u8 input with | FStar.Pervasives.Native.None #_ -> FStar.Pervasives.Native.None | FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ x consumed_x) -> let len = LowParse.Spec.DER.der_length_payload_size_of_tag x in (match LowParse.Spec.DER.der_length_payload_size min <= len && len <= LowParse.Spec.DER.der_length_payload_size max with | true -> let input' = FStar.Seq.Base.slice input consumed_x (FStar.Seq.Base.length input) in (match LowParse.Spec.Base.parse (LowParse.Spec.DER.parse_bounded_der_length_payload min max x) input' with | FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ y consumed_y) -> FStar.Pervasives.Native.Some (y, consumed_x + consumed_y) | FStar.Pervasives.Native.None #_ -> FStar.Pervasives.Native.None) <: FStar.Pervasives.Native.option (LowParse.Spec.DER.bounded_int min max * LowParse.Spec.Base.consumed_length input) | _ -> FStar.Pervasives.Native.None) <: FStar.Pervasives.Native.option (LowParse.Spec.DER.bounded_int min max * LowParse.Spec.Base.consumed_length input)))

FStar.Pervasives.Lemma

val parse_seq_flbytes_synth_be_int_eq (len: integer_size) (input: bytes) : Lemma (let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse (parse_synth #_ #(lint len) #(bounded_integer len) (parse_synth #_ #(Seq.lseq byte len) #(lint len) (parse_seq_flbytes len) (synth_be_int len)) (be_int_of_bounded_integer len)) input == parse (parse_bounded_integer len) input)

let parse_seq_flbytes_synth_be_int_eq (len: integer_size) (input: bytes) : Lemma ( let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse ( parse_synth #_ #(lint len) #(bounded_integer len) (parse_synth #_ #(Seq.lseq byte len) #(lint len) (parse_seq_flbytes len) (synth_be_int len) ) (be_int_of_bounded_integer len) ) input == parse (parse_bounded_integer len) input) = let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse_synth_eq (parse_seq_flbytes len `parse_synth` synth_be_int len) (be_int_of_bounded_integer len) input; parse_synth_eq (parse_seq_flbytes len) (synth_be_int len) input; parser_kind_prop_equiv (parse_bounded_integer_kind len) (parse_bounded_integer len); parse_bounded_integer_spec len input

val parse_seq_flbytes_synth_be_int_eq (len: integer_size) (input: bytes) : Lemma (let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse (parse_synth #_ #(lint len) #(bounded_integer len) (parse_synth #_ #(Seq.lseq byte len) #(lint len) (parse_seq_flbytes len) (synth_be_int len)) (be_int_of_bounded_integer len)) input == parse (parse_bounded_integer len) input) let parse_seq_flbytes_synth_be_int_eq (len: integer_size) (input: bytes) : Lemma (let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse (parse_synth #_ #(lint len) #(bounded_integer len) (parse_synth #_ #(Seq.lseq byte len) #(lint len) (parse_seq_flbytes len) (synth_be_int len)) (be_int_of_bounded_integer len)) input == parse (parse_bounded_integer len) input) =

let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse_synth_eq ((parse_seq_flbytes len) `parse_synth` (synth_be_int len)) (be_int_of_bounded_integer len) input; parse_synth_eq (parse_seq_flbytes len) (synth_be_int len) input; parser_kind_prop_equiv (parse_bounded_integer_kind len) (parse_bounded_integer len); parse_bounded_integer_spec len input

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y let synth_der_length_greater_inverse (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) : Lemma (synth_inverse (synth_der_length_greater x len) (synth_der_length_greater_recip x len)) = () private let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } ) = (serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () ) let tag_of_der_length_lt_128_eta (x:U8.t{U8.v x < 128}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_lt_128 y <: Lemma (U8.v x == y) let tag_of_der_length_invalid_eta (x:U8.t{U8.v x == 128 \/ U8.v x == 255}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_invalid y <: Lemma False let tag_of_der_length_eq_129_eta (x:U8.t{U8.v x == 129}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_eq_129 y <: Lemma (synth_der_length_129 x (synth_der_length_129_recip x y) == y) let serialize_der_length_payload (x: U8.t) : Tot (serializer (parse_der_length_payload x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_ret (x' <: refine_with_tag tag_of_der_length x) (tag_of_der_length_lt_128_eta x)) end else if x = 128uy || x = 255uy then fail_serializer (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) (tag_of_der_length_invalid_eta x) else if x = 129uy then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_synth (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) ) end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? serialize_weaken (parse_der_length_payload_kind x) (serialize_der_length_payload_greater x len) end let serialize_der_length_weak : serializer parse_der_length_weak = serialize_tagged_union serialize_u8 tag_of_der_length (fun x -> serialize_weaken parse_der_length_payload_kind_weak (serialize_der_length_payload x)) #push-options "--max_ifuel 6 --z3rlimit 64" let serialize_der_length_weak_unfold (y: der_length_t) : Lemma (let res = serialize serialize_der_length_weak y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = let x = tag_of_der_length y in serialize_u8_spec x; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy || x = 255uy then tag_of_der_length_invalid y else if x = 129uy then begin tag_of_der_length_eq_129 y; assert (U8.v (synth_der_length_129_recip x y) == y); let s1 = serialize ( serialize_synth #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x))) y in serialize_synth_eq' #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) y s1 () (serialize serialize_u8 (synth_der_length_129_recip x y)) () ; serialize_u8_spec (U8.uint_to_t y); () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? assert ( serialize (serialize_der_length_payload x) y == serialize (serialize_der_length_payload_greater x len) y ); serialize_synth_eq' #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () y (serialize (serialize_der_length_payload_greater x len) y) (_ by (FStar.Tactics.trefl ())) (serialize (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (synth_der_length_greater_recip x len y) ) () ; serialize_synth_eq _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () (synth_der_length_greater_recip x len y); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); () end; () #pop-options let serialize_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length_weak min max)) = serialize_synth _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () let serialize_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length min max)) = Classical.forall_intro (parse_bounded_der_length_eq min max); serialize_ext _ (serialize_bounded_der_length_weak min max) (parse_bounded_der_length min max) let serialize_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (y: bounded_int min max) : Lemma (let res = serialize (serialize_bounded_der_length min max) y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = serialize_synth_eq _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () y; serialize_der_length_weak_unfold y (* 32-bit spec *) module U32 = FStar.UInt32 let der_length_payload_size_of_tag_inv32 (x: der_length_t) : Lemma (requires (x < 4294967296)) (ensures ( tag_of_der_length x == ( if x < 128 then U8.uint_to_t x else if x < 256 then 129uy else if x < 65536 then 130uy else if x < 16777216 then 131uy else 132uy ))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126); assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); if x < 256 then log256_unique x 1 else if x < 65536 then log256_unique x 2 else if x < 16777216 then log256_unique x 3 else log256_unique x 4 let synth_der_length_payload32 (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) (y: refine_with_tag tag_of_der_length x) : GTot (refine_with_tag tag_of_der_length32 x) = let _ = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in if y >= 128 then begin Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end in U32.uint_to_t y let synth_der_length_payload32_injective (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) : Lemma (synth_injective (synth_der_length_payload32 x)) [SMTPat (synth_injective (synth_der_length_payload32 x))] = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in synth_injective_intro' (synth_der_length_payload32 x) (fun (y1 y2: refine_with_tag tag_of_der_length x) -> if y1 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y1 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y1) == 128 + log256 y1) end; if y2 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y2 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y2) == 128 + log256 y2) end ) let parse_der_length_payload32 x : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length32 x)) = parse_der_length_payload x `parse_synth` synth_der_length_payload32 x let be_int_of_bounded_integer (len: integer_size) (x: nat { x < pow2 (8 * len) } ) : GTot (bounded_integer len) = integer_size_values len; assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); U32.uint_to_t x let be_int_of_bounded_integer_injective (len: integer_size) : Lemma (synth_injective (be_int_of_bounded_integer len)) [SMTPat (synth_injective (be_int_of_bounded_integer len))] // FIXME: WHY WHY WHY does this pattern NEVER trigger? = integer_size_values len; assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296) #push-options "--max_ifuel 4 --z3rlimit 16" let parse_seq_flbytes_synth_be_int_eq (len: integer_size) (input: bytes) : Lemma ( let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse ( parse_synth #_ #(lint len) #(bounded_integer len) (parse_synth #_ #(Seq.lseq byte len) #(lint len) (parse_seq_flbytes len) (synth_be_int len) ) (be_int_of_bounded_integer len)

LowParse.Spec.DER.fst

val parse_seq_flbytes_synth_be_int_eq (len: integer_size) (input: bytes) : Lemma (let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse (parse_synth #_ #(lint len) #(bounded_integer len) (parse_synth #_ #(Seq.lseq byte len) #(lint len) (parse_seq_flbytes len) (synth_be_int len)) (be_int_of_bounded_integer len)) input == parse (parse_bounded_integer len) input)

LowParse.Spec.DER.parse_seq_flbytes_synth_be_int_eq

len: LowParse.Spec.BoundedInt.integer_size -> input: LowParse.Bytes.bytes -> FStar.Pervasives.Lemma (ensures ([@@ FStar.Pervasives.inline_let ]let _ = LowParse.Spec.DER.synth_be_int_injective len in [@@ FStar.Pervasives.inline_let ]let _ = LowParse.Spec.DER.be_int_of_bounded_integer_injective len in LowParse.Spec.Base.parse (LowParse.Spec.Combinators.parse_synth (LowParse.Spec.Combinators.parse_synth (LowParse.Spec.SeqBytes.Base.parse_seq_flbytes len) (LowParse.Spec.DER.synth_be_int len)) (LowParse.Spec.DER.be_int_of_bounded_integer len)) input == LowParse.Spec.Base.parse (LowParse.Spec.BoundedInt.parse_bounded_integer len) input))

FStar.Pervasives.Lemma

val parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t{min <= max}) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None))

let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input

val parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t{min <= max}) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t{min <= max}) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None)) =

parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t{min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end

LowParse.Spec.DER.fst

val parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t{min <= max}) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None))

LowParse.Spec.DER.parse_bounded_der_length_weak_unfold

min: LowParse.Spec.DER.der_length_t -> max: LowParse.Spec.DER.der_length_t{min <= max} -> input: LowParse.Bytes.bytes -> FStar.Pervasives.Lemma (ensures LowParse.Spec.Base.parse (LowParse.Spec.DER.parse_bounded_der_length_weak min max) input == (match LowParse.Spec.Base.parse LowParse.Spec.Int.parse_u8 input with | FStar.Pervasives.Native.None #_ -> FStar.Pervasives.Native.None | FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ x consumed_x) -> let input' = FStar.Seq.Base.slice input consumed_x (FStar.Seq.Base.length input) in (match LowParse.Spec.Base.parse (LowParse.Spec.DER.parse_der_length_payload x) input' with | FStar.Pervasives.Native.None #_ -> FStar.Pervasives.Native.None | FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ y consumed_y) -> (match min <= y && y <= max with | true -> FStar.Pervasives.Native.Some (y, consumed_x + consumed_y) | _ -> FStar.Pervasives.Native.None) <: FStar.Pervasives.Native.option (LowParse.Spec.DER.bounded_int min max * LowParse.Spec.Base.consumed_length input)) <: FStar.Pervasives.Native.option (LowParse.Spec.DER.bounded_int min max * LowParse.Spec.Base.consumed_length input)))

Prims.Tot

val serialize_bounded_der_length32 (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) : Tot (serializer (parse_bounded_der_length32 min max))

let serialize_bounded_der_length32 (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) : Tot (serializer (parse_bounded_der_length32 min max)) = serialize_synth _ (synth_bounded_der_length32 min max) (serialize_bounded_der_length min max) (synth_bounded_der_length32_recip min max) ()

val serialize_bounded_der_length32 (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) : Tot (serializer (parse_bounded_der_length32 min max)) let serialize_bounded_der_length32 (min: der_length_t) (max: der_length_t{min <= max /\ max < 4294967296}) : Tot (serializer (parse_bounded_der_length32 min max)) =

serialize_synth _ (synth_bounded_der_length32 min max) (serialize_bounded_der_length min max) (synth_bounded_der_length32_recip min max) ()

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y let synth_der_length_greater_inverse (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) : Lemma (synth_inverse (synth_der_length_greater x len) (synth_der_length_greater_recip x len)) = () private let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } ) = (serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () ) let tag_of_der_length_lt_128_eta (x:U8.t{U8.v x < 128}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_lt_128 y <: Lemma (U8.v x == y) let tag_of_der_length_invalid_eta (x:U8.t{U8.v x == 128 \/ U8.v x == 255}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_invalid y <: Lemma False let tag_of_der_length_eq_129_eta (x:U8.t{U8.v x == 129}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_eq_129 y <: Lemma (synth_der_length_129 x (synth_der_length_129_recip x y) == y) let serialize_der_length_payload (x: U8.t) : Tot (serializer (parse_der_length_payload x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_ret (x' <: refine_with_tag tag_of_der_length x) (tag_of_der_length_lt_128_eta x)) end else if x = 128uy || x = 255uy then fail_serializer (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) (tag_of_der_length_invalid_eta x) else if x = 129uy then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_synth (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) ) end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? serialize_weaken (parse_der_length_payload_kind x) (serialize_der_length_payload_greater x len) end let serialize_der_length_weak : serializer parse_der_length_weak = serialize_tagged_union serialize_u8 tag_of_der_length (fun x -> serialize_weaken parse_der_length_payload_kind_weak (serialize_der_length_payload x)) #push-options "--max_ifuel 6 --z3rlimit 64" let serialize_der_length_weak_unfold (y: der_length_t) : Lemma (let res = serialize serialize_der_length_weak y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = let x = tag_of_der_length y in serialize_u8_spec x; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy || x = 255uy then tag_of_der_length_invalid y else if x = 129uy then begin tag_of_der_length_eq_129 y; assert (U8.v (synth_der_length_129_recip x y) == y); let s1 = serialize ( serialize_synth #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x))) y in serialize_synth_eq' #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) y s1 () (serialize serialize_u8 (synth_der_length_129_recip x y)) () ; serialize_u8_spec (U8.uint_to_t y); () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? assert ( serialize (serialize_der_length_payload x) y == serialize (serialize_der_length_payload_greater x len) y ); serialize_synth_eq' #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () y (serialize (serialize_der_length_payload_greater x len) y) (_ by (FStar.Tactics.trefl ())) (serialize (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (synth_der_length_greater_recip x len y) ) () ; serialize_synth_eq _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () (synth_der_length_greater_recip x len y); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); () end; () #pop-options let serialize_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length_weak min max)) = serialize_synth _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () let serialize_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length min max)) = Classical.forall_intro (parse_bounded_der_length_eq min max); serialize_ext _ (serialize_bounded_der_length_weak min max) (parse_bounded_der_length min max) let serialize_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (y: bounded_int min max) : Lemma (let res = serialize (serialize_bounded_der_length min max) y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = serialize_synth_eq _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () y; serialize_der_length_weak_unfold y (* 32-bit spec *) module U32 = FStar.UInt32 let der_length_payload_size_of_tag_inv32 (x: der_length_t) : Lemma (requires (x < 4294967296)) (ensures ( tag_of_der_length x == ( if x < 128 then U8.uint_to_t x else if x < 256 then 129uy else if x < 65536 then 130uy else if x < 16777216 then 131uy else 132uy ))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126); assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); if x < 256 then log256_unique x 1 else if x < 65536 then log256_unique x 2 else if x < 16777216 then log256_unique x 3 else log256_unique x 4 let synth_der_length_payload32 (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) (y: refine_with_tag tag_of_der_length x) : GTot (refine_with_tag tag_of_der_length32 x) = let _ = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in if y >= 128 then begin Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end in U32.uint_to_t y let synth_der_length_payload32_injective (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) : Lemma (synth_injective (synth_der_length_payload32 x)) [SMTPat (synth_injective (synth_der_length_payload32 x))] = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in synth_injective_intro' (synth_der_length_payload32 x) (fun (y1 y2: refine_with_tag tag_of_der_length x) -> if y1 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y1 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y1) == 128 + log256 y1) end; if y2 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y2 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y2) == 128 + log256 y2) end ) let parse_der_length_payload32 x : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length32 x)) = parse_der_length_payload x `parse_synth` synth_der_length_payload32 x let be_int_of_bounded_integer (len: integer_size) (x: nat { x < pow2 (8 * len) } ) : GTot (bounded_integer len) = integer_size_values len; assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); U32.uint_to_t x let be_int_of_bounded_integer_injective (len: integer_size) : Lemma (synth_injective (be_int_of_bounded_integer len)) [SMTPat (synth_injective (be_int_of_bounded_integer len))] // FIXME: WHY WHY WHY does this pattern NEVER trigger? = integer_size_values len; assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296) #push-options "--max_ifuel 4 --z3rlimit 16" let parse_seq_flbytes_synth_be_int_eq (len: integer_size) (input: bytes) : Lemma ( let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse ( parse_synth #_ #(lint len) #(bounded_integer len) (parse_synth #_ #(Seq.lseq byte len) #(lint len) (parse_seq_flbytes len) (synth_be_int len) ) (be_int_of_bounded_integer len) ) input == parse (parse_bounded_integer len) input) = let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse_synth_eq (parse_seq_flbytes len `parse_synth` synth_be_int len) (be_int_of_bounded_integer len) input; parse_synth_eq (parse_seq_flbytes len) (synth_be_int len) input; parser_kind_prop_equiv (parse_bounded_integer_kind len) (parse_bounded_integer len); parse_bounded_integer_spec len input let parse_der_length_payload32_unfold x input = parse_synth_eq (parse_der_length_payload x) (synth_der_length_payload32 x) input; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 (8 * 1) == 256); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in begin match parse (parse_der_length_payload x) input with | None -> () | Some (y, _) -> if y >= 128 then begin Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end end; parse_der_length_payload_unfold x input; if U8.v x < 128 then () // tag_of_der_length (U8.v x) == x /\ y == Some (Cast.uint8_to_uint32 x, 0) else if x = 128uy || x = 255uy then () // y == None else if x = 129uy then () else begin let len : nat = U8.v x - 128 in assert (2 <= len /\ len <= 4); let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse_seq_flbytes_synth_be_int_eq len input; integer_size_values len; parse_synth_eq #_ #(lint len) #(bounded_integer len) (parse_synth #_ #(Seq.lseq byte len) #(lint len) (parse_seq_flbytes len) (synth_be_int len)) (be_int_of_bounded_integer len) input end #pop-options let log256_eq x = log256_unique x (log256' x) let synth_bounded_der_length32 (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) (x: bounded_int min max) : Tot (bounded_int32 min max) = U32.uint_to_t x let parse_bounded_der_length32 (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) : Tot (parser (parse_bounded_der_length32_kind min max) (bounded_int32 min max)) = parse_bounded_der_length min max `parse_synth` synth_bounded_der_length32 min max #push-options "--z3rlimit 50" let parse_bounded_der_length32_unfold min max input = parse_synth_eq (parse_bounded_der_length min max) (synth_bounded_der_length32 min max) input; parse_bounded_der_length_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in assert_norm (4294967296 <= der_length_max); der_length_payload_size_le max 4294967295; assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); log256_unique 4294967295 4; parse_synth_eq (parse_der_length_payload x) (synth_der_length_payload32 x) input' ; match parse (parse_der_length_payload x) input' with | None -> () | Some (y, _) -> if y >= 128 then begin assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end else () #pop-options let synth_bounded_der_length32_recip (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) (x: bounded_int32 min max) : GTot (bounded_int min max) = U32.v x let serialize_bounded_der_length32 (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 })

LowParse.Spec.DER.fst

val serialize_bounded_der_length32 (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) : Tot (serializer (parse_bounded_der_length32 min max))

LowParse.Spec.DER.serialize_bounded_der_length32

min: LowParse.Spec.DER.der_length_t -> max: LowParse.Spec.DER.der_length_t{min <= max /\ max < 4294967296} -> LowParse.Spec.Base.serializer (LowParse.Spec.DER.parse_bounded_der_length32 min max)

Prims.Tot

val parse_der_length_weak:parser parse_der_length_weak_kind der_length_t

let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x))

val parse_der_length_weak:parser parse_der_length_weak_kind der_length_t let parse_der_length_weak:parser parse_der_length_weak_kind der_length_t =

parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x))

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak

LowParse.Spec.DER.fst

val parse_der_length_weak:parser parse_der_length_weak_kind der_length_t

LowParse.Spec.DER.parse_der_length_weak

LowParse.Spec.Base.parser LowParse.Spec.DER.parse_der_length_weak_kind LowParse.Spec.DER.der_length_t

FStar.Pervasives.Lemma

val der_length_payload_size_le (x1 x2: der_length_t) : Lemma (requires (x1 <= x2)) (ensures (der_length_payload_size x1 <= der_length_payload_size x2))

let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126)

val der_length_payload_size_le (x1 x2: der_length_t) : Lemma (requires (x1 <= x2)) (ensures (der_length_payload_size x1 <= der_length_payload_size x2)) let der_length_payload_size_le x1 x2 =

if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126)

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1

LowParse.Spec.DER.fst

val der_length_payload_size_le (x1 x2: der_length_t) : Lemma (requires (x1 <= x2)) (ensures (der_length_payload_size x1 <= der_length_payload_size x2))

LowParse.Spec.DER.der_length_payload_size_le

x1: LowParse.Spec.DER.der_length_t -> x2: LowParse.Spec.DER.der_length_t -> FStar.Pervasives.Lemma (requires x1 <= x2) (ensures LowParse.Spec.DER.der_length_payload_size x1 <= LowParse.Spec.DER.der_length_payload_size x2 )

FStar.Pervasives.Lemma

val tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False)

let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126)

val tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) =

if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126)

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255))

LowParse.Spec.DER.fst

val tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False)

LowParse.Spec.DER.tag_of_der_length_invalid

x: LowParse.Spec.DER.der_length_t -> FStar.Pervasives.Lemma (requires (let y = FStar.UInt8.v (LowParse.Spec.DER.tag_of_der_length x) in y == 128 \/ y == 255)) (ensures Prims.l_False)

Prims.Tot

val synth_der_length_129 (x: U8.t{x == 129uy}) (y: U8.t{U8.v y >= 128}) : Tot (refine_with_tag tag_of_der_length x)

let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y

val synth_der_length_129 (x: U8.t{x == 129uy}) (y: U8.t{U8.v y >= 128}) : Tot (refine_with_tag tag_of_der_length x) let synth_der_length_129 (x: U8.t{x == 129uy}) (y: U8.t{U8.v y >= 128}) : Tot (refine_with_tag tag_of_der_length x) =

assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } )

LowParse.Spec.DER.fst

val synth_der_length_129 (x: U8.t{x == 129uy}) (y: U8.t{U8.v y >= 128}) : Tot (refine_with_tag tag_of_der_length x)

LowParse.Spec.DER.synth_der_length_129

x: FStar.UInt8.t{x == 129uy} -> y: FStar.UInt8.t{FStar.UInt8.v y >= 128} -> LowParse.Spec.Base.refine_with_tag LowParse.Spec.DER.tag_of_der_length x

FStar.Pervasives.Lemma

val tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256))

let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126)

val tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) =

if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126)

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129))

LowParse.Spec.DER.fst

val tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256))

LowParse.Spec.DER.tag_of_der_length_eq_129

x: LowParse.Spec.DER.der_length_t -> FStar.Pervasives.Lemma (requires FStar.UInt8.v (LowParse.Spec.DER.tag_of_der_length x) == 129) (ensures x >= 128 /\ x < 256)

Prims.GTot

val synth_der_length_payload32 (x: U8.t{der_length_payload_size_of_tag x <= 4}) (y: refine_with_tag tag_of_der_length x) : GTot (refine_with_tag tag_of_der_length32 x)

let synth_der_length_payload32 (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) (y: refine_with_tag tag_of_der_length x) : GTot (refine_with_tag tag_of_der_length32 x) = let _ = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in if y >= 128 then begin Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end in U32.uint_to_t y

val synth_der_length_payload32 (x: U8.t{der_length_payload_size_of_tag x <= 4}) (y: refine_with_tag tag_of_der_length x) : GTot (refine_with_tag tag_of_der_length32 x) let synth_der_length_payload32 (x: U8.t{der_length_payload_size_of_tag x <= 4}) (y: refine_with_tag tag_of_der_length x) : GTot (refine_with_tag tag_of_der_length32 x) =

let _ = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in if y >= 128 then (Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y)) in U32.uint_to_t y

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y let synth_der_length_greater_inverse (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) : Lemma (synth_inverse (synth_der_length_greater x len) (synth_der_length_greater_recip x len)) = () private let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } ) = (serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () ) let tag_of_der_length_lt_128_eta (x:U8.t{U8.v x < 128}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_lt_128 y <: Lemma (U8.v x == y) let tag_of_der_length_invalid_eta (x:U8.t{U8.v x == 128 \/ U8.v x == 255}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_invalid y <: Lemma False let tag_of_der_length_eq_129_eta (x:U8.t{U8.v x == 129}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_eq_129 y <: Lemma (synth_der_length_129 x (synth_der_length_129_recip x y) == y) let serialize_der_length_payload (x: U8.t) : Tot (serializer (parse_der_length_payload x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_ret (x' <: refine_with_tag tag_of_der_length x) (tag_of_der_length_lt_128_eta x)) end else if x = 128uy || x = 255uy then fail_serializer (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) (tag_of_der_length_invalid_eta x) else if x = 129uy then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_synth (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) ) end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? serialize_weaken (parse_der_length_payload_kind x) (serialize_der_length_payload_greater x len) end let serialize_der_length_weak : serializer parse_der_length_weak = serialize_tagged_union serialize_u8 tag_of_der_length (fun x -> serialize_weaken parse_der_length_payload_kind_weak (serialize_der_length_payload x)) #push-options "--max_ifuel 6 --z3rlimit 64" let serialize_der_length_weak_unfold (y: der_length_t) : Lemma (let res = serialize serialize_der_length_weak y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = let x = tag_of_der_length y in serialize_u8_spec x; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy || x = 255uy then tag_of_der_length_invalid y else if x = 129uy then begin tag_of_der_length_eq_129 y; assert (U8.v (synth_der_length_129_recip x y) == y); let s1 = serialize ( serialize_synth #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x))) y in serialize_synth_eq' #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) y s1 () (serialize serialize_u8 (synth_der_length_129_recip x y)) () ; serialize_u8_spec (U8.uint_to_t y); () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? assert ( serialize (serialize_der_length_payload x) y == serialize (serialize_der_length_payload_greater x len) y ); serialize_synth_eq' #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () y (serialize (serialize_der_length_payload_greater x len) y) (_ by (FStar.Tactics.trefl ())) (serialize (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (synth_der_length_greater_recip x len y) ) () ; serialize_synth_eq _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () (synth_der_length_greater_recip x len y); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); () end; () #pop-options let serialize_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length_weak min max)) = serialize_synth _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () let serialize_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length min max)) = Classical.forall_intro (parse_bounded_der_length_eq min max); serialize_ext _ (serialize_bounded_der_length_weak min max) (parse_bounded_der_length min max) let serialize_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (y: bounded_int min max) : Lemma (let res = serialize (serialize_bounded_der_length min max) y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = serialize_synth_eq _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () y; serialize_der_length_weak_unfold y (* 32-bit spec *) module U32 = FStar.UInt32 let der_length_payload_size_of_tag_inv32 (x: der_length_t) : Lemma (requires (x < 4294967296)) (ensures ( tag_of_der_length x == ( if x < 128 then U8.uint_to_t x else if x < 256 then 129uy else if x < 65536 then 130uy else if x < 16777216 then 131uy else 132uy ))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126); assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); if x < 256 then log256_unique x 1 else if x < 65536 then log256_unique x 2 else if x < 16777216 then log256_unique x 3 else log256_unique x 4 let synth_der_length_payload32 (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) (y: refine_with_tag tag_of_der_length x)

LowParse.Spec.DER.fst

val synth_der_length_payload32 (x: U8.t{der_length_payload_size_of_tag x <= 4}) (y: refine_with_tag tag_of_der_length x) : GTot (refine_with_tag tag_of_der_length32 x)

LowParse.Spec.DER.synth_der_length_payload32

x: FStar.UInt8.t{LowParse.Spec.DER.der_length_payload_size_of_tag x <= 4} -> y: LowParse.Spec.Base.refine_with_tag LowParse.Spec.DER.tag_of_der_length x -> Prims.GTot (LowParse.Spec.Base.refine_with_tag LowParse.Spec.DER.tag_of_der_length32 x)

Prims.Tot

val synth_der_length_greater_recip (x: U8.t{U8.v x > 129 /\ U8.v x < 255}) (len: nat{len == U8.v x % 128}) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len {y >= pow2 (8 * (len - 1))})

let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y

val synth_der_length_greater_recip (x: U8.t{U8.v x > 129 /\ U8.v x < 255}) (len: nat{len == U8.v x % 128}) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len {y >= pow2 (8 * (len - 1))}) let synth_der_length_greater_recip (x: U8.t{U8.v x > 129 /\ U8.v x < 255}) (len: nat{len == U8.v x % 128}) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len {y >= pow2 (8 * (len - 1))}) =

assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x)

LowParse.Spec.DER.fst

val synth_der_length_greater_recip (x: U8.t{U8.v x > 129 /\ U8.v x < 255}) (len: nat{len == U8.v x % 128}) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len {y >= pow2 (8 * (len - 1))})

LowParse.Spec.DER.synth_der_length_greater_recip

x: FStar.UInt8.t{FStar.UInt8.v x > 129 /\ FStar.UInt8.v x < 255} -> len: Prims.nat{len == FStar.UInt8.v x % 128} -> y: LowParse.Spec.Base.refine_with_tag LowParse.Spec.DER.tag_of_der_length x -> y: LowParse.Spec.DER.lint len {y >= Prims.pow2 (8 * (len - 1))}

Prims.Tot

val synth_der_length_greater (x: U8.t{U8.v x > 129 /\ U8.v x < 255}) (len: nat{len == U8.v x - 128}) (y: lint len {y >= pow2 (8 * (len - 1))}) : Tot (refine_with_tag tag_of_der_length x)

let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y

val synth_der_length_greater (x: U8.t{U8.v x > 129 /\ U8.v x < 255}) (len: nat{len == U8.v x - 128}) (y: lint len {y >= pow2 (8 * (len - 1))}) : Tot (refine_with_tag tag_of_der_length x) let synth_der_length_greater (x: U8.t{U8.v x > 129 /\ U8.v x < 255}) (len: nat{len == U8.v x - 128}) (y: lint len {y >= pow2 (8 * (len - 1))}) : Tot (refine_with_tag tag_of_der_length x) =

assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } )

LowParse.Spec.DER.fst

val synth_der_length_greater (x: U8.t{U8.v x > 129 /\ U8.v x < 255}) (len: nat{len == U8.v x - 128}) (y: lint len {y >= pow2 (8 * (len - 1))}) : Tot (refine_with_tag tag_of_der_length x)

LowParse.Spec.DER.synth_der_length_greater

x: FStar.UInt8.t{FStar.UInt8.v x > 129 /\ FStar.UInt8.v x < 255} -> len: Prims.nat{len == FStar.UInt8.v x - 128} -> y: LowParse.Spec.DER.lint len {y >= Prims.pow2 (8 * (len - 1))} -> LowParse.Spec.Base.refine_with_tag LowParse.Spec.DER.tag_of_der_length x

FStar.Pervasives.Lemma

val synth_der_length_payload32_injective (x: U8.t{der_length_payload_size_of_tag x <= 4}) : Lemma (synth_injective (synth_der_length_payload32 x)) [SMTPat (synth_injective (synth_der_length_payload32 x))]

let synth_der_length_payload32_injective (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) : Lemma (synth_injective (synth_der_length_payload32 x)) [SMTPat (synth_injective (synth_der_length_payload32 x))] = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in synth_injective_intro' (synth_der_length_payload32 x) (fun (y1 y2: refine_with_tag tag_of_der_length x) -> if y1 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y1 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y1) == 128 + log256 y1) end; if y2 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y2 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y2) == 128 + log256 y2) end )

val synth_der_length_payload32_injective (x: U8.t{der_length_payload_size_of_tag x <= 4}) : Lemma (synth_injective (synth_der_length_payload32 x)) [SMTPat (synth_injective (synth_der_length_payload32 x))] let synth_der_length_payload32_injective (x: U8.t{der_length_payload_size_of_tag x <= 4}) : Lemma (synth_injective (synth_der_length_payload32 x)) [SMTPat (synth_injective (synth_der_length_payload32 x))] =

assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in synth_injective_intro' (synth_der_length_payload32 x) (fun (y1: refine_with_tag tag_of_der_length x) (y2: refine_with_tag tag_of_der_length x) -> if y1 >= 128 then (Math.pow2_lt_recip (8 * (log256 y1 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y1) == 128 + log256 y1)); if y2 >= 128 then (Math.pow2_lt_recip (8 * (log256 y2 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y2) == 128 + log256 y2)))

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y let synth_der_length_greater_inverse (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) : Lemma (synth_inverse (synth_der_length_greater x len) (synth_der_length_greater_recip x len)) = () private let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } ) = (serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () ) let tag_of_der_length_lt_128_eta (x:U8.t{U8.v x < 128}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_lt_128 y <: Lemma (U8.v x == y) let tag_of_der_length_invalid_eta (x:U8.t{U8.v x == 128 \/ U8.v x == 255}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_invalid y <: Lemma False let tag_of_der_length_eq_129_eta (x:U8.t{U8.v x == 129}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_eq_129 y <: Lemma (synth_der_length_129 x (synth_der_length_129_recip x y) == y) let serialize_der_length_payload (x: U8.t) : Tot (serializer (parse_der_length_payload x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_ret (x' <: refine_with_tag tag_of_der_length x) (tag_of_der_length_lt_128_eta x)) end else if x = 128uy || x = 255uy then fail_serializer (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) (tag_of_der_length_invalid_eta x) else if x = 129uy then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_synth (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) ) end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? serialize_weaken (parse_der_length_payload_kind x) (serialize_der_length_payload_greater x len) end let serialize_der_length_weak : serializer parse_der_length_weak = serialize_tagged_union serialize_u8 tag_of_der_length (fun x -> serialize_weaken parse_der_length_payload_kind_weak (serialize_der_length_payload x)) #push-options "--max_ifuel 6 --z3rlimit 64" let serialize_der_length_weak_unfold (y: der_length_t) : Lemma (let res = serialize serialize_der_length_weak y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = let x = tag_of_der_length y in serialize_u8_spec x; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy || x = 255uy then tag_of_der_length_invalid y else if x = 129uy then begin tag_of_der_length_eq_129 y; assert (U8.v (synth_der_length_129_recip x y) == y); let s1 = serialize ( serialize_synth #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x))) y in serialize_synth_eq' #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) y s1 () (serialize serialize_u8 (synth_der_length_129_recip x y)) () ; serialize_u8_spec (U8.uint_to_t y); () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? assert ( serialize (serialize_der_length_payload x) y == serialize (serialize_der_length_payload_greater x len) y ); serialize_synth_eq' #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () y (serialize (serialize_der_length_payload_greater x len) y) (_ by (FStar.Tactics.trefl ())) (serialize (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (synth_der_length_greater_recip x len y) ) () ; serialize_synth_eq _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () (synth_der_length_greater_recip x len y); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); () end; () #pop-options let serialize_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length_weak min max)) = serialize_synth _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () let serialize_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length min max)) = Classical.forall_intro (parse_bounded_der_length_eq min max); serialize_ext _ (serialize_bounded_der_length_weak min max) (parse_bounded_der_length min max) let serialize_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (y: bounded_int min max) : Lemma (let res = serialize (serialize_bounded_der_length min max) y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = serialize_synth_eq _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () y; serialize_der_length_weak_unfold y (* 32-bit spec *) module U32 = FStar.UInt32 let der_length_payload_size_of_tag_inv32 (x: der_length_t) : Lemma (requires (x < 4294967296)) (ensures ( tag_of_der_length x == ( if x < 128 then U8.uint_to_t x else if x < 256 then 129uy else if x < 65536 then 130uy else if x < 16777216 then 131uy else 132uy ))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126); assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); if x < 256 then log256_unique x 1 else if x < 65536 then log256_unique x 2 else if x < 16777216 then log256_unique x 3 else log256_unique x 4 let synth_der_length_payload32 (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) (y: refine_with_tag tag_of_der_length x) : GTot (refine_with_tag tag_of_der_length32 x) = let _ = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in if y >= 128 then begin Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end in U32.uint_to_t y let synth_der_length_payload32_injective (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) : Lemma (synth_injective (synth_der_length_payload32 x))

LowParse.Spec.DER.fst

val synth_der_length_payload32_injective (x: U8.t{der_length_payload_size_of_tag x <= 4}) : Lemma (synth_injective (synth_der_length_payload32 x)) [SMTPat (synth_injective (synth_der_length_payload32 x))]

LowParse.Spec.DER.synth_der_length_payload32_injective

x: FStar.UInt8.t{LowParse.Spec.DER.der_length_payload_size_of_tag x <= 4} -> FStar.Pervasives.Lemma (ensures LowParse.Spec.Combinators.synth_injective (LowParse.Spec.DER.synth_der_length_payload32 x)) [ SMTPat (LowParse.Spec.Combinators.synth_injective (LowParse.Spec.DER.synth_der_length_payload32 x)) ]

FStar.Pervasives.Lemma

val der_length_payload_size_of_tag_inv32 (x: der_length_t) : Lemma (requires (x < 4294967296)) (ensures (tag_of_der_length x == (if x < 128 then U8.uint_to_t x else if x < 256 then 129uy else if x < 65536 then 130uy else if x < 16777216 then 131uy else 132uy)))

let der_length_payload_size_of_tag_inv32 (x: der_length_t) : Lemma (requires (x < 4294967296)) (ensures ( tag_of_der_length x == ( if x < 128 then U8.uint_to_t x else if x < 256 then 129uy else if x < 65536 then 130uy else if x < 16777216 then 131uy else 132uy ))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126); assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); if x < 256 then log256_unique x 1 else if x < 65536 then log256_unique x 2 else if x < 16777216 then log256_unique x 3 else log256_unique x 4

val der_length_payload_size_of_tag_inv32 (x: der_length_t) : Lemma (requires (x < 4294967296)) (ensures (tag_of_der_length x == (if x < 128 then U8.uint_to_t x else if x < 256 then 129uy else if x < 65536 then 130uy else if x < 16777216 then 131uy else 132uy))) let der_length_payload_size_of_tag_inv32 (x: der_length_t) : Lemma (requires (x < 4294967296)) (ensures (tag_of_der_length x == (if x < 128 then U8.uint_to_t x else if x < 256 then 129uy else if x < 65536 then 130uy else if x < 16777216 then 131uy else 132uy))) =

if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126); assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); if x < 256 then log256_unique x 1 else if x < 65536 then log256_unique x 2 else if x < 16777216 then log256_unique x 3 else log256_unique x 4

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y let synth_der_length_greater_inverse (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) : Lemma (synth_inverse (synth_der_length_greater x len) (synth_der_length_greater_recip x len)) = () private let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } ) = (serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () ) let tag_of_der_length_lt_128_eta (x:U8.t{U8.v x < 128}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_lt_128 y <: Lemma (U8.v x == y) let tag_of_der_length_invalid_eta (x:U8.t{U8.v x == 128 \/ U8.v x == 255}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_invalid y <: Lemma False let tag_of_der_length_eq_129_eta (x:U8.t{U8.v x == 129}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_eq_129 y <: Lemma (synth_der_length_129 x (synth_der_length_129_recip x y) == y) let serialize_der_length_payload (x: U8.t) : Tot (serializer (parse_der_length_payload x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_ret (x' <: refine_with_tag tag_of_der_length x) (tag_of_der_length_lt_128_eta x)) end else if x = 128uy || x = 255uy then fail_serializer (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) (tag_of_der_length_invalid_eta x) else if x = 129uy then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_synth (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) ) end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? serialize_weaken (parse_der_length_payload_kind x) (serialize_der_length_payload_greater x len) end let serialize_der_length_weak : serializer parse_der_length_weak = serialize_tagged_union serialize_u8 tag_of_der_length (fun x -> serialize_weaken parse_der_length_payload_kind_weak (serialize_der_length_payload x)) #push-options "--max_ifuel 6 --z3rlimit 64" let serialize_der_length_weak_unfold (y: der_length_t) : Lemma (let res = serialize serialize_der_length_weak y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = let x = tag_of_der_length y in serialize_u8_spec x; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy || x = 255uy then tag_of_der_length_invalid y else if x = 129uy then begin tag_of_der_length_eq_129 y; assert (U8.v (synth_der_length_129_recip x y) == y); let s1 = serialize ( serialize_synth #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x))) y in serialize_synth_eq' #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) y s1 () (serialize serialize_u8 (synth_der_length_129_recip x y)) () ; serialize_u8_spec (U8.uint_to_t y); () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? assert ( serialize (serialize_der_length_payload x) y == serialize (serialize_der_length_payload_greater x len) y ); serialize_synth_eq' #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () y (serialize (serialize_der_length_payload_greater x len) y) (_ by (FStar.Tactics.trefl ())) (serialize (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (synth_der_length_greater_recip x len y) ) () ; serialize_synth_eq _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () (synth_der_length_greater_recip x len y); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); () end; () #pop-options let serialize_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length_weak min max)) = serialize_synth _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () let serialize_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length min max)) = Classical.forall_intro (parse_bounded_der_length_eq min max); serialize_ext _ (serialize_bounded_der_length_weak min max) (parse_bounded_der_length min max) let serialize_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (y: bounded_int min max) : Lemma (let res = serialize (serialize_bounded_der_length min max) y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = serialize_synth_eq _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () y; serialize_der_length_weak_unfold y (* 32-bit spec *) module U32 = FStar.UInt32 let der_length_payload_size_of_tag_inv32 (x: der_length_t) : Lemma (requires (x < 4294967296)) (ensures ( tag_of_der_length x == ( if x < 128 then U8.uint_to_t x else if x < 256 then 129uy else if x < 65536 then 130uy else if x < 16777216 then 131uy else 132uy

LowParse.Spec.DER.fst

val der_length_payload_size_of_tag_inv32 (x: der_length_t) : Lemma (requires (x < 4294967296)) (ensures (tag_of_der_length x == (if x < 128 then U8.uint_to_t x else if x < 256 then 129uy else if x < 65536 then 130uy else if x < 16777216 then 131uy else 132uy)))

LowParse.Spec.DER.der_length_payload_size_of_tag_inv32

x: LowParse.Spec.DER.der_length_t -> FStar.Pervasives.Lemma (requires x < 4294967296) (ensures LowParse.Spec.DER.tag_of_der_length x == (match x < 128 with | true -> FStar.UInt8.uint_to_t x | _ -> (match x < 256 with | true -> 129uy | _ -> (match x < 65536 with | true -> 130uy | _ -> (match x < 16777216 with | true -> 131uy | _ -> 132uy) <: FStar.UInt8.t) <: FStar.UInt8.t) <: FStar.UInt8.t))

Prims.Tot

val serialize_der_length_payload (x: U8.t) : Tot (serializer (parse_der_length_payload x))

let serialize_der_length_payload (x: U8.t) : Tot (serializer (parse_der_length_payload x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_ret (x' <: refine_with_tag tag_of_der_length x) (tag_of_der_length_lt_128_eta x)) end else if x = 128uy || x = 255uy then fail_serializer (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) (tag_of_der_length_invalid_eta x) else if x = 129uy then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_synth (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) ) end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? serialize_weaken (parse_der_length_payload_kind x) (serialize_der_length_payload_greater x len) end

val serialize_der_length_payload (x: U8.t) : Tot (serializer (parse_der_length_payload x)) let serialize_der_length_payload (x: U8.t) : Tot (serializer (parse_der_length_payload x)) =

assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let x':der_length_t = U8.v x in if x' < 128 then serialize_weaken (parse_der_length_payload_kind x) (serialize_ret (x' <: refine_with_tag tag_of_der_length x) (tag_of_der_length_lt_128_eta x)) else if x = 128uy || x = 255uy then fail_serializer (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) (tag_of_der_length_invalid_eta x) else if x = 129uy then serialize_weaken (parse_der_length_payload_kind x) (serialize_synth (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x))) else let len:nat = U8.v x - 128 in synth_be_int_injective len; serialize_weaken (parse_der_length_payload_kind x) (serialize_der_length_payload_greater x len)

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y let synth_der_length_greater_inverse (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) : Lemma (synth_inverse (synth_der_length_greater x len) (synth_der_length_greater_recip x len)) = () private let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } ) = (serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () ) let tag_of_der_length_lt_128_eta (x:U8.t{U8.v x < 128}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_lt_128 y <: Lemma (U8.v x == y) let tag_of_der_length_invalid_eta (x:U8.t{U8.v x == 128 \/ U8.v x == 255}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_invalid y <: Lemma False let tag_of_der_length_eq_129_eta (x:U8.t{U8.v x == 129}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_eq_129 y <: Lemma (synth_der_length_129 x (synth_der_length_129_recip x y) == y) let serialize_der_length_payload (x: U8.t)

LowParse.Spec.DER.fst

val serialize_der_length_payload (x: U8.t) : Tot (serializer (parse_der_length_payload x))

LowParse.Spec.DER.serialize_der_length_payload

x: FStar.UInt8.t -> LowParse.Spec.Base.serializer (LowParse.Spec.DER.parse_der_length_payload x)

Prims.GTot

val synth_be_int_recip (len: nat) (x: lint len) : GTot (b : Seq.lseq byte len)

let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x

val synth_be_int_recip (len: nat) (x: lint len) : GTot (b : Seq.lseq byte len) let synth_be_int_recip (len: nat) (x: lint len) : GTot (b : Seq.lseq byte len) =

E.n_to_be len x

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len)

LowParse.Spec.DER.fst

val synth_be_int_recip (len: nat) (x: lint len) : GTot (b : Seq.lseq byte len)

LowParse.Spec.DER.synth_be_int_recip

len: Prims.nat -> x: LowParse.Spec.DER.lint len -> Prims.GTot (FStar.Seq.Properties.lseq LowParse.Bytes.byte len)

FStar.Pervasives.Lemma

val serialize_bounded_der_length32_unfold (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) (y': bounded_int32 min max) : Lemma ( let res = serialize (serialize_bounded_der_length32 min max) y' in let x = tag_of_der_length32_impl y' in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then U32.v y' <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (Cast.uint32_to_uint8 y')) else let len = log256' (U32.v y') in res `Seq.equal` (s1 `Seq.append` serialize (serialize_bounded_integer len) y') )

let serialize_bounded_der_length32_unfold min max y' = serialize_synth_eq _ (synth_bounded_der_length32 min max) (serialize_bounded_der_length min max) (synth_bounded_der_length32_recip min max) () y'; serialize_bounded_der_length_unfold min max (U32.v y'); let x = tag_of_der_length32_impl y' in if x `U8.lt` 128uy then () else if x = 129uy then FStar.Math.Lemmas.small_modulo_lemma_1 (U32.v y') 256 else begin assert (x <> 128uy /\ x <> 255uy); let len = log256' (U32.v y') in log256_eq (U32.v y'); serialize_bounded_integer_spec len y' end

val serialize_bounded_der_length32_unfold (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) (y': bounded_int32 min max) : Lemma ( let res = serialize (serialize_bounded_der_length32 min max) y' in let x = tag_of_der_length32_impl y' in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then U32.v y' <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (Cast.uint32_to_uint8 y')) else let len = log256' (U32.v y') in res `Seq.equal` (s1 `Seq.append` serialize (serialize_bounded_integer len) y') ) let serialize_bounded_der_length32_unfold min max y' =

serialize_synth_eq _ (synth_bounded_der_length32 min max) (serialize_bounded_der_length min max) (synth_bounded_der_length32_recip min max) () y'; serialize_bounded_der_length_unfold min max (U32.v y'); let x = tag_of_der_length32_impl y' in if x `U8.lt` 128uy then () else if x = 129uy then FStar.Math.Lemmas.small_modulo_lemma_1 (U32.v y') 256 else (assert (x <> 128uy /\ x <> 255uy); let len = log256' (U32.v y') in log256_eq (U32.v y'); serialize_bounded_integer_spec len y')

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y let synth_der_length_greater_inverse (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) : Lemma (synth_inverse (synth_der_length_greater x len) (synth_der_length_greater_recip x len)) = () private let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } ) = (serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () ) let tag_of_der_length_lt_128_eta (x:U8.t{U8.v x < 128}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_lt_128 y <: Lemma (U8.v x == y) let tag_of_der_length_invalid_eta (x:U8.t{U8.v x == 128 \/ U8.v x == 255}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_invalid y <: Lemma False let tag_of_der_length_eq_129_eta (x:U8.t{U8.v x == 129}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_eq_129 y <: Lemma (synth_der_length_129 x (synth_der_length_129_recip x y) == y) let serialize_der_length_payload (x: U8.t) : Tot (serializer (parse_der_length_payload x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_ret (x' <: refine_with_tag tag_of_der_length x) (tag_of_der_length_lt_128_eta x)) end else if x = 128uy || x = 255uy then fail_serializer (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) (tag_of_der_length_invalid_eta x) else if x = 129uy then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_synth (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) ) end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? serialize_weaken (parse_der_length_payload_kind x) (serialize_der_length_payload_greater x len) end let serialize_der_length_weak : serializer parse_der_length_weak = serialize_tagged_union serialize_u8 tag_of_der_length (fun x -> serialize_weaken parse_der_length_payload_kind_weak (serialize_der_length_payload x)) #push-options "--max_ifuel 6 --z3rlimit 64" let serialize_der_length_weak_unfold (y: der_length_t) : Lemma (let res = serialize serialize_der_length_weak y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = let x = tag_of_der_length y in serialize_u8_spec x; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy || x = 255uy then tag_of_der_length_invalid y else if x = 129uy then begin tag_of_der_length_eq_129 y; assert (U8.v (synth_der_length_129_recip x y) == y); let s1 = serialize ( serialize_synth #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x))) y in serialize_synth_eq' #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) y s1 () (serialize serialize_u8 (synth_der_length_129_recip x y)) () ; serialize_u8_spec (U8.uint_to_t y); () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? assert ( serialize (serialize_der_length_payload x) y == serialize (serialize_der_length_payload_greater x len) y ); serialize_synth_eq' #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () y (serialize (serialize_der_length_payload_greater x len) y) (_ by (FStar.Tactics.trefl ())) (serialize (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (synth_der_length_greater_recip x len y) ) () ; serialize_synth_eq _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () (synth_der_length_greater_recip x len y); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); () end; () #pop-options let serialize_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length_weak min max)) = serialize_synth _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () let serialize_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length min max)) = Classical.forall_intro (parse_bounded_der_length_eq min max); serialize_ext _ (serialize_bounded_der_length_weak min max) (parse_bounded_der_length min max) let serialize_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (y: bounded_int min max) : Lemma (let res = serialize (serialize_bounded_der_length min max) y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = serialize_synth_eq _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () y; serialize_der_length_weak_unfold y (* 32-bit spec *) module U32 = FStar.UInt32 let der_length_payload_size_of_tag_inv32 (x: der_length_t) : Lemma (requires (x < 4294967296)) (ensures ( tag_of_der_length x == ( if x < 128 then U8.uint_to_t x else if x < 256 then 129uy else if x < 65536 then 130uy else if x < 16777216 then 131uy else 132uy ))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126); assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); if x < 256 then log256_unique x 1 else if x < 65536 then log256_unique x 2 else if x < 16777216 then log256_unique x 3 else log256_unique x 4 let synth_der_length_payload32 (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) (y: refine_with_tag tag_of_der_length x) : GTot (refine_with_tag tag_of_der_length32 x) = let _ = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in if y >= 128 then begin Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end in U32.uint_to_t y let synth_der_length_payload32_injective (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) : Lemma (synth_injective (synth_der_length_payload32 x)) [SMTPat (synth_injective (synth_der_length_payload32 x))] = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in synth_injective_intro' (synth_der_length_payload32 x) (fun (y1 y2: refine_with_tag tag_of_der_length x) -> if y1 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y1 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y1) == 128 + log256 y1) end; if y2 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y2 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y2) == 128 + log256 y2) end ) let parse_der_length_payload32 x : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length32 x)) = parse_der_length_payload x `parse_synth` synth_der_length_payload32 x let be_int_of_bounded_integer (len: integer_size) (x: nat { x < pow2 (8 * len) } ) : GTot (bounded_integer len) = integer_size_values len; assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); U32.uint_to_t x let be_int_of_bounded_integer_injective (len: integer_size) : Lemma (synth_injective (be_int_of_bounded_integer len)) [SMTPat (synth_injective (be_int_of_bounded_integer len))] // FIXME: WHY WHY WHY does this pattern NEVER trigger? = integer_size_values len; assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296) #push-options "--max_ifuel 4 --z3rlimit 16" let parse_seq_flbytes_synth_be_int_eq (len: integer_size) (input: bytes) : Lemma ( let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse ( parse_synth #_ #(lint len) #(bounded_integer len) (parse_synth #_ #(Seq.lseq byte len) #(lint len) (parse_seq_flbytes len) (synth_be_int len) ) (be_int_of_bounded_integer len) ) input == parse (parse_bounded_integer len) input) = let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse_synth_eq (parse_seq_flbytes len `parse_synth` synth_be_int len) (be_int_of_bounded_integer len) input; parse_synth_eq (parse_seq_flbytes len) (synth_be_int len) input; parser_kind_prop_equiv (parse_bounded_integer_kind len) (parse_bounded_integer len); parse_bounded_integer_spec len input let parse_der_length_payload32_unfold x input = parse_synth_eq (parse_der_length_payload x) (synth_der_length_payload32 x) input; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 (8 * 1) == 256); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in begin match parse (parse_der_length_payload x) input with | None -> () | Some (y, _) -> if y >= 128 then begin Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end end; parse_der_length_payload_unfold x input; if U8.v x < 128 then () // tag_of_der_length (U8.v x) == x /\ y == Some (Cast.uint8_to_uint32 x, 0) else if x = 128uy || x = 255uy then () // y == None else if x = 129uy then () else begin let len : nat = U8.v x - 128 in assert (2 <= len /\ len <= 4); let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse_seq_flbytes_synth_be_int_eq len input; integer_size_values len; parse_synth_eq #_ #(lint len) #(bounded_integer len) (parse_synth #_ #(Seq.lseq byte len) #(lint len) (parse_seq_flbytes len) (synth_be_int len)) (be_int_of_bounded_integer len) input end #pop-options let log256_eq x = log256_unique x (log256' x) let synth_bounded_der_length32 (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) (x: bounded_int min max) : Tot (bounded_int32 min max) = U32.uint_to_t x let parse_bounded_der_length32 (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) : Tot (parser (parse_bounded_der_length32_kind min max) (bounded_int32 min max)) = parse_bounded_der_length min max `parse_synth` synth_bounded_der_length32 min max #push-options "--z3rlimit 50" let parse_bounded_der_length32_unfold min max input = parse_synth_eq (parse_bounded_der_length min max) (synth_bounded_der_length32 min max) input; parse_bounded_der_length_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in assert_norm (4294967296 <= der_length_max); der_length_payload_size_le max 4294967295; assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); log256_unique 4294967295 4; parse_synth_eq (parse_der_length_payload x) (synth_der_length_payload32 x) input' ; match parse (parse_der_length_payload x) input' with | None -> () | Some (y, _) -> if y >= 128 then begin assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end else () #pop-options let synth_bounded_der_length32_recip (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) (x: bounded_int32 min max) : GTot (bounded_int min max) = U32.v x let serialize_bounded_der_length32 (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) : Tot (serializer (parse_bounded_der_length32 min max)) = serialize_synth _ (synth_bounded_der_length32 min max) (serialize_bounded_der_length min max) (synth_bounded_der_length32_recip min max) () let serialize_bounded_der_length32_unfold

LowParse.Spec.DER.fst

val serialize_bounded_der_length32_unfold (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) (y': bounded_int32 min max) : Lemma ( let res = serialize (serialize_bounded_der_length32 min max) y' in let x = tag_of_der_length32_impl y' in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then U32.v y' <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (Cast.uint32_to_uint8 y')) else let len = log256' (U32.v y') in res `Seq.equal` (s1 `Seq.append` serialize (serialize_bounded_integer len) y') )

LowParse.Spec.DER.serialize_bounded_der_length32_unfold

min: LowParse.Spec.DER.der_length_t -> max: LowParse.Spec.DER.der_length_t{min <= max /\ max < 4294967296} -> y': LowParse.Spec.BoundedInt.bounded_int32 min max -> FStar.Pervasives.Lemma (ensures (let res = LowParse.Spec.Base.serialize (LowParse.Spec.DER.serialize_bounded_der_length32 min max) y' in let x = LowParse.Spec.DER.tag_of_der_length32_impl y' in let s1 = FStar.Seq.Base.create 1 x in (match FStar.UInt8.lt x 128uy with | true -> FStar.Seq.Base.equal res s1 | _ -> (match x = 129uy with | true -> FStar.UInt32.v y' <= 255 /\ FStar.Seq.Base.equal res (FStar.Seq.Base.append s1 (FStar.Seq.Base.create 1 (FStar.Int.Cast.uint32_to_uint8 y'))) | _ -> let len = LowParse.Spec.BoundedInt.log256' (FStar.UInt32.v y') in FStar.Seq.Base.equal res (FStar.Seq.Base.append s1 (LowParse.Spec.Base.serialize (LowParse.Spec.BoundedInt.serialize_bounded_integer len) y'))) <: Type0) <: Type0))

Prims.Tot

val parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x))

let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end

val parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) =

assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let x':der_length_t = U8.v x in if x' < 128 then weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` (synth_der_length_129 x) ) else let len:nat = U8.v x - 128 in synth_be_int_injective len; weaken (parse_der_length_payload_kind x) ((((parse_seq_flbytes len) `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` (synth_der_length_greater x len))

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t)

LowParse.Spec.DER.fst

val parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x))

LowParse.Spec.DER.parse_der_length_payload

x: FStar.UInt8.t -> LowParse.Spec.Base.parser (LowParse.Spec.DER.parse_der_length_payload_kind x) (LowParse.Spec.Base.refine_with_tag LowParse.Spec.DER.tag_of_der_length x)

FStar.Pervasives.Lemma

let tag_of_der_length_invalid_eta (x:U8.t{U8.v x == 128 \/ U8.v x == 255}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_invalid y <: Lemma False

let tag_of_der_length_invalid_eta (x: U8.t{U8.v x == 128 \/ U8.v x == 255}) =

fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_invalid y <: Lemma False

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y let synth_der_length_greater_inverse (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) : Lemma (synth_inverse (synth_der_length_greater x len) (synth_der_length_greater_recip x len)) = () private let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } ) = (serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () ) let tag_of_der_length_lt_128_eta (x:U8.t{U8.v x < 128}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_lt_128 y <: Lemma (U8.v x == y)

LowParse.Spec.DER.fst

val tag_of_der_length_invalid_eta : x: FStar.UInt8.t{FStar.UInt8.v x == 128 \/ FStar.UInt8.v x == 255} -> y: LowParse.Spec.Base.refine_with_tag LowParse.Spec.DER.tag_of_der_length x -> FStar.Pervasives.Lemma (ensures Prims.l_False)

LowParse.Spec.DER.tag_of_der_length_invalid_eta

x: FStar.UInt8.t{FStar.UInt8.v x == 128 \/ FStar.UInt8.v x == 255} -> y: LowParse.Spec.Base.refine_with_tag LowParse.Spec.DER.tag_of_der_length x -> FStar.Pervasives.Lemma (ensures Prims.l_False)

FStar.Pervasives.Lemma

val tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x)))

let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126)

val tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) =

if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126)

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128))

LowParse.Spec.DER.fst

val tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x)))

LowParse.Spec.DER.tag_of_der_length_lt_128

x: LowParse.Spec.DER.der_length_t -> FStar.Pervasives.Lemma (requires FStar.UInt8.v (LowParse.Spec.DER.tag_of_der_length x) < 128) (ensures x == FStar.UInt8.v (LowParse.Spec.DER.tag_of_der_length x))

FStar.Pervasives.Lemma

val parse_bounded_der_length32_unfold (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) (input: bytes) : Lemma (let res = parse (parse_bounded_der_length32 min max) input in match parse parse_u8 input with | None -> res == None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in len <= 4 /\ ( match parse (parse_der_length_payload32 x) input' with | Some (y, consumed_y) -> if min <= U32.v y && U32.v y <= max then res == Some (y, consumed_x + consumed_y) else res == None | None -> res == None ) else res == None )

let parse_bounded_der_length32_unfold min max input = parse_synth_eq (parse_bounded_der_length min max) (synth_bounded_der_length32 min max) input; parse_bounded_der_length_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in assert_norm (4294967296 <= der_length_max); der_length_payload_size_le max 4294967295; assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); log256_unique 4294967295 4; parse_synth_eq (parse_der_length_payload x) (synth_der_length_payload32 x) input' ; match parse (parse_der_length_payload x) input' with | None -> () | Some (y, _) -> if y >= 128 then begin assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end else ()

val parse_bounded_der_length32_unfold (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) (input: bytes) : Lemma (let res = parse (parse_bounded_der_length32 min max) input in match parse parse_u8 input with | None -> res == None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in len <= 4 /\ ( match parse (parse_der_length_payload32 x) input' with | Some (y, consumed_y) -> if min <= U32.v y && U32.v y <= max then res == Some (y, consumed_x + consumed_y) else res == None | None -> res == None ) else res == None ) let parse_bounded_der_length32_unfold min max input =

parse_synth_eq (parse_bounded_der_length min max) (synth_bounded_der_length32 min max) input; parse_bounded_der_length_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in assert_norm (4294967296 <= der_length_max); der_length_payload_size_le max 4294967295; assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); log256_unique 4294967295 4; parse_synth_eq (parse_der_length_payload x) (synth_der_length_payload32 x) input'; match parse (parse_der_length_payload x) input' with | None -> () | Some (y, _) -> if y >= 128 then (assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y))

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y let synth_der_length_greater_inverse (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) : Lemma (synth_inverse (synth_der_length_greater x len) (synth_der_length_greater_recip x len)) = () private let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } ) = (serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () ) let tag_of_der_length_lt_128_eta (x:U8.t{U8.v x < 128}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_lt_128 y <: Lemma (U8.v x == y) let tag_of_der_length_invalid_eta (x:U8.t{U8.v x == 128 \/ U8.v x == 255}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_invalid y <: Lemma False let tag_of_der_length_eq_129_eta (x:U8.t{U8.v x == 129}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_eq_129 y <: Lemma (synth_der_length_129 x (synth_der_length_129_recip x y) == y) let serialize_der_length_payload (x: U8.t) : Tot (serializer (parse_der_length_payload x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_ret (x' <: refine_with_tag tag_of_der_length x) (tag_of_der_length_lt_128_eta x)) end else if x = 128uy || x = 255uy then fail_serializer (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) (tag_of_der_length_invalid_eta x) else if x = 129uy then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_synth (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) ) end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? serialize_weaken (parse_der_length_payload_kind x) (serialize_der_length_payload_greater x len) end let serialize_der_length_weak : serializer parse_der_length_weak = serialize_tagged_union serialize_u8 tag_of_der_length (fun x -> serialize_weaken parse_der_length_payload_kind_weak (serialize_der_length_payload x)) #push-options "--max_ifuel 6 --z3rlimit 64" let serialize_der_length_weak_unfold (y: der_length_t) : Lemma (let res = serialize serialize_der_length_weak y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = let x = tag_of_der_length y in serialize_u8_spec x; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy || x = 255uy then tag_of_der_length_invalid y else if x = 129uy then begin tag_of_der_length_eq_129 y; assert (U8.v (synth_der_length_129_recip x y) == y); let s1 = serialize ( serialize_synth #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x))) y in serialize_synth_eq' #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) y s1 () (serialize serialize_u8 (synth_der_length_129_recip x y)) () ; serialize_u8_spec (U8.uint_to_t y); () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? assert ( serialize (serialize_der_length_payload x) y == serialize (serialize_der_length_payload_greater x len) y ); serialize_synth_eq' #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () y (serialize (serialize_der_length_payload_greater x len) y) (_ by (FStar.Tactics.trefl ())) (serialize (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (synth_der_length_greater_recip x len y) ) () ; serialize_synth_eq _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () (synth_der_length_greater_recip x len y); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); () end; () #pop-options let serialize_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length_weak min max)) = serialize_synth _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () let serialize_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length min max)) = Classical.forall_intro (parse_bounded_der_length_eq min max); serialize_ext _ (serialize_bounded_der_length_weak min max) (parse_bounded_der_length min max) let serialize_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (y: bounded_int min max) : Lemma (let res = serialize (serialize_bounded_der_length min max) y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = serialize_synth_eq _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () y; serialize_der_length_weak_unfold y (* 32-bit spec *) module U32 = FStar.UInt32 let der_length_payload_size_of_tag_inv32 (x: der_length_t) : Lemma (requires (x < 4294967296)) (ensures ( tag_of_der_length x == ( if x < 128 then U8.uint_to_t x else if x < 256 then 129uy else if x < 65536 then 130uy else if x < 16777216 then 131uy else 132uy ))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126); assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); if x < 256 then log256_unique x 1 else if x < 65536 then log256_unique x 2 else if x < 16777216 then log256_unique x 3 else log256_unique x 4 let synth_der_length_payload32 (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) (y: refine_with_tag tag_of_der_length x) : GTot (refine_with_tag tag_of_der_length32 x) = let _ = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in if y >= 128 then begin Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end in U32.uint_to_t y let synth_der_length_payload32_injective (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) : Lemma (synth_injective (synth_der_length_payload32 x)) [SMTPat (synth_injective (synth_der_length_payload32 x))] = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in synth_injective_intro' (synth_der_length_payload32 x) (fun (y1 y2: refine_with_tag tag_of_der_length x) -> if y1 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y1 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y1) == 128 + log256 y1) end; if y2 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y2 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y2) == 128 + log256 y2) end ) let parse_der_length_payload32 x : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length32 x)) = parse_der_length_payload x `parse_synth` synth_der_length_payload32 x let be_int_of_bounded_integer (len: integer_size) (x: nat { x < pow2 (8 * len) } ) : GTot (bounded_integer len) = integer_size_values len; assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); U32.uint_to_t x let be_int_of_bounded_integer_injective (len: integer_size) : Lemma (synth_injective (be_int_of_bounded_integer len)) [SMTPat (synth_injective (be_int_of_bounded_integer len))] // FIXME: WHY WHY WHY does this pattern NEVER trigger? = integer_size_values len; assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296) #push-options "--max_ifuel 4 --z3rlimit 16" let parse_seq_flbytes_synth_be_int_eq (len: integer_size) (input: bytes) : Lemma ( let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse ( parse_synth #_ #(lint len) #(bounded_integer len) (parse_synth #_ #(Seq.lseq byte len) #(lint len) (parse_seq_flbytes len) (synth_be_int len) ) (be_int_of_bounded_integer len) ) input == parse (parse_bounded_integer len) input) = let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse_synth_eq (parse_seq_flbytes len `parse_synth` synth_be_int len) (be_int_of_bounded_integer len) input; parse_synth_eq (parse_seq_flbytes len) (synth_be_int len) input; parser_kind_prop_equiv (parse_bounded_integer_kind len) (parse_bounded_integer len); parse_bounded_integer_spec len input let parse_der_length_payload32_unfold x input = parse_synth_eq (parse_der_length_payload x) (synth_der_length_payload32 x) input; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 (8 * 1) == 256); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in begin match parse (parse_der_length_payload x) input with | None -> () | Some (y, _) -> if y >= 128 then begin Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end end; parse_der_length_payload_unfold x input; if U8.v x < 128 then () // tag_of_der_length (U8.v x) == x /\ y == Some (Cast.uint8_to_uint32 x, 0) else if x = 128uy || x = 255uy then () // y == None else if x = 129uy then () else begin let len : nat = U8.v x - 128 in assert (2 <= len /\ len <= 4); let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse_seq_flbytes_synth_be_int_eq len input; integer_size_values len; parse_synth_eq #_ #(lint len) #(bounded_integer len) (parse_synth #_ #(Seq.lseq byte len) #(lint len) (parse_seq_flbytes len) (synth_be_int len)) (be_int_of_bounded_integer len) input end #pop-options let log256_eq x = log256_unique x (log256' x) let synth_bounded_der_length32 (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) (x: bounded_int min max) : Tot (bounded_int32 min max) = U32.uint_to_t x let parse_bounded_der_length32 (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) : Tot (parser (parse_bounded_der_length32_kind min max) (bounded_int32 min max)) = parse_bounded_der_length min max `parse_synth` synth_bounded_der_length32 min max #push-options "--z3rlimit 50" let parse_bounded_der_length32_unfold min max

LowParse.Spec.DER.fst

val parse_bounded_der_length32_unfold (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) (input: bytes) : Lemma (let res = parse (parse_bounded_der_length32 min max) input in match parse parse_u8 input with | None -> res == None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in len <= 4 /\ ( match parse (parse_der_length_payload32 x) input' with | Some (y, consumed_y) -> if min <= U32.v y && U32.v y <= max then res == Some (y, consumed_x + consumed_y) else res == None | None -> res == None ) else res == None )

LowParse.Spec.DER.parse_bounded_der_length32_unfold

min: LowParse.Spec.DER.der_length_t -> max: LowParse.Spec.DER.der_length_t{min <= max /\ max < 4294967296} -> input: LowParse.Bytes.bytes -> FStar.Pervasives.Lemma (ensures (let res = LowParse.Spec.Base.parse (LowParse.Spec.DER.parse_bounded_der_length32 min max) input in (match LowParse.Spec.Base.parse LowParse.Spec.Int.parse_u8 input with | FStar.Pervasives.Native.None #_ -> res == FStar.Pervasives.Native.None | FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ x consumed_x) -> let len = LowParse.Spec.DER.der_length_payload_size_of_tag x in (match LowParse.Spec.DER.der_length_payload_size min <= len && len <= LowParse.Spec.DER.der_length_payload_size max with | true -> let input' = FStar.Seq.Base.slice input consumed_x (FStar.Seq.Base.length input) in len <= 4 /\ (match LowParse.Spec.Base.parse (LowParse.Spec.DER.parse_der_length_payload32 x) input' with | FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ y consumed_y) -> (match min <= FStar.UInt32.v y && FStar.UInt32.v y <= max with | true -> res == FStar.Pervasives.Native.Some (y, consumed_x + consumed_y) | _ -> res == FStar.Pervasives.Native.None) <: Prims.logical | FStar.Pervasives.Native.None #_ -> res == FStar.Pervasives.Native.None) | _ -> res == FStar.Pervasives.Native.None) <: Type0) <: Type0))

Prims.Tot

val synth_bounded_der_length32 (min: der_length_t) (max: der_length_t{min <= max /\ max < 4294967296}) (x: bounded_int min max) : Tot (bounded_int32 min max)

let synth_bounded_der_length32 (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) (x: bounded_int min max) : Tot (bounded_int32 min max) = U32.uint_to_t x

val synth_bounded_der_length32 (min: der_length_t) (max: der_length_t{min <= max /\ max < 4294967296}) (x: bounded_int min max) : Tot (bounded_int32 min max) let synth_bounded_der_length32 (min: der_length_t) (max: der_length_t{min <= max /\ max < 4294967296}) (x: bounded_int min max) : Tot (bounded_int32 min max) =

U32.uint_to_t x

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y let synth_der_length_greater_inverse (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) : Lemma (synth_inverse (synth_der_length_greater x len) (synth_der_length_greater_recip x len)) = () private let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } ) = (serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () ) let tag_of_der_length_lt_128_eta (x:U8.t{U8.v x < 128}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_lt_128 y <: Lemma (U8.v x == y) let tag_of_der_length_invalid_eta (x:U8.t{U8.v x == 128 \/ U8.v x == 255}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_invalid y <: Lemma False let tag_of_der_length_eq_129_eta (x:U8.t{U8.v x == 129}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_eq_129 y <: Lemma (synth_der_length_129 x (synth_der_length_129_recip x y) == y) let serialize_der_length_payload (x: U8.t) : Tot (serializer (parse_der_length_payload x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_ret (x' <: refine_with_tag tag_of_der_length x) (tag_of_der_length_lt_128_eta x)) end else if x = 128uy || x = 255uy then fail_serializer (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) (tag_of_der_length_invalid_eta x) else if x = 129uy then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_synth (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) ) end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? serialize_weaken (parse_der_length_payload_kind x) (serialize_der_length_payload_greater x len) end let serialize_der_length_weak : serializer parse_der_length_weak = serialize_tagged_union serialize_u8 tag_of_der_length (fun x -> serialize_weaken parse_der_length_payload_kind_weak (serialize_der_length_payload x)) #push-options "--max_ifuel 6 --z3rlimit 64" let serialize_der_length_weak_unfold (y: der_length_t) : Lemma (let res = serialize serialize_der_length_weak y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = let x = tag_of_der_length y in serialize_u8_spec x; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy || x = 255uy then tag_of_der_length_invalid y else if x = 129uy then begin tag_of_der_length_eq_129 y; assert (U8.v (synth_der_length_129_recip x y) == y); let s1 = serialize ( serialize_synth #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x))) y in serialize_synth_eq' #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) y s1 () (serialize serialize_u8 (synth_der_length_129_recip x y)) () ; serialize_u8_spec (U8.uint_to_t y); () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? assert ( serialize (serialize_der_length_payload x) y == serialize (serialize_der_length_payload_greater x len) y ); serialize_synth_eq' #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () y (serialize (serialize_der_length_payload_greater x len) y) (_ by (FStar.Tactics.trefl ())) (serialize (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (synth_der_length_greater_recip x len y) ) () ; serialize_synth_eq _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () (synth_der_length_greater_recip x len y); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); () end; () #pop-options let serialize_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length_weak min max)) = serialize_synth _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () let serialize_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length min max)) = Classical.forall_intro (parse_bounded_der_length_eq min max); serialize_ext _ (serialize_bounded_der_length_weak min max) (parse_bounded_der_length min max) let serialize_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (y: bounded_int min max) : Lemma (let res = serialize (serialize_bounded_der_length min max) y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = serialize_synth_eq _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () y; serialize_der_length_weak_unfold y (* 32-bit spec *) module U32 = FStar.UInt32 let der_length_payload_size_of_tag_inv32 (x: der_length_t) : Lemma (requires (x < 4294967296)) (ensures ( tag_of_der_length x == ( if x < 128 then U8.uint_to_t x else if x < 256 then 129uy else if x < 65536 then 130uy else if x < 16777216 then 131uy else 132uy ))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126); assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); if x < 256 then log256_unique x 1 else if x < 65536 then log256_unique x 2 else if x < 16777216 then log256_unique x 3 else log256_unique x 4 let synth_der_length_payload32 (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) (y: refine_with_tag tag_of_der_length x) : GTot (refine_with_tag tag_of_der_length32 x) = let _ = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in if y >= 128 then begin Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end in U32.uint_to_t y let synth_der_length_payload32_injective (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) : Lemma (synth_injective (synth_der_length_payload32 x)) [SMTPat (synth_injective (synth_der_length_payload32 x))] = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in synth_injective_intro' (synth_der_length_payload32 x) (fun (y1 y2: refine_with_tag tag_of_der_length x) -> if y1 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y1 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y1) == 128 + log256 y1) end; if y2 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y2 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y2) == 128 + log256 y2) end ) let parse_der_length_payload32 x : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length32 x)) = parse_der_length_payload x `parse_synth` synth_der_length_payload32 x let be_int_of_bounded_integer (len: integer_size) (x: nat { x < pow2 (8 * len) } ) : GTot (bounded_integer len) = integer_size_values len; assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); U32.uint_to_t x let be_int_of_bounded_integer_injective (len: integer_size) : Lemma (synth_injective (be_int_of_bounded_integer len)) [SMTPat (synth_injective (be_int_of_bounded_integer len))] // FIXME: WHY WHY WHY does this pattern NEVER trigger? = integer_size_values len; assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296) #push-options "--max_ifuel 4 --z3rlimit 16" let parse_seq_flbytes_synth_be_int_eq (len: integer_size) (input: bytes) : Lemma ( let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse ( parse_synth #_ #(lint len) #(bounded_integer len) (parse_synth #_ #(Seq.lseq byte len) #(lint len) (parse_seq_flbytes len) (synth_be_int len) ) (be_int_of_bounded_integer len) ) input == parse (parse_bounded_integer len) input) = let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse_synth_eq (parse_seq_flbytes len `parse_synth` synth_be_int len) (be_int_of_bounded_integer len) input; parse_synth_eq (parse_seq_flbytes len) (synth_be_int len) input; parser_kind_prop_equiv (parse_bounded_integer_kind len) (parse_bounded_integer len); parse_bounded_integer_spec len input let parse_der_length_payload32_unfold x input = parse_synth_eq (parse_der_length_payload x) (synth_der_length_payload32 x) input; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 (8 * 1) == 256); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in begin match parse (parse_der_length_payload x) input with | None -> () | Some (y, _) -> if y >= 128 then begin Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end end; parse_der_length_payload_unfold x input; if U8.v x < 128 then () // tag_of_der_length (U8.v x) == x /\ y == Some (Cast.uint8_to_uint32 x, 0) else if x = 128uy || x = 255uy then () // y == None else if x = 129uy then () else begin let len : nat = U8.v x - 128 in assert (2 <= len /\ len <= 4); let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse_seq_flbytes_synth_be_int_eq len input; integer_size_values len; parse_synth_eq #_ #(lint len) #(bounded_integer len) (parse_synth #_ #(Seq.lseq byte len) #(lint len) (parse_seq_flbytes len) (synth_be_int len)) (be_int_of_bounded_integer len) input end #pop-options let log256_eq x = log256_unique x (log256' x) let synth_bounded_der_length32 (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) (x: bounded_int min max)

LowParse.Spec.DER.fst

val synth_bounded_der_length32 (min: der_length_t) (max: der_length_t{min <= max /\ max < 4294967296}) (x: bounded_int min max) : Tot (bounded_int32 min max)

LowParse.Spec.DER.synth_bounded_der_length32

min: LowParse.Spec.DER.der_length_t -> max: LowParse.Spec.DER.der_length_t{min <= max /\ max < 4294967296} -> x: LowParse.Spec.DER.bounded_int min max -> LowParse.Spec.BoundedInt.bounded_int32 min max

FStar.Pervasives.Lemma

val parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma (let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ (if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len:nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ (let res:option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ (if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None))))

let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end

val parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma (let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ (if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len:nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ (let res:option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ (if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None)))) let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma (let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ (if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len:nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ (let res:option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ (if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None)))) =

assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let x':der_length_t = U8.v x in if x' < 128 then () else if x = 128uy then () else if x = 255uy then () else if x = 129uy then (parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then log256_unique (U8.v y) 1) else let len:nat = U8.v x - 128 in synth_be_int_injective len; parse_synth_eq (((parse_seq_flbytes len) `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq ((parse_seq_flbytes len) `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res:option (lint len & consumed_length input) = parse ((parse_seq_flbytes len) `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then let y:y: lint len {y >= pow2 (8 * (len - 1))} = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None

LowParse.Spec.DER.fst

val parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma (let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ (if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len:nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ (let res:option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ (if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None))))

LowParse.Spec.DER.parse_der_length_payload_unfold

x: FStar.UInt8.t -> input: LowParse.Bytes.bytes -> FStar.Pervasives.Lemma (ensures (let y = LowParse.Spec.Base.parse (LowParse.Spec.DER.parse_der_length_payload x) input in 256 < LowParse.Spec.DER.der_length_max /\ (match FStar.UInt8.v x < 128 with | true -> LowParse.Spec.DER.tag_of_der_length (FStar.UInt8.v x) == x /\ y == FStar.Pervasives.Native.Some (FStar.UInt8.v x, 0) | _ -> (match x = 128uy || x = 255uy with | true -> y == FStar.Pervasives.Native.None | _ -> (match x = 129uy with | true -> (match LowParse.Spec.Base.parse LowParse.Spec.Int.parse_u8 input with | FStar.Pervasives.Native.None #_ -> y == FStar.Pervasives.Native.None | FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ z consumed) -> (match FStar.UInt8.v z < 128 with | true -> y == FStar.Pervasives.Native.None | _ -> LowParse.Spec.DER.tag_of_der_length (FStar.UInt8.v z) == x /\ y == FStar.Pervasives.Native.Some (FStar.UInt8.v z, consumed)) <: Prims.logical) <: Prims.logical | _ -> let len = FStar.UInt8.v x - 128 in LowParse.Spec.Combinators.synth_injective (LowParse.Spec.DER.synth_be_int len) /\ (let res = LowParse.Spec.Base.parse (LowParse.Spec.Combinators.parse_synth (LowParse.Spec.SeqBytes.Base.parse_seq_flbytes len) (LowParse.Spec.DER.synth_be_int len)) input in (match res with | FStar.Pervasives.Native.None #_ -> y == FStar.Pervasives.Native.None | FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ z consumed) -> len > 0 /\ (match z >= Prims.pow2 (8 * (len - 1)) with | true -> z <= LowParse.Spec.DER.der_length_max /\ LowParse.Spec.DER.tag_of_der_length z == x /\ y == FStar.Pervasives.Native.Some (z, consumed) | _ -> y == FStar.Pervasives.Native.None)) <: Prims.logical)) <: Prims.logical) <: Prims.logical)))

FStar.Pervasives.Lemma

val log256_eq (x: nat) : Lemma (requires (x > 0 /\ x < 4294967296)) (ensures (log256 x == log256' x))

let log256_eq x = log256_unique x (log256' x)

val log256_eq (x: nat) : Lemma (requires (x > 0 /\ x < 4294967296)) (ensures (log256 x == log256' x)) let log256_eq x =

log256_unique x (log256' x)

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y let synth_der_length_greater_inverse (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) : Lemma (synth_inverse (synth_der_length_greater x len) (synth_der_length_greater_recip x len)) = () private let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } ) = (serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () ) let tag_of_der_length_lt_128_eta (x:U8.t{U8.v x < 128}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_lt_128 y <: Lemma (U8.v x == y) let tag_of_der_length_invalid_eta (x:U8.t{U8.v x == 128 \/ U8.v x == 255}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_invalid y <: Lemma False let tag_of_der_length_eq_129_eta (x:U8.t{U8.v x == 129}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_eq_129 y <: Lemma (synth_der_length_129 x (synth_der_length_129_recip x y) == y) let serialize_der_length_payload (x: U8.t) : Tot (serializer (parse_der_length_payload x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_ret (x' <: refine_with_tag tag_of_der_length x) (tag_of_der_length_lt_128_eta x)) end else if x = 128uy || x = 255uy then fail_serializer (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) (tag_of_der_length_invalid_eta x) else if x = 129uy then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_synth (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) ) end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? serialize_weaken (parse_der_length_payload_kind x) (serialize_der_length_payload_greater x len) end let serialize_der_length_weak : serializer parse_der_length_weak = serialize_tagged_union serialize_u8 tag_of_der_length (fun x -> serialize_weaken parse_der_length_payload_kind_weak (serialize_der_length_payload x)) #push-options "--max_ifuel 6 --z3rlimit 64" let serialize_der_length_weak_unfold (y: der_length_t) : Lemma (let res = serialize serialize_der_length_weak y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = let x = tag_of_der_length y in serialize_u8_spec x; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy || x = 255uy then tag_of_der_length_invalid y else if x = 129uy then begin tag_of_der_length_eq_129 y; assert (U8.v (synth_der_length_129_recip x y) == y); let s1 = serialize ( serialize_synth #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x))) y in serialize_synth_eq' #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) y s1 () (serialize serialize_u8 (synth_der_length_129_recip x y)) () ; serialize_u8_spec (U8.uint_to_t y); () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? assert ( serialize (serialize_der_length_payload x) y == serialize (serialize_der_length_payload_greater x len) y ); serialize_synth_eq' #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () y (serialize (serialize_der_length_payload_greater x len) y) (_ by (FStar.Tactics.trefl ())) (serialize (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (synth_der_length_greater_recip x len y) ) () ; serialize_synth_eq _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () (synth_der_length_greater_recip x len y); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); () end; () #pop-options let serialize_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length_weak min max)) = serialize_synth _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () let serialize_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length min max)) = Classical.forall_intro (parse_bounded_der_length_eq min max); serialize_ext _ (serialize_bounded_der_length_weak min max) (parse_bounded_der_length min max) let serialize_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (y: bounded_int min max) : Lemma (let res = serialize (serialize_bounded_der_length min max) y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = serialize_synth_eq _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () y; serialize_der_length_weak_unfold y (* 32-bit spec *) module U32 = FStar.UInt32 let der_length_payload_size_of_tag_inv32 (x: der_length_t) : Lemma (requires (x < 4294967296)) (ensures ( tag_of_der_length x == ( if x < 128 then U8.uint_to_t x else if x < 256 then 129uy else if x < 65536 then 130uy else if x < 16777216 then 131uy else 132uy ))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126); assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); if x < 256 then log256_unique x 1 else if x < 65536 then log256_unique x 2 else if x < 16777216 then log256_unique x 3 else log256_unique x 4 let synth_der_length_payload32 (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) (y: refine_with_tag tag_of_der_length x) : GTot (refine_with_tag tag_of_der_length32 x) = let _ = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in if y >= 128 then begin Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end in U32.uint_to_t y let synth_der_length_payload32_injective (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) : Lemma (synth_injective (synth_der_length_payload32 x)) [SMTPat (synth_injective (synth_der_length_payload32 x))] = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in synth_injective_intro' (synth_der_length_payload32 x) (fun (y1 y2: refine_with_tag tag_of_der_length x) -> if y1 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y1 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y1) == 128 + log256 y1) end; if y2 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y2 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y2) == 128 + log256 y2) end ) let parse_der_length_payload32 x : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length32 x)) = parse_der_length_payload x `parse_synth` synth_der_length_payload32 x let be_int_of_bounded_integer (len: integer_size) (x: nat { x < pow2 (8 * len) } ) : GTot (bounded_integer len) = integer_size_values len; assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); U32.uint_to_t x let be_int_of_bounded_integer_injective (len: integer_size) : Lemma (synth_injective (be_int_of_bounded_integer len)) [SMTPat (synth_injective (be_int_of_bounded_integer len))] // FIXME: WHY WHY WHY does this pattern NEVER trigger? = integer_size_values len; assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296) #push-options "--max_ifuel 4 --z3rlimit 16" let parse_seq_flbytes_synth_be_int_eq (len: integer_size) (input: bytes) : Lemma ( let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse ( parse_synth #_ #(lint len) #(bounded_integer len) (parse_synth #_ #(Seq.lseq byte len) #(lint len) (parse_seq_flbytes len) (synth_be_int len) ) (be_int_of_bounded_integer len) ) input == parse (parse_bounded_integer len) input) = let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse_synth_eq (parse_seq_flbytes len `parse_synth` synth_be_int len) (be_int_of_bounded_integer len) input; parse_synth_eq (parse_seq_flbytes len) (synth_be_int len) input; parser_kind_prop_equiv (parse_bounded_integer_kind len) (parse_bounded_integer len); parse_bounded_integer_spec len input let parse_der_length_payload32_unfold x input = parse_synth_eq (parse_der_length_payload x) (synth_der_length_payload32 x) input; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 (8 * 1) == 256); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in begin match parse (parse_der_length_payload x) input with | None -> () | Some (y, _) -> if y >= 128 then begin Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end end; parse_der_length_payload_unfold x input; if U8.v x < 128 then () // tag_of_der_length (U8.v x) == x /\ y == Some (Cast.uint8_to_uint32 x, 0) else if x = 128uy || x = 255uy then () // y == None else if x = 129uy then () else begin let len : nat = U8.v x - 128 in assert (2 <= len /\ len <= 4); let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse_seq_flbytes_synth_be_int_eq len input; integer_size_values len; parse_synth_eq #_ #(lint len) #(bounded_integer len) (parse_synth #_ #(Seq.lseq byte len) #(lint len) (parse_seq_flbytes len) (synth_be_int len)) (be_int_of_bounded_integer len) input end #pop-options let log256_eq

LowParse.Spec.DER.fst

val log256_eq (x: nat) : Lemma (requires (x > 0 /\ x < 4294967296)) (ensures (log256 x == log256' x))

LowParse.Spec.DER.log256_eq

x: Prims.nat -> FStar.Pervasives.Lemma (requires x > 0 /\ x < 4294967296) (ensures LowParse.Spec.DER.log256 x == LowParse.Spec.BoundedInt.log256' x)

FStar.Pervasives.Lemma

val serialize_der_length_weak_unfold (y: der_length_t) : Lemma (let res = serialize serialize_der_length_weak y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` (Seq.create 1 (U8.uint_to_t y))) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` (E.n_to_be len y)))

let serialize_der_length_weak_unfold (y: der_length_t) : Lemma (let res = serialize serialize_der_length_weak y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = let x = tag_of_der_length y in serialize_u8_spec x; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy || x = 255uy then tag_of_der_length_invalid y else if x = 129uy then begin tag_of_der_length_eq_129 y; assert (U8.v (synth_der_length_129_recip x y) == y); let s1 = serialize ( serialize_synth #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x))) y in serialize_synth_eq' #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) y s1 () (serialize serialize_u8 (synth_der_length_129_recip x y)) () ; serialize_u8_spec (U8.uint_to_t y); () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? assert ( serialize (serialize_der_length_payload x) y == serialize (serialize_der_length_payload_greater x len) y ); serialize_synth_eq' #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () y (serialize (serialize_der_length_payload_greater x len) y) (_ by (FStar.Tactics.trefl ())) (serialize (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (synth_der_length_greater_recip x len y) ) () ; serialize_synth_eq _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () (synth_der_length_greater_recip x len y); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); () end; ()

val serialize_der_length_weak_unfold (y: der_length_t) : Lemma (let res = serialize serialize_der_length_weak y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` (Seq.create 1 (U8.uint_to_t y))) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` (E.n_to_be len y))) let serialize_der_length_weak_unfold (y: der_length_t) : Lemma (let res = serialize serialize_der_length_weak y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` (Seq.create 1 (U8.uint_to_t y))) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` (E.n_to_be len y))) =

let x = tag_of_der_length y in serialize_u8_spec x; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let x':der_length_t = U8.v x in if x' < 128 then () else if x = 128uy || x = 255uy then tag_of_der_length_invalid y else if x = 129uy then (tag_of_der_length_eq_129 y; assert (U8.v (synth_der_length_129_recip x y) == y); let s1 = serialize (serialize_synth #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x))) y in serialize_synth_eq' #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) y s1 () (serialize serialize_u8 (synth_der_length_129_recip x y)) (); serialize_u8_spec (U8.uint_to_t y); ()) else (let len:nat = U8.v x - 128 in synth_be_int_injective len; assert (serialize (serialize_der_length_payload x) y == serialize (serialize_der_length_payload_greater x len) y); serialize_synth_eq' #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) ()) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater_recip x len) () y (serialize (serialize_der_length_payload_greater x len) y) (FStar.Tactics.Effect.synth_by_tactic (fun _ -> (FStar.Tactics.trefl ()))) (serialize (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) ()) (synth_der_length_greater_recip x len y)) (); serialize_synth_eq _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () (synth_der_length_greater_recip x len y); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); ()); ()

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y let synth_der_length_greater_inverse (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) : Lemma (synth_inverse (synth_der_length_greater x len) (synth_der_length_greater_recip x len)) = () private let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } ) = (serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () ) let tag_of_der_length_lt_128_eta (x:U8.t{U8.v x < 128}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_lt_128 y <: Lemma (U8.v x == y) let tag_of_der_length_invalid_eta (x:U8.t{U8.v x == 128 \/ U8.v x == 255}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_invalid y <: Lemma False let tag_of_der_length_eq_129_eta (x:U8.t{U8.v x == 129}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_eq_129 y <: Lemma (synth_der_length_129 x (synth_der_length_129_recip x y) == y) let serialize_der_length_payload (x: U8.t) : Tot (serializer (parse_der_length_payload x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_ret (x' <: refine_with_tag tag_of_der_length x) (tag_of_der_length_lt_128_eta x)) end else if x = 128uy || x = 255uy then fail_serializer (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) (tag_of_der_length_invalid_eta x) else if x = 129uy then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_synth (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) ) end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? serialize_weaken (parse_der_length_payload_kind x) (serialize_der_length_payload_greater x len) end let serialize_der_length_weak : serializer parse_der_length_weak = serialize_tagged_union serialize_u8 tag_of_der_length (fun x -> serialize_weaken parse_der_length_payload_kind_weak (serialize_der_length_payload x)) #push-options "--max_ifuel 6 --z3rlimit 64" let serialize_der_length_weak_unfold (y: der_length_t) : Lemma (let res = serialize serialize_der_length_weak y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y)

LowParse.Spec.DER.fst

val serialize_der_length_weak_unfold (y: der_length_t) : Lemma (let res = serialize serialize_der_length_weak y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` (Seq.create 1 (U8.uint_to_t y))) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` (E.n_to_be len y)))

LowParse.Spec.DER.serialize_der_length_weak_unfold

y: LowParse.Spec.DER.der_length_t -> FStar.Pervasives.Lemma (ensures (let res = LowParse.Spec.Base.serialize LowParse.Spec.DER.serialize_der_length_weak y in let x = LowParse.Spec.DER.tag_of_der_length y in let s1 = FStar.Seq.Base.create 1 x in (match FStar.UInt8.lt x 128uy with | true -> FStar.Seq.Base.equal res s1 | _ -> (match x = 129uy with | true -> y <= 255 /\ FStar.Seq.Base.equal res (FStar.Seq.Base.append s1 (FStar.Seq.Base.create 1 (FStar.UInt8.uint_to_t y))) | _ -> let len = LowParse.Spec.DER.log256 y in FStar.Seq.Base.equal res (FStar.Seq.Base.append s1 (FStar.Endianness.n_to_be len y)) ) <: Type0) <: Type0))

FStar.Pervasives.Lemma

val parse_der_length_payload32_unfold (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload32 x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (Cast.uint8_to_uint32 x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (Cast.uint8_to_uint32 z, consumed) else let len : nat = U8.v x - 128 in 2 <= len /\ len <= 4 /\ ( let res : option (bounded_integer len & consumed_length input) = parse (parse_bounded_integer len) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if U32.v z >= pow2 (8 * (len - 1)) then U32.v z <= der_length_max /\ tag_of_der_length32 z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length32 x), consumed) else y == None ))))

let parse_der_length_payload32_unfold x input = parse_synth_eq (parse_der_length_payload x) (synth_der_length_payload32 x) input; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 (8 * 1) == 256); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in begin match parse (parse_der_length_payload x) input with | None -> () | Some (y, _) -> if y >= 128 then begin Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end end; parse_der_length_payload_unfold x input; if U8.v x < 128 then () // tag_of_der_length (U8.v x) == x /\ y == Some (Cast.uint8_to_uint32 x, 0) else if x = 128uy || x = 255uy then () // y == None else if x = 129uy then () else begin let len : nat = U8.v x - 128 in assert (2 <= len /\ len <= 4); let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse_seq_flbytes_synth_be_int_eq len input; integer_size_values len; parse_synth_eq #_ #(lint len) #(bounded_integer len) (parse_synth #_ #(Seq.lseq byte len) #(lint len) (parse_seq_flbytes len) (synth_be_int len)) (be_int_of_bounded_integer len) input end

val parse_der_length_payload32_unfold (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload32 x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (Cast.uint8_to_uint32 x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (Cast.uint8_to_uint32 z, consumed) else let len : nat = U8.v x - 128 in 2 <= len /\ len <= 4 /\ ( let res : option (bounded_integer len & consumed_length input) = parse (parse_bounded_integer len) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if U32.v z >= pow2 (8 * (len - 1)) then U32.v z <= der_length_max /\ tag_of_der_length32 z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length32 x), consumed) else y == None )))) let parse_der_length_payload32_unfold x input =

parse_synth_eq (parse_der_length_payload x) (synth_der_length_payload32 x) input; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 (8 * 1) == 256); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in (match parse (parse_der_length_payload x) input with | None -> () | Some (y, _) -> if y >= 128 then (Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y))); parse_der_length_payload_unfold x input; if U8.v x < 128 then () else if x = 128uy || x = 255uy then () else if x = 129uy then () else let len:nat = U8.v x - 128 in assert (2 <= len /\ len <= 4); let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse_seq_flbytes_synth_be_int_eq len input; integer_size_values len; parse_synth_eq #_ #(lint len) #(bounded_integer len) (parse_synth #_ #(Seq.lseq byte len) #(lint len) (parse_seq_flbytes len) (synth_be_int len)) (be_int_of_bounded_integer len) input

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y let synth_der_length_greater_inverse (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) : Lemma (synth_inverse (synth_der_length_greater x len) (synth_der_length_greater_recip x len)) = () private let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } ) = (serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () ) let tag_of_der_length_lt_128_eta (x:U8.t{U8.v x < 128}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_lt_128 y <: Lemma (U8.v x == y) let tag_of_der_length_invalid_eta (x:U8.t{U8.v x == 128 \/ U8.v x == 255}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_invalid y <: Lemma False let tag_of_der_length_eq_129_eta (x:U8.t{U8.v x == 129}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_eq_129 y <: Lemma (synth_der_length_129 x (synth_der_length_129_recip x y) == y) let serialize_der_length_payload (x: U8.t) : Tot (serializer (parse_der_length_payload x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_ret (x' <: refine_with_tag tag_of_der_length x) (tag_of_der_length_lt_128_eta x)) end else if x = 128uy || x = 255uy then fail_serializer (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) (tag_of_der_length_invalid_eta x) else if x = 129uy then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_synth (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) ) end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? serialize_weaken (parse_der_length_payload_kind x) (serialize_der_length_payload_greater x len) end let serialize_der_length_weak : serializer parse_der_length_weak = serialize_tagged_union serialize_u8 tag_of_der_length (fun x -> serialize_weaken parse_der_length_payload_kind_weak (serialize_der_length_payload x)) #push-options "--max_ifuel 6 --z3rlimit 64" let serialize_der_length_weak_unfold (y: der_length_t) : Lemma (let res = serialize serialize_der_length_weak y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = let x = tag_of_der_length y in serialize_u8_spec x; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy || x = 255uy then tag_of_der_length_invalid y else if x = 129uy then begin tag_of_der_length_eq_129 y; assert (U8.v (synth_der_length_129_recip x y) == y); let s1 = serialize ( serialize_synth #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x))) y in serialize_synth_eq' #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) y s1 () (serialize serialize_u8 (synth_der_length_129_recip x y)) () ; serialize_u8_spec (U8.uint_to_t y); () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? assert ( serialize (serialize_der_length_payload x) y == serialize (serialize_der_length_payload_greater x len) y ); serialize_synth_eq' #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () y (serialize (serialize_der_length_payload_greater x len) y) (_ by (FStar.Tactics.trefl ())) (serialize (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (synth_der_length_greater_recip x len y) ) () ; serialize_synth_eq _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () (synth_der_length_greater_recip x len y); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); () end; () #pop-options let serialize_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length_weak min max)) = serialize_synth _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () let serialize_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length min max)) = Classical.forall_intro (parse_bounded_der_length_eq min max); serialize_ext _ (serialize_bounded_der_length_weak min max) (parse_bounded_der_length min max) let serialize_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (y: bounded_int min max) : Lemma (let res = serialize (serialize_bounded_der_length min max) y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = serialize_synth_eq _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () y; serialize_der_length_weak_unfold y (* 32-bit spec *) module U32 = FStar.UInt32 let der_length_payload_size_of_tag_inv32 (x: der_length_t) : Lemma (requires (x < 4294967296)) (ensures ( tag_of_der_length x == ( if x < 128 then U8.uint_to_t x else if x < 256 then 129uy else if x < 65536 then 130uy else if x < 16777216 then 131uy else 132uy ))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126); assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); if x < 256 then log256_unique x 1 else if x < 65536 then log256_unique x 2 else if x < 16777216 then log256_unique x 3 else log256_unique x 4 let synth_der_length_payload32 (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) (y: refine_with_tag tag_of_der_length x) : GTot (refine_with_tag tag_of_der_length32 x) = let _ = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in if y >= 128 then begin Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end in U32.uint_to_t y let synth_der_length_payload32_injective (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) : Lemma (synth_injective (synth_der_length_payload32 x)) [SMTPat (synth_injective (synth_der_length_payload32 x))] = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in synth_injective_intro' (synth_der_length_payload32 x) (fun (y1 y2: refine_with_tag tag_of_der_length x) -> if y1 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y1 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y1) == 128 + log256 y1) end; if y2 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y2 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y2) == 128 + log256 y2) end ) let parse_der_length_payload32 x : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length32 x)) = parse_der_length_payload x `parse_synth` synth_der_length_payload32 x let be_int_of_bounded_integer (len: integer_size) (x: nat { x < pow2 (8 * len) } ) : GTot (bounded_integer len) = integer_size_values len; assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); U32.uint_to_t x let be_int_of_bounded_integer_injective (len: integer_size) : Lemma (synth_injective (be_int_of_bounded_integer len)) [SMTPat (synth_injective (be_int_of_bounded_integer len))] // FIXME: WHY WHY WHY does this pattern NEVER trigger? = integer_size_values len; assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296) #push-options "--max_ifuel 4 --z3rlimit 16" let parse_seq_flbytes_synth_be_int_eq (len: integer_size) (input: bytes) : Lemma ( let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse ( parse_synth #_ #(lint len) #(bounded_integer len) (parse_synth #_ #(Seq.lseq byte len) #(lint len) (parse_seq_flbytes len) (synth_be_int len) ) (be_int_of_bounded_integer len) ) input == parse (parse_bounded_integer len) input) = let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse_synth_eq (parse_seq_flbytes len `parse_synth` synth_be_int len) (be_int_of_bounded_integer len) input; parse_synth_eq (parse_seq_flbytes len) (synth_be_int len) input; parser_kind_prop_equiv (parse_bounded_integer_kind len) (parse_bounded_integer len); parse_bounded_integer_spec len input let parse_der_length_payload32_unfold x

LowParse.Spec.DER.fst

val parse_der_length_payload32_unfold (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload32 x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (Cast.uint8_to_uint32 x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (Cast.uint8_to_uint32 z, consumed) else let len : nat = U8.v x - 128 in 2 <= len /\ len <= 4 /\ ( let res : option (bounded_integer len & consumed_length input) = parse (parse_bounded_integer len) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if U32.v z >= pow2 (8 * (len - 1)) then U32.v z <= der_length_max /\ tag_of_der_length32 z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length32 x), consumed) else y == None ))))

LowParse.Spec.DER.parse_der_length_payload32_unfold

x: FStar.UInt8.t{LowParse.Spec.DER.der_length_payload_size_of_tag x <= 4} -> input: LowParse.Bytes.bytes -> FStar.Pervasives.Lemma (ensures (let y = LowParse.Spec.Base.parse (LowParse.Spec.DER.parse_der_length_payload32 x) input in 256 < LowParse.Spec.DER.der_length_max /\ (match FStar.UInt8.v x < 128 with | true -> LowParse.Spec.DER.tag_of_der_length (FStar.UInt8.v x) == x /\ y == FStar.Pervasives.Native.Some (FStar.Int.Cast.uint8_to_uint32 x, 0) | _ -> (match x = 128uy || x = 255uy with | true -> y == FStar.Pervasives.Native.None | _ -> (match x = 129uy with | true -> (match LowParse.Spec.Base.parse LowParse.Spec.Int.parse_u8 input with | FStar.Pervasives.Native.None #_ -> y == FStar.Pervasives.Native.None | FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ z consumed) -> (match FStar.UInt8.v z < 128 with | true -> y == FStar.Pervasives.Native.None | _ -> LowParse.Spec.DER.tag_of_der_length (FStar.UInt8.v z) == x /\ y == FStar.Pervasives.Native.Some (FStar.Int.Cast.uint8_to_uint32 z, consumed)) <: Prims.logical) <: Prims.logical | _ -> let len = FStar.UInt8.v x - 128 in 2 <= len /\ len <= 4 /\ (let res = LowParse.Spec.Base.parse (LowParse.Spec.BoundedInt.parse_bounded_integer len ) input in (match res with | FStar.Pervasives.Native.None #_ -> y == FStar.Pervasives.Native.None | FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ z consumed) -> len > 0 /\ (match FStar.UInt32.v z >= Prims.pow2 (8 * (len - 1)) with | true -> FStar.UInt32.v z <= LowParse.Spec.DER.der_length_max /\ LowParse.Spec.DER.tag_of_der_length32 z == x /\ y == FStar.Pervasives.Native.Some (z, consumed) | _ -> y == FStar.Pervasives.Native.None)) <: Prims.logical)) <: Prims.logical) <: Prims.logical)))

FStar.Pervasives.Lemma

val serialize_bounded_der_length_unfold (min: der_length_t) (max: der_length_t{min <= max}) (y: bounded_int min max) : Lemma (let res = serialize (serialize_bounded_der_length min max) y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` (Seq.create 1 (U8.uint_to_t y))) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` (E.n_to_be len y)))

let serialize_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (y: bounded_int min max) : Lemma (let res = serialize (serialize_bounded_der_length min max) y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = serialize_synth_eq _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () y; serialize_der_length_weak_unfold y

val serialize_bounded_der_length_unfold (min: der_length_t) (max: der_length_t{min <= max}) (y: bounded_int min max) : Lemma (let res = serialize (serialize_bounded_der_length min max) y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` (Seq.create 1 (U8.uint_to_t y))) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` (E.n_to_be len y))) let serialize_bounded_der_length_unfold (min: der_length_t) (max: der_length_t{min <= max}) (y: bounded_int min max) : Lemma (let res = serialize (serialize_bounded_der_length min max) y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` (Seq.create 1 (U8.uint_to_t y))) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` (E.n_to_be len y))) =

serialize_synth_eq _ (fun (y: der_length_t{min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max)) (fun (y: bounded_int min max) -> (y <: (y: der_length_t{min <= y && y <= max}))) () y; serialize_der_length_weak_unfold y

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y let synth_der_length_greater_inverse (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) : Lemma (synth_inverse (synth_der_length_greater x len) (synth_der_length_greater_recip x len)) = () private let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } ) = (serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () ) let tag_of_der_length_lt_128_eta (x:U8.t{U8.v x < 128}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_lt_128 y <: Lemma (U8.v x == y) let tag_of_der_length_invalid_eta (x:U8.t{U8.v x == 128 \/ U8.v x == 255}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_invalid y <: Lemma False let tag_of_der_length_eq_129_eta (x:U8.t{U8.v x == 129}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_eq_129 y <: Lemma (synth_der_length_129 x (synth_der_length_129_recip x y) == y) let serialize_der_length_payload (x: U8.t) : Tot (serializer (parse_der_length_payload x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_ret (x' <: refine_with_tag tag_of_der_length x) (tag_of_der_length_lt_128_eta x)) end else if x = 128uy || x = 255uy then fail_serializer (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) (tag_of_der_length_invalid_eta x) else if x = 129uy then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_synth (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) ) end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? serialize_weaken (parse_der_length_payload_kind x) (serialize_der_length_payload_greater x len) end let serialize_der_length_weak : serializer parse_der_length_weak = serialize_tagged_union serialize_u8 tag_of_der_length (fun x -> serialize_weaken parse_der_length_payload_kind_weak (serialize_der_length_payload x)) #push-options "--max_ifuel 6 --z3rlimit 64" let serialize_der_length_weak_unfold (y: der_length_t) : Lemma (let res = serialize serialize_der_length_weak y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = let x = tag_of_der_length y in serialize_u8_spec x; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy || x = 255uy then tag_of_der_length_invalid y else if x = 129uy then begin tag_of_der_length_eq_129 y; assert (U8.v (synth_der_length_129_recip x y) == y); let s1 = serialize ( serialize_synth #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x))) y in serialize_synth_eq' #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) y s1 () (serialize serialize_u8 (synth_der_length_129_recip x y)) () ; serialize_u8_spec (U8.uint_to_t y); () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? assert ( serialize (serialize_der_length_payload x) y == serialize (serialize_der_length_payload_greater x len) y ); serialize_synth_eq' #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () y (serialize (serialize_der_length_payload_greater x len) y) (_ by (FStar.Tactics.trefl ())) (serialize (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (synth_der_length_greater_recip x len y) ) () ; serialize_synth_eq _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () (synth_der_length_greater_recip x len y); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); () end; () #pop-options let serialize_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length_weak min max)) = serialize_synth _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () let serialize_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length min max)) = Classical.forall_intro (parse_bounded_der_length_eq min max); serialize_ext _ (serialize_bounded_der_length_weak min max) (parse_bounded_der_length min max) let serialize_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (y: bounded_int min max) : Lemma (let res = serialize (serialize_bounded_der_length min max) y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y)

LowParse.Spec.DER.fst

val serialize_bounded_der_length_unfold (min: der_length_t) (max: der_length_t{min <= max}) (y: bounded_int min max) : Lemma (let res = serialize (serialize_bounded_der_length min max) y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` (Seq.create 1 (U8.uint_to_t y))) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` (E.n_to_be len y)))

LowParse.Spec.DER.serialize_bounded_der_length_unfold

min: LowParse.Spec.DER.der_length_t -> max: LowParse.Spec.DER.der_length_t{min <= max} -> y: LowParse.Spec.DER.bounded_int min max -> FStar.Pervasives.Lemma (ensures (let res = LowParse.Spec.Base.serialize (LowParse.Spec.DER.serialize_bounded_der_length min max) y in let x = LowParse.Spec.DER.tag_of_der_length y in let s1 = FStar.Seq.Base.create 1 x in (match FStar.UInt8.lt x 128uy with | true -> FStar.Seq.Base.equal res s1 | _ -> (match x = 129uy with | true -> y <= 255 /\ FStar.Seq.Base.equal res (FStar.Seq.Base.append s1 (FStar.Seq.Base.create 1 (FStar.UInt8.uint_to_t y))) | _ -> let len = LowParse.Spec.DER.log256 y in FStar.Seq.Base.equal res (FStar.Seq.Base.append s1 (FStar.Endianness.n_to_be len y)) ) <: Type0) <: Type0))

FStar.Pervasives.Lemma

val serialize_bounded_der_length32_size (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) (y': bounded_int32 min max) : Lemma ( Seq.length (serialize (serialize_bounded_der_length32 min max) y') == ( if y' `U32.lt` 128ul then 1 else if y' `U32.lt` 256ul then 2 else if y' `U32.lt` 65536ul then 3 else if y' `U32.lt` 16777216ul then 4 else 5 ))

let serialize_bounded_der_length32_size min max y' = serialize_bounded_der_length32_unfold min max y'

val serialize_bounded_der_length32_size (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) (y': bounded_int32 min max) : Lemma ( Seq.length (serialize (serialize_bounded_der_length32 min max) y') == ( if y' `U32.lt` 128ul then 1 else if y' `U32.lt` 256ul then 2 else if y' `U32.lt` 65536ul then 3 else if y' `U32.lt` 16777216ul then 4 else 5 )) let serialize_bounded_der_length32_size min max y' =

serialize_bounded_der_length32_unfold min max y'

module LowParse.Spec.DER open LowParse.Spec.Combinators open LowParse.Spec.SeqBytes.Base // include LowParse.Spec.VLData // for in_bounds open FStar.Mul module U8 = FStar.UInt8 module UInt = FStar.UInt module Math = LowParse.Math module E = FStar.Endianness module Seq = FStar.Seq #reset-options "--z3cliopt smt.arith.nl=false --max_fuel 0 --max_ifuel 0" // let _ : unit = _ by (FStar.Tactics.(print (string_of_int der_length_max); exact (`()))) let der_length_max_eq = assert_norm (der_length_max == pow2 (8 * 126) - 1) let rec log256 (x: nat { x > 0 }) : Tot (y: nat { y > 0 /\ pow2 (8 * (y - 1)) <= x /\ x < pow2 (8 * y)}) = assert_norm (pow2 8 == 256); if x < 256 then 1 else begin let n = log256 (x / 256) in Math.pow2_plus (8 * (n - 1)) 8; Math.pow2_plus (8 * n) 8; n + 1 end let log256_unique x y = Math.pow2_lt_recip (8 * (y - 1)) (8 * log256 x); Math.pow2_lt_recip (8 * (log256 x - 1)) (8 * y) let log256_le x1 x2 = Math.pow2_lt_recip (8 * (log256 x1 - 1)) (8 * log256 x2) let der_length_payload_size_le x1 x2 = if x1 < 128 || x2 < 128 then () else let len_len2 = log256 x2 in let len_len1 = log256 x1 in log256_le x1 x2; assert_norm (pow2 7 == 128); assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len2 - 1)) (8 * 126) let synth_be_int (len: nat) (b: Seq.lseq byte len) : Tot (lint len) = E.lemma_be_to_n_is_bounded b; E.be_to_n b let synth_be_int_injective (len: nat) : Lemma (synth_injective (synth_be_int len)) [SMTPat (synth_injective (synth_be_int len))] = synth_injective_intro' (synth_be_int len) (fun (x x' : Seq.lseq byte len) -> E.be_to_n_inj x x' ) let synth_der_length_129 (x: U8.t { x == 129uy } ) (y: U8.t { U8.v y >= 128 } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); log256_unique (U8.v y) 1; U8.v y let synth_der_length_greater (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x - 128 } ) (y: lint len { y >= pow2 (8 * (len - 1)) } ) : Tot (refine_with_tag tag_of_der_length x) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len; y let parse_der_length_payload (x: U8.t) : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin weaken (parse_der_length_payload_kind x) (parse_ret (x' <: refine_with_tag tag_of_der_length x)) end else if x = 128uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // DER representation of 0 is covered by the x<128 case else if x = 255uy then fail_parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) // forbidden in BER already else if x = 129uy then weaken (parse_der_length_payload_kind x) ((parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) `parse_synth` synth_der_length_129 x) else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? weaken (parse_der_length_payload_kind x) (((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) `parse_synth` synth_der_length_greater x len) end let parse_der_length_payload_unfold (x: U8.t) (input: bytes) : Lemma ( let y = parse (parse_der_length_payload x) input in (256 < der_length_max) /\ ( if U8.v x < 128 then tag_of_der_length (U8.v x) == x /\ y == Some (U8.v x, 0) else if x = 128uy || x = 255uy then y == None else if x = 129uy then match parse parse_u8 input with | None -> y == None | Some (z, consumed) -> if U8.v z < 128 then y == None else tag_of_der_length (U8.v z) == x /\ y == Some (U8.v z, consumed) else let len : nat = U8.v x - 128 in synth_injective (synth_be_int len) /\ ( let res : option (lint len & consumed_length input) = parse (parse_synth (parse_seq_flbytes len) (synth_be_int len)) input in match res with | None -> y == None | Some (z, consumed) -> len > 0 /\ ( if z >= pow2 (8 * (len - 1)) then z <= der_length_max /\ tag_of_der_length z == x /\ y == Some ((z <: refine_with_tag tag_of_der_length x), consumed) else y == None )))) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy then () else if x = 255uy then () else if x = 129uy then begin parse_synth_eq (parse_u8 `parse_filter` (fun y -> U8.v y >= 128)) (synth_der_length_129 x) input; parse_filter_eq parse_u8 (fun y -> U8.v y >= 128) input; match parse parse_u8 input with | None -> () | Some (y, _) -> if U8.v y >= 128 then begin log256_unique (U8.v y) 1 end else () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? parse_synth_eq ((parse_seq_flbytes len `parse_synth` (synth_be_int len)) `parse_filter` (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) (synth_der_length_greater x len) input; parse_filter_eq (parse_seq_flbytes len `parse_synth` (synth_be_int len)) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) input; assert (len > 1); let res : option (lint len & consumed_length input) = parse (parse_seq_flbytes len `parse_synth` (synth_be_int len)) input in match res with | None -> () | Some (y, _) -> if y >= pow2 (8 * (len - 1)) then begin let (y: lint len { y >= pow2 (8 * (len - 1)) } ) = y in Math.pow2_le_compat (8 * 126) (8 * len); Math.pow2_le_compat (8 * (len - 1)) 7; log256_unique y len end else () end inline_for_extraction let parse_der_length_payload_kind_weak : parser_kind = strong_parser_kind 0 126 None inline_for_extraction let parse_der_length_weak_kind : parser_kind = and_then_kind parse_u8_kind parse_der_length_payload_kind_weak let parse_der_length_weak : parser parse_der_length_weak_kind der_length_t = parse_tagged_union parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) [@@(noextract_to "krml")] let parse_bounded_der_length_payload_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = [@inline_let] let _ = der_length_payload_size_le min max in strong_parser_kind (der_length_payload_size min) (der_length_payload_size max) None let bounded_int (min: der_length_t) (max: der_length_t { min <= max }) : Tot Type = (x: int { min <= x /\ x <= max }) let parse_bounded_der_length_tag_cond (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t) : Tot bool = let len = der_length_payload_size_of_tag x in der_length_payload_size min <= len && len <= der_length_payload_size max inline_for_extraction // for parser_kind let tag_of_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) (x: bounded_int min max) : Tot (y: U8.t { parse_bounded_der_length_tag_cond min max y == true } ) = [@inline_let] let _ = der_length_payload_size_le min x; der_length_payload_size_le x max in tag_of_der_length x let parse_bounded_der_length_payload (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) : Tot (parser (parse_bounded_der_length_payload_kind min max) (refine_with_tag (tag_of_bounded_der_length min max) x)) = weaken (parse_bounded_der_length_payload_kind min max) (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) `parse_synth` (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x))) [@@(noextract_to "krml")] let parse_bounded_der_length_kind (min: der_length_t) (max: der_length_t { min <= max } ) : Tot parser_kind = and_then_kind (parse_filter_kind parse_u8_kind) (parse_bounded_der_length_payload_kind min max) let parse_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_bounded_der_length_kind min max) (bounded_int min max)) = parse_tagged_union (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) (* equality *) let parse_bounded_der_length_payload_unfold (min: der_length_t) (max: der_length_t { min <= max }) (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) (input' : bytes) : Lemma (parse (parse_bounded_der_length_payload min max x) input' == ( match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_y) else None )) = parse_synth_eq (parse_der_length_payload x `parse_filter` (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max)) (fun (y: refine_with_tag tag_of_der_length x { min <= y && y <= max }) -> (y <: refine_with_tag (tag_of_bounded_der_length min max) x)) input' ; parse_filter_eq (parse_der_length_payload x) (fun (y: refine_with_tag tag_of_der_length x) -> min <= y && y <= max) input' let parse_bounded_der_length_unfold_aux (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_bounded_der_length_payload min max x) input' with | Some (y, consumed_y) -> Some (y, consumed_x + consumed_y) | None -> None else None )) = parse_tagged_union_eq (parse_u8 `parse_filter` parse_bounded_der_length_tag_cond min max) (tag_of_bounded_der_length min max) (parse_bounded_der_length_payload min max) input; parse_filter_eq parse_u8 (parse_bounded_der_length_tag_cond min max) input let parse_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length min max) input == (match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None else None )) = parse_bounded_der_length_unfold_aux min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in parse_bounded_der_length_payload_unfold min max (x <: (x: U8.t { parse_bounded_der_length_tag_cond min max x == true } ) ) input' else () let parse_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (parser (parse_filter_kind parse_der_length_weak_kind) (bounded_int min max)) = parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max) `parse_synth` (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) let parse_bounded_der_length_weak_unfold (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (parse (parse_bounded_der_length_weak min max) input == ( match parse parse_u8 input with | None -> None | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> None | Some (y, consumed_y) -> if min <= y && y <= max then Some (y, consumed_x + consumed_y) else None end )) = parse_synth_eq (parse_der_length_weak `parse_filter` (fun y -> min <= y && y <= max)) (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) input; parse_filter_eq parse_der_length_weak (fun y -> min <= y && y <= max) input; parse_tagged_union_eq parse_u8 tag_of_der_length (fun x -> weaken parse_der_length_payload_kind_weak (parse_der_length_payload x)) input let parse_bounded_der_length_eq (min: der_length_t) (max: der_length_t { min <= max }) (input: bytes) : Lemma (ensures (parse (parse_bounded_der_length min max) input == parse (parse_bounded_der_length_weak min max) input)) = parse_bounded_der_length_unfold min max input; parse_bounded_der_length_weak_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let input' = Seq.slice input consumed_x (Seq.length input) in begin match parse (parse_der_length_payload x) input' with | None -> () | Some (y, consumed_y) -> if min <= y && y <= max then (der_length_payload_size_le min y; der_length_payload_size_le y max) else () end (* serializer *) let tag_of_der_length_lt_128 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) < 128)) (ensures (x == U8.v (tag_of_der_length x))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_invalid (x: der_length_t) : Lemma (requires (let y = U8.v (tag_of_der_length x) in y == 128 \/ y == 255)) (ensures False) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let tag_of_der_length_eq_129 (x: der_length_t) : Lemma (requires (U8.v (tag_of_der_length x) == 129)) (ensures (x >= 128 /\ x < 256)) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126) let synth_der_length_129_recip (x: U8.t { x == 129uy }) (y: refine_with_tag tag_of_der_length x) : GTot (y: U8.t {U8.v y >= 128}) = tag_of_der_length_eq_129 y; U8.uint_to_t y let synth_be_int_recip (len: nat) (x: lint len) : GTot (b: Seq.lseq byte len) = E.n_to_be len x let synth_be_int_inverse (len: nat) : Lemma (synth_inverse (synth_be_int len) (synth_be_int_recip len)) = () let synth_der_length_greater_recip (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) (y: refine_with_tag tag_of_der_length x) : Tot (y: lint len { y >= pow2 (8 * (len - 1)) } ) = assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); y let synth_der_length_greater_inverse (x: U8.t { U8.v x > 129 /\ U8.v x < 255 } ) (len: nat { len == U8.v x % 128 } ) : Lemma (synth_inverse (synth_der_length_greater x len) (synth_der_length_greater_recip x len)) = () private let serialize_der_length_payload_greater (x: U8.t { not (U8.v x < 128 || x = 128uy || x = 255uy || x = 129uy) } ) (len: nat { len == U8.v x - 128 } ) = (serialize_synth #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () ) let tag_of_der_length_lt_128_eta (x:U8.t{U8.v x < 128}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_lt_128 y <: Lemma (U8.v x == y) let tag_of_der_length_invalid_eta (x:U8.t{U8.v x == 128 \/ U8.v x == 255}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_invalid y <: Lemma False let tag_of_der_length_eq_129_eta (x:U8.t{U8.v x == 129}) = fun (y: refine_with_tag tag_of_der_length x) -> tag_of_der_length_eq_129 y <: Lemma (synth_der_length_129 x (synth_der_length_129_recip x y) == y) let serialize_der_length_payload (x: U8.t) : Tot (serializer (parse_der_length_payload x)) = assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_ret (x' <: refine_with_tag tag_of_der_length x) (tag_of_der_length_lt_128_eta x)) end else if x = 128uy || x = 255uy then fail_serializer (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length x) (tag_of_der_length_invalid_eta x) else if x = 129uy then begin serialize_weaken (parse_der_length_payload_kind x) (serialize_synth (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) ) end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? serialize_weaken (parse_der_length_payload_kind x) (serialize_der_length_payload_greater x len) end let serialize_der_length_weak : serializer parse_der_length_weak = serialize_tagged_union serialize_u8 tag_of_der_length (fun x -> serialize_weaken parse_der_length_payload_kind_weak (serialize_der_length_payload x)) #push-options "--max_ifuel 6 --z3rlimit 64" let serialize_der_length_weak_unfold (y: der_length_t) : Lemma (let res = serialize serialize_der_length_weak y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = let x = tag_of_der_length y in serialize_u8_spec x; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 7 == 128); assert_norm (pow2 8 == 256); assert_norm (256 < der_length_max); assert (U8.v x <= der_length_max); let (x' : der_length_t) = U8.v x in if x' < 128 then begin () end else if x = 128uy || x = 255uy then tag_of_der_length_invalid y else if x = 129uy then begin tag_of_der_length_eq_129 y; assert (U8.v (synth_der_length_129_recip x y) == y); let s1 = serialize ( serialize_synth #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x))) y in serialize_synth_eq' #_ #(parse_filter_refine #U8.t (fun y -> U8.v y >= 128)) #(refine_with_tag tag_of_der_length x) (parse_filter parse_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129 x) (serialize_filter serialize_u8 (fun y -> U8.v y >= 128)) (synth_der_length_129_recip x) (synth_inverse_intro' (synth_der_length_129 x) (synth_der_length_129_recip x) (tag_of_der_length_eq_129_eta x)) y s1 () (serialize serialize_u8 (synth_der_length_129_recip x y)) () ; serialize_u8_spec (U8.uint_to_t y); () end else begin let len : nat = U8.v x - 128 in synth_be_int_injective len; // FIXME: WHY WHY WHY does the pattern not trigger, even with higher rlimit? assert ( serialize (serialize_der_length_payload x) y == serialize (serialize_der_length_payload_greater x len) y ); serialize_synth_eq' #_ #(parse_filter_refine #(lint len) (fun (y: lint len) -> y >= pow2 (8 * (len - 1)))) #(refine_with_tag tag_of_der_length x) _ (synth_der_length_greater x len) (serialize_filter (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (fun (y: lint len) -> y >= pow2 (8 * (len - 1))) ) (synth_der_length_greater_recip x len) () y (serialize (serialize_der_length_payload_greater x len) y) (_ by (FStar.Tactics.trefl ())) (serialize (serialize_synth #_ #(Seq.lseq byte len) #(lint len) _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () ) (synth_der_length_greater_recip x len y) ) () ; serialize_synth_eq _ (synth_be_int len) (serialize_seq_flbytes len) (synth_be_int_recip len) () (synth_der_length_greater_recip x len y); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); () end; () #pop-options let serialize_bounded_der_length_weak (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length_weak min max)) = serialize_synth _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () let serialize_bounded_der_length (min: der_length_t) (max: der_length_t { min <= max }) : Tot (serializer (parse_bounded_der_length min max)) = Classical.forall_intro (parse_bounded_der_length_eq min max); serialize_ext _ (serialize_bounded_der_length_weak min max) (parse_bounded_der_length min max) let serialize_bounded_der_length_unfold (min: der_length_t) (max: der_length_t { min <= max }) (y: bounded_int min max) : Lemma (let res = serialize (serialize_bounded_der_length min max) y in let x = tag_of_der_length y in let s1 = Seq.create 1 x in if x `U8.lt` 128uy then res `Seq.equal` s1 else if x = 129uy then y <= 255 /\ res `Seq.equal` (s1 `Seq.append` Seq.create 1 (U8.uint_to_t y)) else let len = log256 y in res `Seq.equal` (s1 `Seq.append` E.n_to_be len y) ) = serialize_synth_eq _ (fun (y: der_length_t {min <= y && y <= max}) -> (y <: bounded_int min max)) (serialize_filter serialize_der_length_weak (fun y -> min <= y && y <= max) ) (fun (y : bounded_int min max) -> (y <: (y: der_length_t {min <= y && y <= max}))) () y; serialize_der_length_weak_unfold y (* 32-bit spec *) module U32 = FStar.UInt32 let der_length_payload_size_of_tag_inv32 (x: der_length_t) : Lemma (requires (x < 4294967296)) (ensures ( tag_of_der_length x == ( if x < 128 then U8.uint_to_t x else if x < 256 then 129uy else if x < 65536 then 130uy else if x < 16777216 then 131uy else 132uy ))) = if x < 128 then () else let len_len = log256 x in assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (len_len - 1)) (8 * 126); assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); if x < 256 then log256_unique x 1 else if x < 65536 then log256_unique x 2 else if x < 16777216 then log256_unique x 3 else log256_unique x 4 let synth_der_length_payload32 (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) (y: refine_with_tag tag_of_der_length x) : GTot (refine_with_tag tag_of_der_length32 x) = let _ = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in if y >= 128 then begin Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end in U32.uint_to_t y let synth_der_length_payload32_injective (x: U8.t { der_length_payload_size_of_tag x <= 4 } ) : Lemma (synth_injective (synth_der_length_payload32 x)) [SMTPat (synth_injective (synth_der_length_payload32 x))] = assert_norm (der_length_max == pow2 (8 * 126) - 1); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in synth_injective_intro' (synth_der_length_payload32 x) (fun (y1 y2: refine_with_tag tag_of_der_length x) -> if y1 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y1 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y1) == 128 + log256 y1) end; if y2 >= 128 then begin Math.pow2_lt_recip (8 * (log256 y2 - 1)) (8 * 126); assert (U8.v (tag_of_der_length y2) == 128 + log256 y2) end ) let parse_der_length_payload32 x : Tot (parser (parse_der_length_payload_kind x) (refine_with_tag tag_of_der_length32 x)) = parse_der_length_payload x `parse_synth` synth_der_length_payload32 x let be_int_of_bounded_integer (len: integer_size) (x: nat { x < pow2 (8 * len) } ) : GTot (bounded_integer len) = integer_size_values len; assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); U32.uint_to_t x let be_int_of_bounded_integer_injective (len: integer_size) : Lemma (synth_injective (be_int_of_bounded_integer len)) [SMTPat (synth_injective (be_int_of_bounded_integer len))] // FIXME: WHY WHY WHY does this pattern NEVER trigger? = integer_size_values len; assert_norm (pow2 (8 * 1) == 256); assert_norm (pow2 (8 * 2) == 65536); assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296) #push-options "--max_ifuel 4 --z3rlimit 16" let parse_seq_flbytes_synth_be_int_eq (len: integer_size) (input: bytes) : Lemma ( let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse ( parse_synth #_ #(lint len) #(bounded_integer len) (parse_synth #_ #(Seq.lseq byte len) #(lint len) (parse_seq_flbytes len) (synth_be_int len) ) (be_int_of_bounded_integer len) ) input == parse (parse_bounded_integer len) input) = let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse_synth_eq (parse_seq_flbytes len `parse_synth` synth_be_int len) (be_int_of_bounded_integer len) input; parse_synth_eq (parse_seq_flbytes len) (synth_be_int len) input; parser_kind_prop_equiv (parse_bounded_integer_kind len) (parse_bounded_integer len); parse_bounded_integer_spec len input let parse_der_length_payload32_unfold x input = parse_synth_eq (parse_der_length_payload x) (synth_der_length_payload32 x) input; assert_norm (der_length_max == pow2 (8 * 126) - 1); assert_norm (pow2 (8 * 1) == 256); let _ = assert_norm (pow2 (8 * 2) == 65536) in let _ = assert_norm (pow2 (8 * 3) == 16777216) in let _ = assert_norm (pow2 (8 * 4) == 4294967296) in begin match parse (parse_der_length_payload x) input with | None -> () | Some (y, _) -> if y >= 128 then begin Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end end; parse_der_length_payload_unfold x input; if U8.v x < 128 then () // tag_of_der_length (U8.v x) == x /\ y == Some (Cast.uint8_to_uint32 x, 0) else if x = 128uy || x = 255uy then () // y == None else if x = 129uy then () else begin let len : nat = U8.v x - 128 in assert (2 <= len /\ len <= 4); let _ = synth_be_int_injective len in let _ = be_int_of_bounded_integer_injective len in parse_seq_flbytes_synth_be_int_eq len input; integer_size_values len; parse_synth_eq #_ #(lint len) #(bounded_integer len) (parse_synth #_ #(Seq.lseq byte len) #(lint len) (parse_seq_flbytes len) (synth_be_int len)) (be_int_of_bounded_integer len) input end #pop-options let log256_eq x = log256_unique x (log256' x) let synth_bounded_der_length32 (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) (x: bounded_int min max) : Tot (bounded_int32 min max) = U32.uint_to_t x let parse_bounded_der_length32 (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) : Tot (parser (parse_bounded_der_length32_kind min max) (bounded_int32 min max)) = parse_bounded_der_length min max `parse_synth` synth_bounded_der_length32 min max #push-options "--z3rlimit 50" let parse_bounded_der_length32_unfold min max input = parse_synth_eq (parse_bounded_der_length min max) (synth_bounded_der_length32 min max) input; parse_bounded_der_length_unfold min max input; match parse parse_u8 input with | None -> () | Some (x, consumed_x) -> let len = der_length_payload_size_of_tag x in if der_length_payload_size min <= len && len <= der_length_payload_size max then let input' = Seq.slice input consumed_x (Seq.length input) in assert_norm (4294967296 <= der_length_max); der_length_payload_size_le max 4294967295; assert_norm (pow2 (8 * 3) == 16777216); assert_norm (pow2 (8 * 4) == 4294967296); log256_unique 4294967295 4; parse_synth_eq (parse_der_length_payload x) (synth_der_length_payload32 x) input' ; match parse (parse_der_length_payload x) input' with | None -> () | Some (y, _) -> if y >= 128 then begin assert_norm (der_length_max == pow2 (8 * 126) - 1); Math.pow2_lt_recip (8 * (log256 y - 1)) (8 * 126); assert (U8.v (tag_of_der_length y) == 128 + log256 y) end else () #pop-options let synth_bounded_der_length32_recip (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) (x: bounded_int32 min max) : GTot (bounded_int min max) = U32.v x let serialize_bounded_der_length32 (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) : Tot (serializer (parse_bounded_der_length32 min max)) = serialize_synth _ (synth_bounded_der_length32 min max) (serialize_bounded_der_length min max) (synth_bounded_der_length32_recip min max) () let serialize_bounded_der_length32_unfold min max y' = serialize_synth_eq _ (synth_bounded_der_length32 min max) (serialize_bounded_der_length min max) (synth_bounded_der_length32_recip min max) () y'; serialize_bounded_der_length_unfold min max (U32.v y'); let x = tag_of_der_length32_impl y' in if x `U8.lt` 128uy then () else if x = 129uy then FStar.Math.Lemmas.small_modulo_lemma_1 (U32.v y') 256 else begin assert (x <> 128uy /\ x <> 255uy); let len = log256' (U32.v y') in log256_eq (U32.v y'); serialize_bounded_integer_spec len y' end #push-options "--z3rlimit 20" let serialize_bounded_der_length32_size

LowParse.Spec.DER.fst

val serialize_bounded_der_length32_size (min: der_length_t) (max: der_length_t { min <= max /\ max < 4294967296 }) (y': bounded_int32 min max) : Lemma ( Seq.length (serialize (serialize_bounded_der_length32 min max) y') == ( if y' `U32.lt` 128ul then 1 else if y' `U32.lt` 256ul then 2 else if y' `U32.lt` 65536ul then 3 else if y' `U32.lt` 16777216ul then 4 else 5 ))

LowParse.Spec.DER.serialize_bounded_der_length32_size

min: LowParse.Spec.DER.der_length_t -> max: LowParse.Spec.DER.der_length_t{min <= max /\ max < 4294967296} -> y': LowParse.Spec.BoundedInt.bounded_int32 min max -> FStar.Pervasives.Lemma (ensures FStar.Seq.Base.length (LowParse.Spec.Base.serialize (LowParse.Spec.DER.serialize_bounded_der_length32 min max) y') == (match FStar.UInt32.lt y' 128ul with | true -> 1 | _ -> (match FStar.UInt32.lt y' 256ul with | true -> 2 | _ -> (match FStar.UInt32.lt y' 65536ul with | true -> 3 | _ -> (match FStar.UInt32.lt y' 16777216ul with | true -> 4 | _ -> 5) <: Prims.int) <: Prims.int) <: Prims.int))

Prims.Tot

let nt (x:var) (t:term) = [ NT x t ]

let nt (x: var) (t: term) =

[NT x t]

module Pulse.Typing.Metatheory.Base open Pulse.Syntax open Pulse.Syntax.Naming open Pulse.Typing let comp_typing_u (g:env) (c:comp_st) = comp_typing g c (comp_u c) val admit_comp_typing (g:env) (c:comp_st) : comp_typing_u g c val st_typing_correctness (#g:env) (#t:st_term) (#c:comp_st) (_:st_typing g t c) : comp_typing_u g c val comp_typing_inversion (#g:env) (#c:comp_st) (ct:comp_typing_u g c) : st_comp_typing g (st_comp_of_comp c) val st_comp_typing_inversion_cofinite (#g:env) (#st:_) (ct:st_comp_typing g st) : (universe_of g st.res st.u & tot_typing g st.pre tm_vprop & (x:var{fresh_wrt x g (freevars st.post)} -> //this part is tricky, to get the quantification on x tot_typing (push_binding g x ppname_default st.res) (open_term st.post x) tm_vprop)) val st_comp_typing_inversion (#g:env) (#st:_) (ct:st_comp_typing g st) : (universe_of g st.res st.u & tot_typing g st.pre tm_vprop & x:var{fresh_wrt x g (freevars st.post)} & tot_typing (push_binding g x ppname_default st.res) (open_term st.post x) tm_vprop) val tm_exists_inversion (#g:env) (#u:universe) (#ty:term) (#p:term) (_:tot_typing g (tm_exists_sl u (as_binder ty) p) tm_vprop) (x:var { fresh_wrt x g (freevars p) } ) : universe_of g ty u & tot_typing (push_binding g x ppname_default ty) p tm_vprop val pure_typing_inversion (#g:env) (#p:term) (_:tot_typing g (tm_pure p) tm_vprop) : tot_typing g p (tm_fstar FStar.Reflection.Typing.tm_prop Range.range_0) val tot_typing_weakening (g:env) (g':env { disjoint g g' }) (t:term) (ty:typ) (_:tot_typing (push_env g g') t ty) (g1:env { pairwise_disjoint g g1 g' }) : tot_typing (push_env (push_env g g1) g') t ty val st_typing_weakening (g:env) (g':env { disjoint g g' }) (t:st_term) (c:comp) (_:st_typing (push_env g g') t c) (g1:env { pairwise_disjoint g g1 g' }) : st_typing (push_env (push_env g g1) g') t c let veq_weakening (g:env) (g':env { disjoint g g' }) (#v1 #v2:vprop) (_:vprop_equiv (push_env g g') v1 v2) (g1:env { pairwise_disjoint g g1 g' }) : vprop_equiv (push_env (push_env g g1) g') v1 v2 = magic ()

Pulse.Typing.Metatheory.Base.fsti

val nt : x: Pulse.Syntax.Base.var -> t: Pulse.Syntax.Base.term -> Prims.list Pulse.Syntax.Naming.subst_elt

Pulse.Typing.Metatheory.Base.nt

x: Pulse.Syntax.Base.var -> t: Pulse.Syntax.Base.term -> Prims.list Pulse.Syntax.Naming.subst_elt

Prims.Tot

let comp_typing_u (g:env) (c:comp_st) = comp_typing g c (comp_u c)

let comp_typing_u (g: env) (c: comp_st) =

comp_typing g c (comp_u c)

module Pulse.Typing.Metatheory.Base open Pulse.Syntax open Pulse.Syntax.Naming open Pulse.Typing

Pulse.Typing.Metatheory.Base.fsti

val comp_typing_u : g: Pulse.Typing.Env.env -> c: Pulse.Syntax.Base.comp_st -> Type0

Pulse.Typing.Metatheory.Base.comp_typing_u

g: Pulse.Typing.Env.env -> c: Pulse.Syntax.Base.comp_st -> Type0

Prims.Tot

let md5_hash_len = 16ul

let md5_hash_len =

16ul

// Separate module because -no-prefix module EverCrypt.Hash.Incremental.Macros

EverCrypt.Hash.Incremental.Macros.fst

val md5_hash_len : FStar.UInt32.t

EverCrypt.Hash.Incremental.Macros.md5_hash_len

FStar.UInt32.t

Prims.Tot

let blake2s_hash_len = 32ul

let blake2s_hash_len =

32ul

// Separate module because -no-prefix module EverCrypt.Hash.Incremental.Macros (* These definitions for the benefits of C clients. *) [@ CMacro ] let md5_hash_len = 16ul [@ CMacro ] let sha1_hash_len = 20ul [@ CMacro ] let sha2_224_hash_len = 28ul [@ CMacro ] let sha2_256_hash_len = 32ul [@ CMacro ] let sha2_384_hash_len = 48ul [@ CMacro ] let sha2_512_hash_len = 64ul [@ CMacro ] let sha3_224_hash_len = 28ul [@ CMacro ] let sha3_256_hash_len = 32ul [@ CMacro ] let sha3_384_hash_len = 48ul

EverCrypt.Hash.Incremental.Macros.fst

val blake2s_hash_len : FStar.UInt32.t

EverCrypt.Hash.Incremental.Macros.blake2s_hash_len

FStar.UInt32.t

Prims.Tot

let sha3_384_hash_len = 48ul

let sha3_384_hash_len =

48ul

// Separate module because -no-prefix module EverCrypt.Hash.Incremental.Macros (* These definitions for the benefits of C clients. *) [@ CMacro ] let md5_hash_len = 16ul [@ CMacro ] let sha1_hash_len = 20ul [@ CMacro ] let sha2_224_hash_len = 28ul [@ CMacro ] let sha2_256_hash_len = 32ul [@ CMacro ] let sha2_384_hash_len = 48ul [@ CMacro ] let sha2_512_hash_len = 64ul [@ CMacro ] let sha3_224_hash_len = 28ul

EverCrypt.Hash.Incremental.Macros.fst

val sha3_384_hash_len : FStar.UInt32.t

EverCrypt.Hash.Incremental.Macros.sha3_384_hash_len

FStar.UInt32.t

Prims.Tot

let sha1_hash_len = 20ul

let sha1_hash_len =

20ul

// Separate module because -no-prefix module EverCrypt.Hash.Incremental.Macros (* These definitions for the benefits of C clients. *)

EverCrypt.Hash.Incremental.Macros.fst

val sha1_hash_len : FStar.UInt32.t

EverCrypt.Hash.Incremental.Macros.sha1_hash_len

FStar.UInt32.t

Prims.Tot

let sha2_224_hash_len = 28ul

let sha2_224_hash_len =

28ul

// Separate module because -no-prefix module EverCrypt.Hash.Incremental.Macros (* These definitions for the benefits of C clients. *) [@ CMacro ] let md5_hash_len = 16ul

EverCrypt.Hash.Incremental.Macros.fst

val sha2_224_hash_len : FStar.UInt32.t

EverCrypt.Hash.Incremental.Macros.sha2_224_hash_len

FStar.UInt32.t

Prims.Tot

let sha2_384_hash_len = 48ul

let sha2_384_hash_len =

48ul

// Separate module because -no-prefix module EverCrypt.Hash.Incremental.Macros (* These definitions for the benefits of C clients. *) [@ CMacro ] let md5_hash_len = 16ul [@ CMacro ] let sha1_hash_len = 20ul [@ CMacro ] let sha2_224_hash_len = 28ul

EverCrypt.Hash.Incremental.Macros.fst

val sha2_384_hash_len : FStar.UInt32.t

EverCrypt.Hash.Incremental.Macros.sha2_384_hash_len

FStar.UInt32.t

Prims.Tot

let sha2_512_hash_len = 64ul

let sha2_512_hash_len =

64ul

// Separate module because -no-prefix module EverCrypt.Hash.Incremental.Macros (* These definitions for the benefits of C clients. *) [@ CMacro ] let md5_hash_len = 16ul [@ CMacro ] let sha1_hash_len = 20ul [@ CMacro ] let sha2_224_hash_len = 28ul [@ CMacro ] let sha2_256_hash_len = 32ul

EverCrypt.Hash.Incremental.Macros.fst

val sha2_512_hash_len : FStar.UInt32.t

EverCrypt.Hash.Incremental.Macros.sha2_512_hash_len

FStar.UInt32.t

Prims.Tot

let sha2_256_hash_len = 32ul

let sha2_256_hash_len =

32ul

// Separate module because -no-prefix module EverCrypt.Hash.Incremental.Macros (* These definitions for the benefits of C clients. *) [@ CMacro ] let md5_hash_len = 16ul [@ CMacro ] let sha1_hash_len = 20ul

EverCrypt.Hash.Incremental.Macros.fst

val sha2_256_hash_len : FStar.UInt32.t

EverCrypt.Hash.Incremental.Macros.sha2_256_hash_len

FStar.UInt32.t

Prims.Tot

let sha3_512_hash_len = 64ul

let sha3_512_hash_len =

64ul

// Separate module because -no-prefix module EverCrypt.Hash.Incremental.Macros (* These definitions for the benefits of C clients. *) [@ CMacro ] let md5_hash_len = 16ul [@ CMacro ] let sha1_hash_len = 20ul [@ CMacro ] let sha2_224_hash_len = 28ul [@ CMacro ] let sha2_256_hash_len = 32ul [@ CMacro ] let sha2_384_hash_len = 48ul [@ CMacro ] let sha2_512_hash_len = 64ul [@ CMacro ] let sha3_224_hash_len = 28ul [@ CMacro ] let sha3_256_hash_len = 32ul

EverCrypt.Hash.Incremental.Macros.fst

val sha3_512_hash_len : FStar.UInt32.t

EverCrypt.Hash.Incremental.Macros.sha3_512_hash_len

FStar.UInt32.t

Prims.Tot

let sha3_256_hash_len = 32ul

let sha3_256_hash_len =

32ul

// Separate module because -no-prefix module EverCrypt.Hash.Incremental.Macros (* These definitions for the benefits of C clients. *) [@ CMacro ] let md5_hash_len = 16ul [@ CMacro ] let sha1_hash_len = 20ul [@ CMacro ] let sha2_224_hash_len = 28ul [@ CMacro ] let sha2_256_hash_len = 32ul [@ CMacro ] let sha2_384_hash_len = 48ul [@ CMacro ] let sha2_512_hash_len = 64ul

EverCrypt.Hash.Incremental.Macros.fst

val sha3_256_hash_len : FStar.UInt32.t

EverCrypt.Hash.Incremental.Macros.sha3_256_hash_len

FStar.UInt32.t

Prims.Tot

let sha3_224_hash_len = 28ul

let sha3_224_hash_len =

28ul

// Separate module because -no-prefix module EverCrypt.Hash.Incremental.Macros (* These definitions for the benefits of C clients. *) [@ CMacro ] let md5_hash_len = 16ul [@ CMacro ] let sha1_hash_len = 20ul [@ CMacro ] let sha2_224_hash_len = 28ul [@ CMacro ] let sha2_256_hash_len = 32ul [@ CMacro ] let sha2_384_hash_len = 48ul

EverCrypt.Hash.Incremental.Macros.fst

val sha3_224_hash_len : FStar.UInt32.t

EverCrypt.Hash.Incremental.Macros.sha3_224_hash_len

FStar.UInt32.t

Prims.Tot

let blake2b_hash_len = 64ul

let blake2b_hash_len =

64ul

// Separate module because -no-prefix module EverCrypt.Hash.Incremental.Macros (* These definitions for the benefits of C clients. *) [@ CMacro ] let md5_hash_len = 16ul [@ CMacro ] let sha1_hash_len = 20ul [@ CMacro ] let sha2_224_hash_len = 28ul [@ CMacro ] let sha2_256_hash_len = 32ul [@ CMacro ] let sha2_384_hash_len = 48ul [@ CMacro ] let sha2_512_hash_len = 64ul [@ CMacro ] let sha3_224_hash_len = 28ul [@ CMacro ] let sha3_256_hash_len = 32ul [@ CMacro ] let sha3_384_hash_len = 48ul [@ CMacro ] let sha3_512_hash_len = 64ul

EverCrypt.Hash.Incremental.Macros.fst

val blake2b_hash_len : FStar.UInt32.t

EverCrypt.Hash.Incremental.Macros.blake2b_hash_len

FStar.UInt32.t

Prims.Tot

let n = 128

let n =

128

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.UInt128 open FStar.UInt open FStar.Mul module U32 = FStar.UInt32 module U64 = FStar.UInt64

FStar.UInt128.fsti

val n : Prims.int

FStar.UInt128.n

Prims.int

Prims.Pure

let op_Plus_Hat = add

let op_Plus_Hat =

add

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.UInt128 open FStar.UInt open FStar.Mul module U32 = FStar.UInt32 module U64 = FStar.UInt64 noextract let n = 128 val t: (x:Type0{hasEq x}) [@@ noextract_to "krml"] val v (x:t) : Tot (uint_t n) [@@ noextract_to "krml"] val uint_to_t: x:uint_t n -> Pure t (requires True) (ensures (fun y -> v y = x)) val v_inj (x1 x2: t): Lemma (requires (v x1 == v x2)) (ensures (x1 == x2)) val add: a:t -> b:t -> Pure t (requires (size (v a + v b) n)) (ensures (fun c -> v a + v b = v c)) val add_underspec: a:t -> b:t -> Pure t (requires True) (ensures (fun c -> size (v a + v b) n ==> v a + v b = v c)) val add_mod: a:t -> b:t -> Pure t (requires True) (ensures (fun c -> (v a + v b) % pow2 n = v c)) (* Subtraction primitives *) val sub: a:t -> b:t -> Pure t (requires (size (v a - v b) n)) (ensures (fun c -> v a - v b = v c)) val sub_underspec: a:t -> b:t -> Pure t (requires True) (ensures (fun c -> size (v a - v b) n ==> v a - v b = v c)) val sub_mod: a:t -> b:t -> Pure t (requires True) (ensures (fun c -> (v a - v b) % pow2 n = v c)) (* Bitwise operators *) val logand: a:t -> b:t -> Pure t (requires True) (ensures (fun r -> v r == logand (v a) (v b))) val logxor: a:t -> b:t -> Pure t (requires True) (ensures (fun r -> v r == logxor (v a) (v b))) val logor: a:t -> b:t -> Pure t (requires True) (ensures (fun r -> v r == logor (v a) (v b))) val lognot: a:t -> Pure t (requires True) (ensures (fun r -> v r == lognot (v a))) //This private primitive is used internally by the //compiler to translate bounded integer constants //with a desugaring-time check of the size of the number, //rather than an expensive verifiation check. //Since it is marked private, client programs cannot call it directly //Since it is marked unfold, it eagerly reduces, //eliminating the verification overhead of the wrapper private unfold let __uint_to_t (x:int) : Tot t = assume (fits x 128); uint_to_t x (* Shift operators *) val shift_left: a:t -> s:UInt32.t -> Pure t (requires (U32.v s < n)) (ensures (fun c -> v c = ((v a * pow2 (UInt32.v s)) % pow2 n))) val shift_right: a:t -> s:UInt32.t -> Pure t (requires (U32.v s < n)) (ensures (fun c -> v c = (v a / (pow2 (UInt32.v s))))) (* Comparison operators *) val eq (a:t) (b:t) : Pure bool (requires True) (ensures (fun r -> r == eq #n (v a) (v b))) val gt (a:t) (b:t) : Pure bool (requires True) (ensures (fun r -> r == gt #n (v a) (v b))) val lt (a:t) (b:t) : Pure bool (requires True) (ensures (fun r -> r == lt #n (v a) (v b))) val gte (a:t) (b:t) : Pure bool (requires True) (ensures (fun r -> r == gte #n (v a) (v b))) val lte (a:t) (b:t) : Pure bool (requires True) (ensures (fun r -> r == lte #n (v a) (v b))) val eq_mask: a:t -> b:t -> Tot (c:t{(v a = v b ==> v c = pow2 n - 1) /\ (v a <> v b ==> v c = 0)}) val gte_mask: a:t -> b:t -> Tot (c:t{(v a >= v b ==> v c = pow2 n - 1) /\ (v a < v b ==> v c = 0)}) (* Casts *) val uint64_to_uint128: a:U64.t -> b:t{v b == U64.v a} val uint128_to_uint64: a:t -> b:U64.t{U64.v b == v a % pow2 64} (* To input / output constants *) (* TODO: assume these without implementations *) //val to_string: t -> Tot string //val of_string: string -> Tot t

FStar.UInt128.fsti

val op_Plus_Hat : a: FStar.UInt128.t -> b: FStar.UInt128.t -> Prims.Pure FStar.UInt128.t

FStar.UInt128.op_Plus_Hat

a: FStar.UInt128.t -> b: FStar.UInt128.t -> Prims.Pure FStar.UInt128.t

Prims.Pure

let op_Plus_Percent_Hat = add_mod

let op_Plus_Percent_Hat =

add_mod

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.UInt128 open FStar.UInt open FStar.Mul module U32 = FStar.UInt32 module U64 = FStar.UInt64 noextract let n = 128 val t: (x:Type0{hasEq x}) [@@ noextract_to "krml"] val v (x:t) : Tot (uint_t n) [@@ noextract_to "krml"] val uint_to_t: x:uint_t n -> Pure t (requires True) (ensures (fun y -> v y = x)) val v_inj (x1 x2: t): Lemma (requires (v x1 == v x2)) (ensures (x1 == x2)) val add: a:t -> b:t -> Pure t (requires (size (v a + v b) n)) (ensures (fun c -> v a + v b = v c)) val add_underspec: a:t -> b:t -> Pure t (requires True) (ensures (fun c -> size (v a + v b) n ==> v a + v b = v c)) val add_mod: a:t -> b:t -> Pure t (requires True) (ensures (fun c -> (v a + v b) % pow2 n = v c)) (* Subtraction primitives *) val sub: a:t -> b:t -> Pure t (requires (size (v a - v b) n)) (ensures (fun c -> v a - v b = v c)) val sub_underspec: a:t -> b:t -> Pure t (requires True) (ensures (fun c -> size (v a - v b) n ==> v a - v b = v c)) val sub_mod: a:t -> b:t -> Pure t (requires True) (ensures (fun c -> (v a - v b) % pow2 n = v c)) (* Bitwise operators *) val logand: a:t -> b:t -> Pure t (requires True) (ensures (fun r -> v r == logand (v a) (v b))) val logxor: a:t -> b:t -> Pure t (requires True) (ensures (fun r -> v r == logxor (v a) (v b))) val logor: a:t -> b:t -> Pure t (requires True) (ensures (fun r -> v r == logor (v a) (v b))) val lognot: a:t -> Pure t (requires True) (ensures (fun r -> v r == lognot (v a))) //This private primitive is used internally by the //compiler to translate bounded integer constants //with a desugaring-time check of the size of the number, //rather than an expensive verifiation check. //Since it is marked private, client programs cannot call it directly //Since it is marked unfold, it eagerly reduces, //eliminating the verification overhead of the wrapper private unfold let __uint_to_t (x:int) : Tot t = assume (fits x 128); uint_to_t x (* Shift operators *) val shift_left: a:t -> s:UInt32.t -> Pure t (requires (U32.v s < n)) (ensures (fun c -> v c = ((v a * pow2 (UInt32.v s)) % pow2 n))) val shift_right: a:t -> s:UInt32.t -> Pure t (requires (U32.v s < n)) (ensures (fun c -> v c = (v a / (pow2 (UInt32.v s))))) (* Comparison operators *) val eq (a:t) (b:t) : Pure bool (requires True) (ensures (fun r -> r == eq #n (v a) (v b))) val gt (a:t) (b:t) : Pure bool (requires True) (ensures (fun r -> r == gt #n (v a) (v b))) val lt (a:t) (b:t) : Pure bool (requires True) (ensures (fun r -> r == lt #n (v a) (v b))) val gte (a:t) (b:t) : Pure bool (requires True) (ensures (fun r -> r == gte #n (v a) (v b))) val lte (a:t) (b:t) : Pure bool (requires True) (ensures (fun r -> r == lte #n (v a) (v b))) val eq_mask: a:t -> b:t -> Tot (c:t{(v a = v b ==> v c = pow2 n - 1) /\ (v a <> v b ==> v c = 0)}) val gte_mask: a:t -> b:t -> Tot (c:t{(v a >= v b ==> v c = pow2 n - 1) /\ (v a < v b ==> v c = 0)}) (* Casts *) val uint64_to_uint128: a:U64.t -> b:t{v b == U64.v a} val uint128_to_uint64: a:t -> b:U64.t{U64.v b == v a % pow2 64} (* To input / output constants *) (* TODO: assume these without implementations *) //val to_string: t -> Tot string //val of_string: string -> Tot t (* Infix notations *) inline_for_extraction noextract let op_Plus_Hat = add

FStar.UInt128.fsti

val op_Plus_Percent_Hat : a: FStar.UInt128.t -> b: FStar.UInt128.t -> Prims.Pure FStar.UInt128.t

FStar.UInt128.op_Plus_Percent_Hat

a: FStar.UInt128.t -> b: FStar.UInt128.t -> Prims.Pure FStar.UInt128.t

Prims.Pure