blob: 4d31dae346d8e21a174d48e96ed1459c7c518c90 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
(**************************************************************************)
(* *)
(* OCaml *)
(* *)
(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)
(* *)
(* Copyright 1996 Institut National de Recherche en Informatique et *)
(* en Automatique. *)
(* *)
(* All rights reserved. This file is distributed under the terms of *)
(* the GNU Lesser General Public License version 2.1, with the *)
(* special exception on linking described in the file LICENSE. *)
(* *)
(**************************************************************************)
(** MD5 message digest.
This module provides functions to compute 128-bit 'digests' of
arbitrary-length strings or files. The algorithm used is MD5.
The MD5 hash function is not cryptographically secure.
Hence, this module should not be used for security-sensitive
applications. More recent, stronger cryptographic primitives
should be used instead.
*)
type t = string
(** The type of digests: 16-character strings. *)
val compare : t -> t -> int
(** The comparison function for 16-character digest, with the same
specification as {!Stdlib.compare} and the implementation
shared with {!String.compare}. Along with the type [t], this
function [compare] allows the module [Digest] to be passed as
argument to the functors {!Set.Make} and {!Map.Make}.
@since 4.00 *)
val equal : t -> t -> bool
(** The equal function for 16-character digest.
@since 4.03 *)
val string : string -> t
(** Return the digest of the given string. *)
val bytes : bytes -> t
(** Return the digest of the given byte sequence.
@since 4.02 *)
val substring : string -> int -> int -> t
(** [Digest.substring s ofs len] returns the digest of the substring
of [s] starting at index [ofs] and containing [len] characters. *)
val subbytes : bytes -> int -> int -> t
(** [Digest.subbytes s ofs len] returns the digest of the subsequence
of [s] starting at index [ofs] and containing [len] bytes.
@since 4.02 *)
external channel : in_channel -> int -> t = "caml_md5_chan"
(** If [len] is nonnegative, [Digest.channel ic len] reads [len]
characters from channel [ic] and returns their digest, or raises
[End_of_file] if end-of-file is reached before [len] characters
are read. If [len] is negative, [Digest.channel ic len] reads
all characters from [ic] until end-of-file is reached and return
their digest. *)
val file : string -> t
(** Return the digest of the file whose name is given. *)
val output : out_channel -> t -> unit
(** Write a digest on the given output channel. *)
val input : in_channel -> t
(** Read a digest from the given input channel. *)
val to_hex : t -> string
(** Return the printable hexadecimal representation of the given digest.
@raise Invalid_argument if the argument is not exactly 16 bytes.
*)
val from_hex : string -> t
(** Convert a hexadecimal representation back into the corresponding digest.
@raise Invalid_argument if the argument is not exactly 32 hexadecimal
characters.
@since 4.00 *)
|
