package octez-internal-libs

  1. Overview
  2. Docs
package octez-internal-libs
Legend:
Library
Module
Module type
Parameter
Class
Class type
val digest_size : int

Size of hash results, in bytes.

type ctx
type t
val empty : ctx

An empty hash context.

val init : unit -> ctx

Create a new hash state.

val feed_bytes : ctx -> ?off:int -> ?len:int -> Bytes.t -> ctx

feed_bytes msg t adds informations in msg to t. feed is analogous to appending: feed (feed t msg1) msg2 = feed t (append msg1 msg2)

val feed_string : ctx -> ?off:int -> ?len:int -> String.t -> ctx

Same as feed_bytes but for String.t.

val feed_bigstring : ctx -> ?off:int -> ?len:int -> Digestif.bigstring -> ctx

Same as feed_bytes but for bigstring.

val feedi_bytes : ctx -> Bytes.t Digestif.iter -> ctx

feedi_bytes t iter = let r = ref t in iter (fun msg -> r := feed !r msg); !r

val feedi_string : ctx -> String.t Digestif.iter -> ctx

Same as feed_bytes but for String.t.

val feedi_bigstring : ctx -> Digestif.bigstring Digestif.iter -> ctx

Same as feed_bytes but for bigstring.

val get : ctx -> t

get t is the digest corresponding to t.

val digest_bytes : ?off:int -> ?len:int -> Bytes.t -> t

digest_bytes msg is the digest of msg.

digest_bytes msg = get (feed_bytes empty msg).

val digest_string : ?off:int -> ?len:int -> String.t -> t

Same as digest_bytes but for a String.t.

val digest_bigstring : ?off:int -> ?len:int -> Digestif.bigstring -> t

Same as digest_bytes but for a bigstring.

val digesti_bytes : Bytes.t Digestif.iter -> t

digesti_bytes iter = feedi_bytes empty iter |> get.

val digesti_string : String.t Digestif.iter -> t

Same as digesti_bytes but for String.t.

val digesti_bigstring : Digestif.bigstring Digestif.iter -> t

Same as digesti_bigstring but for bigstring.

val digestv_bytes : Bytes.t list -> t

Specialization of digesti_bytes with a list of Bytes.t (see iter).

val digestv_string : String.t list -> t

Same as digestv_bytes but for String.t.

val digestv_bigstring : Digestif.bigstring list -> t

Same as digestv_bytes but for bigstring.

val hmac_bytes : key:string -> ?off:int -> ?len:int -> Bytes.t -> t

hmac_bytes ~key bytes is the authentication code for Bytes.t under the secret key, generated using the standard HMAC construction over this hash algorithm.

val hmac_string : key:string -> ?off:int -> ?len:int -> String.t -> t

Same as hmac_bytes but for String.t.

val hmac_bigstring : key:string -> ?off:int -> ?len:int -> Digestif.bigstring -> t

Same as hmac_bytes but for bigstring.

val hmaci_bytes : key:string -> Bytes.t Digestif.iter -> t

Authentication code under the secret key over a collection of Bytes.t.

val hmaci_string : key:string -> String.t Digestif.iter -> t

Same as hmaci_bytes but for String.t.

val hmaci_bigstring : key:string -> Digestif.bigstring Digestif.iter -> t

Same as hmaci_bytes but for bigstring.

val hmacv_bytes : key:string -> Bytes.t list -> t

Specialization of hmaci_bytes with a list of Bytes.t (see iter).

val hmacv_string : key:string -> String.t list -> t

Same as hmacv_bytes but for String.t.

val hmacv_bigstring : key:string -> Digestif.bigstring list -> t

Same as hmacv_bigstring but for bigstring.

val unsafe_compare : t Digestif.compare

unsafe_compare function returns 0 on equality and a negative/positive int depending on the difference (like String.compare). This is usually OK, but this is not constant time, so in some cases it could leak some information.

val equal : t Digestif.equal

The equal (constant-time) function for t.

val pp : t Digestif.pp

Pretty-printer of t.

val of_hex : string -> t

of_hex tries to parse an hexadecimal representation of t. of_hex raises an invalid_argument when input is malformed. We take only firsts digest_size hexadecimal values and ignore rest of input. If it has not enough hexadecimal values, trailing values of the output hash are zero (\x00),

val of_hex_opt : string -> t option

of_hex tries to parse an hexadecimal representation of t. of_hex returns None when input is malformed. We take only first digest_size hexadecimal values and ignore rest of input. If it has not enough hexadecimal values, trailing values of the output hash are zero (\x00).

val consistent_of_hex : string -> t

consistent_of_hex tries to parse an hexadecimal representation of t. consistent_of_hex raises an invalid_argument when input is malformed. However, instead of_hex, consistent_of_hex expects exactly {!digest_size} * 2 hexadecimal values (but continues to ignore whitespaces).

val consistent_of_hex_opt : string -> t option

consistent_of_hex_opt tries to parse an hexadecimal representation of t. consistent_of_hex returns None when input is malformed. However, instead of_hex, consistent_of_hex expects exactly {!digest_size} * 2 hexadecimal values (but continues to ignore whitespaces).

val to_hex : t -> string

to_hex makes a hex-decimal representation of t.

val of_raw_string : string -> t

of_raw_string s see s as a hash. Useful when reading serialized hashes.

val of_raw_string_opt : string -> t option

of_raw_string_opt s see s as a hash. Useful when reading serialized hashes. Returns None if s is not the digest_size bytes long.

val to_raw_string : t -> string

to_raw_string s is (s :> string).

val get_into_bytes : ctx -> ?off:int -> bytes -> unit

get_into_bytes ctx ?off buf writes the result into the given buf at off (defaults to 0).

It's equivalent to:

let get_into_bytes ctx ?(off = 0) buf =
  let t = get ctx in
  let str = to_raw_string t in
  Bytes.blit_string str 0 buf off digest_size

except get_into_bytes does not allocate an intermediate string.

OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct