Mercurial > projects > ldc

comparison tango/tango/io/digest/Digest.d @ 132:1700239cab2e trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[svn r136] MAJOR UNSTABLE UPDATE!!! Initial commit after moving to Tango instead of Phobos. Lots of bugfixes... This build is not suitable for most things.
author lindquist
date Fri, 11 Jan 2008 17:57:40 +0100
parents
children
comparison
equal deleted inserted replaced
131:5825d48b27d1 132:1700239cab2e
1 /******************************************************************************
2
3 copyright: Copyright (c) 2006 Tango. All rights reserved
4
5 license: BSD style: see doc/license.txt for details
6
7 version: Initial release: Feb 2006
8
9 author: Regan Heath, Oskar Linde
10
11 This module defines the Digest interface.
12
13 ******************************************************************************/
14
15 module tango.io.digest.Digest;
16
17 private import tango.stdc.stdlib : alloca;
18
19 /*******************************************************************************
20
21 The DigestTransform interface defines the interface of message
22 digest algorithms, such as MD5 and SHA. Message digests are
23 secure hash functions that take a message of arbitrary length
24 and produce a fix length digest as output.
25
26 A object implementing the DigestTransform should start out initialized.
27 The data is processed though calls to the update method. Once all data
28 has been sent to the algorithm, the digest is finalized and computed
29 with the digest method.
30
31 The digest method may only be called once. After the digest
32 method has been called, the algorithm is reset to its initial
33 state.
34
35 Using the update method, data may be processed piece by piece,
36 which is useful for cases involving streams of data.
37
38 For example:
39 ---
40 // create an MD5 hash algorithm
41 Md5 hash = new Md5();
42
43 // process some data
44 hash.update("The quick brown fox");
45
46 // process some more data
47 hash.update(" jumps over the lazy dog");
48
49 // conclude algorithm and produce digest
50 ubyte[] digest = hash.binaryDigest();
51 ---
52
53 ******************************************************************************/
54
55 abstract class Digest
56 {
57 /*********************************************************************
58
59 Processes data
60
61 Remarks:
62 Updates the hash algorithm state with new data
63
64 *********************************************************************/
65
66 abstract void update(void[] data);
67
68 /********************************************************************
69
70 Computes the digest and resets the state
71
72 Params:
73 buffer = a buffer can be supplied for the digest to be
74 written to
75
76 Remarks:
77 If the buffer is not large enough to hold the
78 digest, a new buffer is allocated and returned.
79 The algorithm state is always reset after a call to
80 binaryDigest. Use the digestSize method to find out how
81 large the buffer has to be.
82
83 *********************************************************************/
84
85 abstract ubyte[] binaryDigest(ubyte[] buffer = null);
86
87 /********************************************************************
88
89 Returns the size in bytes of the digest
90
91 Returns:
92 the size of the digest in bytes
93
94 Remarks:
95 Returns the size of the digest.
96
97 *********************************************************************/
98
99 abstract uint digestSize();
100
101 /*********************************************************************
102
103 Computes the digest as a hex string and resets the state
104
105 Params:
106 buffer = a buffer can be supplied in which the digest
107 will be written. It needs to be able to hold
108 2 * digestSize chars
109
110 Remarks:
111 If the buffer is not large enough to hold the hex digest,
112 a new buffer is allocated and returned. The algorithm
113 state is always reset after a call to hexDigest.
114
115 *********************************************************************/
116
117 char[] hexDigest (char[] buffer = null)
118 {
119 uint ds = digestSize();
120
121 if (buffer.length < ds * 2)
122 buffer.length = ds * 2;
123
124 ubyte[] buf = (cast(ubyte *) alloca(ds))[0..ds];
125 ubyte[] ret = binaryDigest(buf);
126 assert(ret.ptr == buf.ptr);
127
128 static char[] hexdigits = "0123456789abcdef";
129 int i = 0;
130
131 foreach (b; buf)
132 {
133 buffer[i++] = hexdigits[b >> 4];
134 buffer[i++] = hexdigits[b & 0xf];
135 }
136
137 return buffer;
138 }
139 }
140