Sigstore signing and verification for OCaml
sigstore: rename get_/find_ helper functions (merlint E331)
+31
-31
+31
-31
lib/sigstore.ml
+31
-31
lib/sigstore.ml
···
167
167
let json_arr items = Jsont.Array (items, none)
168
168
169
169
(** Find a member by name in a JSON object's member list. *)
170
-
let find_mem name (mems : Jsont.object') =
171
-
match Jsont.Json.find_mem name mems with
170
+
let mem name (mems : Jsont.object') =
171
+
match Jsont.Json.mem name mems with
172
172
| Some (_, v) -> Some v
173
173
| None -> None
174
174
175
175
(** Extract a string from a JSON value. *)
176
-
let get_string_v = function Jsont.String (s, _) -> Some s | _ -> None
176
+
let string_v = function Jsont.String (s, _) -> Some s | _ -> None
177
177
178
178
(** Extract a float from a JSON value. *)
179
-
let get_number_v = function Jsont.Number (n, _) -> Some n | _ -> None
179
+
let number_v = function Jsont.Number (n, _) -> Some n | _ -> None
180
180
181
181
(** Extract object members from a JSON value. *)
182
-
let get_object_v = function Jsont.Object (mems, _) -> Some mems | _ -> None
182
+
let object_v = function Jsont.Object (mems, _) -> Some mems | _ -> None
183
183
184
184
(** Extract array items from a JSON value. *)
185
-
let get_array_v = function Jsont.Array (items, _) -> Some items | _ -> None
185
+
let array_v = function Jsont.Array (items, _) -> Some items | _ -> None
186
186
187
187
(** Find a string member in an object member list. *)
188
-
let find_string name mems =
189
-
match find_mem name mems with Some v -> get_string_v v | None -> None
188
+
let string_of name mems =
189
+
match mem name mems with Some v -> string_v v | None -> None
190
190
191
191
(** Find a number member in an object member list. *)
192
-
let find_number name mems =
193
-
match find_mem name mems with Some v -> get_number_v v | None -> None
192
+
let number_of name mems =
193
+
match mem name mems with Some v -> number_v v | None -> None
194
194
195
195
(** Find an object member in an object member list. *)
196
-
let find_object name mems =
197
-
match find_mem name mems with Some v -> get_object_v v | None -> None
196
+
let object_of name mems =
197
+
match mem name mems with Some v -> object_v v | None -> None
198
198
199
199
(** Find an array member in an object member list. *)
200
-
let find_array name mems =
201
-
match find_mem name mems with Some v -> get_array_v v | None -> None
200
+
let array_of name mems =
201
+
match mem name mems with Some v -> array_v v | None -> None
202
202
203
203
(* -- Other helpers -- *)
204
204
···
256
256
| Error e -> Error (Invalid_token (Fmt.str "OIDC discovery: %s" e))
257
257
| Ok (Jsont.Object (mems, _)) ->
258
258
let get key =
259
-
match find_string key mems with
259
+
match string_of key mems with
260
260
| Some s -> Ok s
261
261
| None ->
262
262
Error
···
284
284
| Error e ->
285
285
Error (Invalid_token (Fmt.str "invalid payload JSON: %s" e))
286
286
| Ok (Jsont.Object (mems, _)) -> (
287
-
match find_string "email" mems with
287
+
match string_of "email" mems with
288
288
| Some email when email <> "" -> Ok email
289
289
| _ -> (
290
-
match find_string "sub" mems with
290
+
match string_of "sub" mems with
291
291
| Some sub -> Ok sub
292
292
| None ->
293
293
Error
···
389
389
match mems with
390
390
| [] -> Error (Rekor_error "empty response")
391
391
| ((uuid, _), entry) :: _ -> (
392
-
match get_object_v entry with
392
+
match object_v entry with
393
393
| None -> Error (Rekor_error "entry is not an object")
394
394
| Some entry_mems ->
395
395
let get_int key =
396
-
match find_number key entry_mems with
396
+
match number_of key entry_mems with
397
397
| Some n -> Ok (int_of_float n)
398
398
| None -> Error (Rekor_error (Fmt.str "missing %s" key))
399
399
in
400
400
let get_str key =
401
-
match find_string key entry_mems with
401
+
match string_of key entry_mems with
402
402
| Some s -> Ok s
403
403
| None -> Error (Rekor_error (Fmt.str "missing %s" key))
404
404
in
···
535
535
match json_to_string json with Ok s -> s | Error e -> failwith e
536
536
537
537
let req_str key mems err =
538
-
match find_string key mems with
538
+
match string_of key mems with
539
539
| Some s -> Ok s
540
540
| None -> Error (Verification_failed (Fmt.str "missing %s" err))
541
541
542
542
let req_obj key mems err =
543
-
match find_object key mems with
543
+
match object_of key mems with
544
544
| Some o -> Ok o
545
545
| None -> Error (Verification_failed (Fmt.str "missing %s" err))
546
546
547
547
let parse_certificate_chain vm =
548
-
match find_object "certificateChain" vm with
548
+
match object_of "certificateChain" vm with
549
549
| Some cc_mems -> (
550
-
match find_array "certificates" cc_mems with
550
+
match array_of "certificates" cc_mems with
551
551
| Some certs ->
552
552
List.filter_map
553
553
(fun c ->
554
-
match get_string_v c with
554
+
match string_v c with
555
555
| Some s -> (
556
556
match b64_decode s with Ok d -> Some d | Error _ -> None)
557
557
| None -> None)
···
560
560
| None -> []
561
561
562
562
let parse_tlog_entry vm =
563
-
match find_array "tlogEntries" vm with
563
+
match array_of "tlogEntries" vm with
564
564
| Some (entry :: _) -> (
565
-
match get_object_v entry with
565
+
match object_v entry with
566
566
| Some e_mems -> (
567
567
match
568
-
( find_number "logIndex" e_mems,
569
-
find_string "logId" e_mems,
570
-
find_number "integratedTime" e_mems,
571
-
find_string "body" e_mems )
568
+
( number_of "logIndex" e_mems,
569
+
string_of "logId" e_mems,
570
+
number_of "integratedTime" e_mems,
571
+
string_of "body" e_mems )
572
572
with
573
573
| Some log_index, Some uuid, Some integrated_time, Some body_b64 -> (
574
574
match b64_decode body_b64 with