package docteur

You can search for identifiers within the package.

in-package search v0.2.0

package docteur

docteur.analyze
- Analyze
  - Lwt_scheduler
    
    Condition
    
    Mutex
  - SHA1
  - Scheduler
  - Verify

Legend:
Library
Module
Module type
Parameter
Class
Class type

include Carton.UID with type t = Digestif.SHA1.t

type t = Digestif.SHA1.t

type ctx

val feed : ctx -> ?off:int -> ?len:int -> Bigstringaf.t -> ctx

val compare : t -> t -> int

val length : int

val null : t

include Digestif.S with type t := t and type ctx := ctx

val digest_size : int

Size of hash results, in bytes.

val empty : ctx

An empty hash context.

val init : unit -> ctx

Create a new hash state.

val feed_bytes : ctx -> ?off:int -> ?len:int -> Stdlib.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 -> Stdlib.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 -> Stdlib.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 -> Stdlib.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 -> Stdlib.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 -> Stdlib.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 : Stdlib.Bytes.t Digestif.iter -> t

digesti_bytes iter = feedi_bytes empty iter |> get.

val digesti_string : Stdlib.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 : Stdlib.Bytes.t list -> t

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

val digestv_string : Stdlib.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 -> Stdlib.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 -> Stdlib.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 -> Stdlib.Bytes.t Digestif.iter -> t

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

val hmaci_string : key:string -> Stdlib.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 -> Stdlib.Bytes.t list -> t

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

val hmacv_string : key:string -> Stdlib.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.