Logo ROOT  
Reference Guide
TMD5.cxx
Go to the documentation of this file.
1 // @(#)root/base:$Id$
2 // Author: Fons Rademakers 29/9/2001
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2001, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 /** \class TMD5
13 \ingroup Base
14 
15 This code implements the MD5 message-digest algorithm.
16 The algorithm is due to Ron Rivest. This code was
17 written by Colin Plumb in 1993, no copyright is claimed.
18 This code is in the public domain; do with it what you wish.
19 
20 Equivalent code is available from RSA Data Security, Inc.
21 This code has been tested against that, and is equivalent,
22 except that you don't need to include two pages of legalese
23 with every copy.
24 
25 To compute the message digest of a chunk of bytes, create an
26 TMD5 object, call Update() as needed on buffers full of bytes, and
27 then call Final(), which will, optionally, fill a supplied 16-byte
28 array with the digest.
29 */
30 
31 #include "TMD5.h"
32 #include "TBuffer.h"
33 #include "TError.h"
34 #include "TSystem.h"
35 #include "Bytes.h"
36 #include <string.h>
37 #include <errno.h>
38 #ifdef R__WIN32
39 #include <io.h>
40 #endif
41 
42 ClassImp(TMD5);
43 
44 ////////////////////////////////////////////////////////////////////////////////
45 /// Create TMD5 object. Set bit count to 0 and buffer to mysterious
46 /// initialization constants.
47 
49 fBits(), fIn(), fString(), fDigest(), fFinalized(kFALSE)
50 {
51  fBuf[0] = 0x67452301;
52  fBuf[1] = 0xefcdab89;
53  fBuf[2] = 0x98badcfe;
54  fBuf[3] = 0x10325476;
55 }
56 
57 ////////////////////////////////////////////////////////////////////////////////
58 /// Create finalized TMD5 object containing passed in 16 byte digest.
59 
60 TMD5::TMD5(const UChar_t *digest):
61 fBuf(), fBits(), fIn(), fString(), fFinalized(kTRUE)
62 {
63  if (digest)
64  memcpy(fDigest, digest, 16);
65  else {
66  memset(fDigest, 0, 16);
67  Error("TMD5::TMD5", "digest is 0");
68  }
69 }
70 
71 ////////////////////////////////////////////////////////////////////////////////
72 /// MD5 copy ctor. Special copy ctor avoids copying unnecessary
73 /// temp arrays when finalized.
74 
75 TMD5::TMD5(const TMD5 &md5):
76 fString()
77 {
78  memcpy(fBuf, md5.fBuf, 4*sizeof(UInt_t));
79  memcpy(fBits, md5.fBits, 2*sizeof(UInt_t));
80  memcpy(fIn, md5.fIn, 64);
81 
82  memcpy(fDigest, md5.fDigest, 16);
83  fFinalized = md5.fFinalized;
84 }
85 
86 ////////////////////////////////////////////////////////////////////////////////
87 /// MD5 assignment operator. Special assignment operator avoids
88 /// copying unnecessary temp arrays when finalized.
89 
91 {
92  if (this != &rhs) {
93  memcpy(fBuf, rhs.fBuf, 4*sizeof(UInt_t));
94  memcpy(fBits, rhs.fBits, 2*sizeof(UInt_t));
95  memcpy(fIn, rhs.fIn, 64);
96 
97  memcpy(fDigest, rhs.fDigest, 16);
98  fFinalized = rhs.fFinalized;
99  memcpy(fString, rhs.fString, sizeof(fString));
100  }
101  return *this;
102 }
103 
104 ////////////////////////////////////////////////////////////////////////////////
105 /// Update TMD5 object to reflect the concatenation of another buffer full
106 /// of bytes.
107 
108 void TMD5::Update(const UChar_t *buf, UInt_t len)
109 {
110  if (fFinalized) {
111  Error("TMD5::Update", "Final() has already been called");
112  return;
113  }
114 
115  UInt_t t;
116 
117  // Update bitcount
118  t = fBits[0];
119  if ((fBits[0] = t + (len << 3)) < t)
120  fBits[1]++; // Carry from low to high
121  fBits[1] += len >> 29;
122 
123  t = (t >> 3) & 0x3f;
124 
125  // Handle any leading odd-sized chunks
126  if (t) {
127  UChar_t *p = (UChar_t *) fIn + t;
128 
129  t = 64 - t;
130  if (len < t) {
131  memcpy(p, buf, len);
132  return;
133  }
134  memcpy(p, buf, t);
135  Transform(fBuf, fIn);
136  buf += t;
137  len -= t;
138  }
139 
140  // Process data in 64-byte chunks
141  while (len >= 64) {
142  memcpy(fIn, buf, 64);
143  Transform(fBuf, fIn);
144  buf += 64;
145  len -= 64;
146  }
147 
148  // Handle any remaining bytes of data
149  memcpy(fIn, buf, len);
150 }
151 
152 ////////////////////////////////////////////////////////////////////////////////
153 /// MD5 finalization, ends an MD5 message-digest operation, writing the
154 /// the message digest and zeroizing the context.
155 /// Returns digest.
156 
157 void TMD5::Final(UChar_t digest[16])
158 {
159  Final();
160  memcpy(digest, fDigest, 16);
161 }
162 
163 ////////////////////////////////////////////////////////////////////////////////
164 /// MD5 finalization, ends an MD5 message-digest operation, writing the
165 /// the message digest and zeroizing the context.
166 
168 {
169  if (fFinalized)
170  return;
171 
172  UInt_t count, padLen;
173  UChar_t bits[8];
174 
175  static UChar_t padding[64] = {
176  0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
177  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
178  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
179  };
180 
181  // Save number of bits
182  Encode(bits, fBits, 8);
183 
184  // Pad out to 56 mod 64
185  count = (fBits[0] >> 3) & 0x3f;
186  padLen = (count < 56) ? (56 - count) : (120 - count);
187  Update(padding, padLen);
188 
189  // Append length (before padding)
190  Update(bits, 8);
191 
192  // Store state in digest
193  Encode(fDigest, fBuf, 16);
194 
195  // Zero out sensitive information
196  memset(fBuf, 0, 4*sizeof(UInt_t));
197  memset(fBits, 0, 2*sizeof(UInt_t));
198  memset(fIn, 0, 64);
199 
200  fFinalized = kTRUE;
201 }
202 
203 ////////////////////////////////////////////////////////////////////////////////
204 /// Print digest in ascii hex form.
205 
206 void TMD5::Print() const
207 {
208  if (!fFinalized) {
209  Error("TMD5::Print", "Final() has not yet been called");
210  return;
211  }
212 
213  printf("%s\n", AsString());
214 }
215 
216 ////////////////////////////////////////////////////////////////////////////////
217 /// Return message digest as string. Returns "" in case Final() has
218 /// not yet been called.
219 
220 const char *TMD5::AsString() const
221 {
222  if (!fFinalized) {
223  Error("TMD5::AsString", "Final() has not yet been called");
224  return "";
225  }
226 
227  if (!fString[0]) {
228  static const char hexdig[] = "0123456789abcdef";
229  for (int i = 0; i < 16; ++i) {
230  fString[i * 2] = hexdig[fDigest[i] / 16];
231  fString[i * 2 + 1] = hexdig[fDigest[i] % 16];
232  }
233  }
234  return fString;
235 }
236 
237 ////////////////////////////////////////////////////////////////////////////////
238 /// Encodes input into output. Assumes len is a multiple of 4.
239 
240 void TMD5::Encode(UChar_t *out, const UInt_t *in, UInt_t len)
241 {
242  UInt_t i, j;
243 
244  for (i = 0, j = 0; j < len; i++, j += 4) {
245  out[j] = (UChar_t)(in[i] & 0xff);
246  out[j+1] = (UChar_t)((in[i] >> 8) & 0xff);
247  out[j+2] = (UChar_t)((in[i] >> 16) & 0xff);
248  out[j+3] = (UChar_t)((in[i] >> 24) & 0xff);
249  }
250 }
251 
252 ////////////////////////////////////////////////////////////////////////////////
253 /// Decodes input into output. Assumes len is a multiple of 4.
254 
255 void TMD5::Decode(UInt_t *out, const UChar_t *in, UInt_t len)
256 {
257  UInt_t i, j;
258 
259  for (i = 0, j = 0; j < len; i++, j += 4)
260  out[i] = ((UInt_t)in[j]) | (((UInt_t)in[j+1]) << 8) |
261  (((UInt_t)in[j+2]) << 16) | (((UInt_t)in[j+3]) << 24);
262 }
263 
264 
265 // The four core functions - F1 is optimized somewhat
266 //#define F1(x, y, z) (x & y | ~x & z)
267 #define F1(x, y, z) (z ^ (x & (y ^ z)))
268 #define F2(x, y, z) F1(z, x, y)
269 #define F3(x, y, z) (x ^ y ^ z)
270 #define F4(x, y, z) (y ^ (x | ~z))
271 
272 // This is the central step in the MD5 algorithm
273 #define MD5STEP(f, w, x, y, z, data, s) \
274  ( w += f(x, y, z) + data, w = w<<s | w>>(32-s), w += x )
275 
276 ////////////////////////////////////////////////////////////////////////////////
277 /// The core of the MD5 algorithm, this alters an existing MD5 hash to
278 /// reflect the addition of 16 longwords of new data. Update() blocks
279 /// the data and converts bytes into longwords for this routine.
280 
281 void TMD5::Transform(UInt_t buf[4], const UChar_t in[64])
282 {
283  UInt_t a, b, c, d, x[16];
284 
285  a = buf[0];
286  b = buf[1];
287  c = buf[2];
288  d = buf[3];
289 
290  Decode(x, in, 64);
291 
292  MD5STEP(F1, a, b, c, d, x[0] + 0xd76aa478, 7);
293  MD5STEP(F1, d, a, b, c, x[1] + 0xe8c7b756, 12);
294  MD5STEP(F1, c, d, a, b, x[2] + 0x242070db, 17);
295  MD5STEP(F1, b, c, d, a, x[3] + 0xc1bdceee, 22);
296  MD5STEP(F1, a, b, c, d, x[4] + 0xf57c0faf, 7);
297  MD5STEP(F1, d, a, b, c, x[5] + 0x4787c62a, 12);
298  MD5STEP(F1, c, d, a, b, x[6] + 0xa8304613, 17);
299  MD5STEP(F1, b, c, d, a, x[7] + 0xfd469501, 22);
300  MD5STEP(F1, a, b, c, d, x[8] + 0x698098d8, 7);
301  MD5STEP(F1, d, a, b, c, x[9] + 0x8b44f7af, 12);
302  MD5STEP(F1, c, d, a, b, x[10] + 0xffff5bb1, 17);
303  MD5STEP(F1, b, c, d, a, x[11] + 0x895cd7be, 22);
304  MD5STEP(F1, a, b, c, d, x[12] + 0x6b901122, 7);
305  MD5STEP(F1, d, a, b, c, x[13] + 0xfd987193, 12);
306  MD5STEP(F1, c, d, a, b, x[14] + 0xa679438e, 17);
307  MD5STEP(F1, b, c, d, a, x[15] + 0x49b40821, 22);
308 
309  MD5STEP(F2, a, b, c, d, x[1] + 0xf61e2562, 5);
310  MD5STEP(F2, d, a, b, c, x[6] + 0xc040b340, 9);
311  MD5STEP(F2, c, d, a, b, x[11] + 0x265e5a51, 14);
312  MD5STEP(F2, b, c, d, a, x[0] + 0xe9b6c7aa, 20);
313  MD5STEP(F2, a, b, c, d, x[5] + 0xd62f105d, 5);
314  MD5STEP(F2, d, a, b, c, x[10] + 0x02441453, 9);
315  MD5STEP(F2, c, d, a, b, x[15] + 0xd8a1e681, 14);
316  MD5STEP(F2, b, c, d, a, x[4] + 0xe7d3fbc8, 20);
317  MD5STEP(F2, a, b, c, d, x[9] + 0x21e1cde6, 5);
318  MD5STEP(F2, d, a, b, c, x[14] + 0xc33707d6, 9);
319  MD5STEP(F2, c, d, a, b, x[3] + 0xf4d50d87, 14);
320  MD5STEP(F2, b, c, d, a, x[8] + 0x455a14ed, 20);
321  MD5STEP(F2, a, b, c, d, x[13] + 0xa9e3e905, 5);
322  MD5STEP(F2, d, a, b, c, x[2] + 0xfcefa3f8, 9);
323  MD5STEP(F2, c, d, a, b, x[7] + 0x676f02d9, 14);
324  MD5STEP(F2, b, c, d, a, x[12] + 0x8d2a4c8a, 20);
325 
326  MD5STEP(F3, a, b, c, d, x[5] + 0xfffa3942, 4);
327  MD5STEP(F3, d, a, b, c, x[8] + 0x8771f681, 11);
328  MD5STEP(F3, c, d, a, b, x[11] + 0x6d9d6122, 16);
329  MD5STEP(F3, b, c, d, a, x[14] + 0xfde5380c, 23);
330  MD5STEP(F3, a, b, c, d, x[1] + 0xa4beea44, 4);
331  MD5STEP(F3, d, a, b, c, x[4] + 0x4bdecfa9, 11);
332  MD5STEP(F3, c, d, a, b, x[7] + 0xf6bb4b60, 16);
333  MD5STEP(F3, b, c, d, a, x[10] + 0xbebfbc70, 23);
334  MD5STEP(F3, a, b, c, d, x[13] + 0x289b7ec6, 4);
335  MD5STEP(F3, d, a, b, c, x[0] + 0xeaa127fa, 11);
336  MD5STEP(F3, c, d, a, b, x[3] + 0xd4ef3085, 16);
337  MD5STEP(F3, b, c, d, a, x[6] + 0x04881d05, 23);
338  MD5STEP(F3, a, b, c, d, x[9] + 0xd9d4d039, 4);
339  MD5STEP(F3, d, a, b, c, x[12] + 0xe6db99e5, 11);
340  MD5STEP(F3, c, d, a, b, x[15] + 0x1fa27cf8, 16);
341  MD5STEP(F3, b, c, d, a, x[2] + 0xc4ac5665, 23);
342 
343  MD5STEP(F4, a, b, c, d, x[0] + 0xf4292244, 6);
344  MD5STEP(F4, d, a, b, c, x[7] + 0x432aff97, 10);
345  MD5STEP(F4, c, d, a, b, x[14] + 0xab9423a7, 15);
346  MD5STEP(F4, b, c, d, a, x[5] + 0xfc93a039, 21);
347  MD5STEP(F4, a, b, c, d, x[12] + 0x655b59c3, 6);
348  MD5STEP(F4, d, a, b, c, x[3] + 0x8f0ccc92, 10);
349  MD5STEP(F4, c, d, a, b, x[10] + 0xffeff47d, 15);
350  MD5STEP(F4, b, c, d, a, x[1] + 0x85845dd1, 21);
351  MD5STEP(F4, a, b, c, d, x[8] + 0x6fa87e4f, 6);
352  MD5STEP(F4, d, a, b, c, x[15] + 0xfe2ce6e0, 10);
353  MD5STEP(F4, c, d, a, b, x[6] + 0xa3014314, 15);
354  MD5STEP(F4, b, c, d, a, x[13] + 0x4e0811a1, 21);
355  MD5STEP(F4, a, b, c, d, x[4] + 0xf7537e82, 6);
356  MD5STEP(F4, d, a, b, c, x[11] + 0xbd3af235, 10);
357  MD5STEP(F4, c, d, a, b, x[2] + 0x2ad7d2bb, 15);
358  MD5STEP(F4, b, c, d, a, x[9] + 0xeb86d391, 21);
359 
360  buf[0] += a;
361  buf[1] += b;
362  buf[2] += c;
363  buf[3] += d;
364 
365  // Zero out sensitive information
366  memset(x, 0, sizeof(x));
367 }
368 
369 ////////////////////////////////////////////////////////////////////////////////
370 /// Compare two message digests for equality.
371 
372 Bool_t operator==(const TMD5 &m1, const TMD5 &m2)
373 {
374  // Make sure both are finalized.
375  if (!m1.fFinalized || !m2.fFinalized) {
376  if (!m1.fFinalized)
377  Error("TMD5::operator==(const TMD5&, const TMD5&)", "arg1.Final() not yet called");
378  if (!m2.fFinalized)
379  Error("TMD5::operator==(const TMD5&, const TMD5&)", "arg2.Final() not yet called");
380  return kFALSE;
381  }
382 
383  for (int i = 0; i < 16; i++)
384  if (m1.fDigest[i] != m2.fDigest[i])
385  return kFALSE;
386 
387  return kTRUE;
388 }
389 
390 ////////////////////////////////////////////////////////////////////////////////
391 /// Set the digest from the ASCII representation 'md5ascii'. The caller
392 /// is responsible to make sure that the 32 chars md5ascii are valid.
393 /// Returns -1 if md5ascii is malformed, returns 0 otherwise.
394 
395 Int_t TMD5::SetDigest(const char *md5ascii)
396 {
397  if (!md5ascii || strlen(md5ascii) < 32) {
398  // Invalid input or ASCII representation
399  return -1;
400  }
401 
402  char *buf = (char *) md5ascii;
403  for (int i = 0; i < 16; i++) {
404  UShort_t d;
405  char s = buf[2+2*i];
406  buf[2+2*i] = 0;
407  sscanf(buf+2*i, "%hx", &d);
408  buf[2+2*i] = s;
409  fDigest[i] = (UChar_t) d;
410  }
411  fFinalized = kTRUE;
412 
413  return 0;
414 }
415 
416 ////////////////////////////////////////////////////////////////////////////////
417 /// Returns checksum stored in ASCII in specified file. Use to read files
418 /// created via WriteChecksum(). The returned TMD5 object must be deleted
419 /// by the user. Returns 0 in case the file cannot be opened or in case of
420 /// error. Static utility function.
421 
423 {
424  FILE *fid = fopen(file, "r");
425  if (!fid) {
426  // file cannot be opened
427  return 0;
428  }
429 
430  char buf[33];
431 
432  if (!fgets(buf, 33, fid)) {
433  SysError("TMD5::ReadChecksum", "error reading checksum from %s", file);
434  fclose(fid);
435  return 0;
436  }
437 
438  fclose(fid);
439 
440  TMD5 *md5 = new TMD5;
441  md5->SetDigest(buf);
442 
443  return md5;
444 }
445 
446 ////////////////////////////////////////////////////////////////////////////////
447 /// Writes checksum in ASCII format to specified file. This file can
448 /// directly be read by ReadChecksum(). The md5 must have been finalized.
449 /// Returns -1 in case file cannot be opened or in case of error,
450 /// 0 otherwise. Static utility function.
451 
452 Int_t TMD5::WriteChecksum(const char *file, const TMD5 *md5)
453 {
454  FILE *fid = fopen(file, "w");
455  if (!fid) {
456  // file cannot be opened
457  return -1;
458  }
459 
460  fputs(md5->AsString(), fid);
461 
462  fclose(fid);
463 
464  return 0;
465 }
466 
467 ////////////////////////////////////////////////////////////////////////////////
468 /// Returns checksum of specified file. The returned TMD5 object must
469 /// be deleted by the user. Returns 0 in case the file does not exists
470 /// or in case of error. This function preserves the modtime of the file
471 /// so it can be safely used in conjunction with methods that keep track
472 /// of the file's modtime. Static utility function.
473 
475 {
476  Long64_t size;
477  Long_t id, flags, modtime;
478  if (gSystem->GetPathInfo(file, &id, &size, &flags, &modtime) == 0) {
479  if (flags > 1) {
480  Error("TMD5::FileChecksum", "%s not a regular file (%ld)", file, flags);
481  return 0;
482  }
483  } else {
484  // file does not exist
485  return 0;
486  }
487 
488 #ifndef WIN32
489  Int_t fd = open(file, O_RDONLY);
490 #else
491  Int_t fd = open(file, O_RDONLY | O_BINARY);
492 #endif
493  if (fd < 0) {
494  Error("TMD5::FileChecksum", "cannot open %s in read mode", file);
495  return 0;
496  }
497 
498  TMD5 *md5 = new TMD5;
499 
500  Long64_t pos = 0;
501  const Int_t bufSize = 8192;
502  UChar_t buf[bufSize];
503 
504  while (pos < size) {
505  Long64_t left = Long64_t(size - pos);
506  if (left > bufSize)
507  left = bufSize;
508  Int_t siz;
509  while ((siz = read(fd, buf, left)) < 0 && TSystem::GetErrno() == EINTR)
511  if (siz < 0 || siz != left) {
512  Error("TMD5::FileChecksum", "error reading from file %s", file);
513  close(fd);
514  delete md5;
515  return 0;
516  }
517 
518  md5->Update(buf, left);
519 
520  pos += left;
521  }
522 
523  close(fd);
524 
525  md5->Final();
526 
527  gSystem->Utime(file, modtime, modtime);
528 
529  return md5;
530 }
531 
532 ////////////////////////////////////////////////////////////////////////////////
533 /// Returns checksum of specified file in digest argument. Returns -1 in
534 /// case of error, 0 otherwise. This method preserves the modtime of the
535 /// file so it can be safely used in conjunction with methods that keep
536 /// track of the file's modtime. Static utility function.
537 
538 Int_t TMD5::FileChecksum(const char *file, UChar_t digest[16])
539 {
540  TMD5 *md5 = FileChecksum(file);
541  if (md5) {
542  memcpy(digest, md5->fDigest, 16);
543  delete md5;
544  return 0;
545  } else
546  memset(digest, 0, 16);
547 
548  return -1;
549 }
550 
551 ////////////////////////////////////////////////////////////////////////////////
552 /// Input operator. Delegate to Streamer.
553 
554 TBuffer &operator<<(TBuffer &buf, const TMD5 &uuid)
555 {
556  R__ASSERT( buf.IsWriting() );
557 
558  const_cast<TMD5&>(uuid).Streamer(buf);
559  return buf;
560 }
c
#define c(i)
Definition: RSha256.hxx:119
TSystem::GetPathInfo
int GetPathInfo(const char *path, Long_t *id, Long_t *size, Long_t *flags, Long_t *modtime)
Get info about a file: id, size, flags, modification time.
Definition: TSystem.cxx:1396
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:91
TMD5::fBits
UInt_t fBits[2]
temp buffer
Definition: TMD5.h:50
TMD5::Print
void Print() const
Print digest in ascii hex form.
Definition: TMD5.cxx:206
UShort_t
unsigned short UShort_t
Definition: RtypesCore.h:40
F2
#define F2(x, y, z)
Definition: TMD5.cxx:268
TMD5::operator=
TMD5 & operator=(const TMD5 &rhs)
MD5 assignment operator.
Definition: TMD5.cxx:90
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
TMD5::ReadChecksum
static TMD5 * ReadChecksum(const char *file)
Returns checksum stored in ASCII in specified file.
Definition: TMD5.cxx:422
Long64_t
long long Long64_t
Definition: RtypesCore.h:73
TMD5::Final
void Final()
MD5 finalization, ends an MD5 message-digest operation, writing the the message digest and zeroizing ...
Definition: TMD5.cxx:167
TMD5::FileChecksum
static TMD5 * FileChecksum(const char *file)
Returns checksum of specified file.
Definition: TMD5.cxx:474
TGeant4Unit::s
static constexpr double s
Definition: TGeant4SystemOfUnits.h:168
TMD5::TMD5
TMD5()
Create TMD5 object.
Definition: TMD5.cxx:48
MD5STEP
#define MD5STEP(f, w, x, y, z, data, s)
Definition: TMD5.cxx:273
TMD5::Transform
void Transform(UInt_t buf[4], const UChar_t in[64])
The core of the MD5 algorithm, this alters an existing MD5 hash to reflect the addition of 16 longwor...
Definition: TMD5.cxx:281
x
Double_t x[n]
Definition: legend1.C:17
TMD5::fDigest
UChar_t fDigest[16]
string representation of digest
Definition: TMD5.h:53
TMD5::Update
void Update(const UChar_t *buf, UInt_t len)
Update TMD5 object to reflect the concatenation of another buffer full of bytes.
Definition: TMD5.cxx:108
TBuffer
Definition: TBuffer.h:43
TMD5::fIn
UChar_t fIn[64]
temp buffer
Definition: TMD5.h:51
operator==
Bool_t operator==(const TMD5 &m1, const TMD5 &m2)
Compare two message digests for equality.
Definition: TMD5.cxx:372
TMD5::AsString
const char * AsString() const
Return message digest as string.
Definition: TMD5.cxx:220
TSystem::Utime
virtual int Utime(const char *file, Long_t modtime, Long_t actime)
Set the a files modification and access times.
Definition: TSystem.cxx:1523
ROOT::Math::detail::open
@ open
Definition: GenVectorIO.h:55
Bool_t
bool Bool_t
Definition: RtypesCore.h:63
b
#define b(i)
Definition: RSha256.hxx:118
O_BINARY
#define O_BINARY
Definition: civetweb.c:799
id
XFontStruct * id
Definition: TGX11.cxx:109
TSystem::ResetErrno
static void ResetErrno()
Static function resetting system error number.
Definition: TSystem.cxx:277
TMD5::WriteChecksum
static Int_t WriteChecksum(const char *file, const TMD5 *md5)
Writes checksum in ASCII format to specified file.
Definition: TMD5.cxx:452
TMD5::fString
Char_t fString[33]
temp buffer
Definition: TMD5.h:52
operator<<
TBuffer & operator<<(TBuffer &buf, const TMD5 &uuid)
Input operator. Delegate to Streamer.
Definition: TMD5.cxx:554
TGeant4Unit::m2
static constexpr double m2
Definition: TGeant4SystemOfUnits.h:129
TBuffer.h
TSystem.h
TBuffer::IsWriting
Bool_t IsWriting() const
Definition: TBuffer.h:87
a
auto * a
Definition: textangle.C:12
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:92
F4
#define F4(x, y, z)
Definition: TMD5.cxx:270
Long_t
long Long_t
Definition: RtypesCore.h:54
TMD5::Decode
void Decode(UInt_t *out, const UChar_t *in, UInt_t len)
Decodes input into output. Assumes len is a multiple of 4.
Definition: TMD5.cxx:255
UInt_t
unsigned int UInt_t
Definition: RtypesCore.h:46
TMD5
Definition: TMD5.h:44
TMD5::fBuf
UInt_t fBuf[4]
Definition: TMD5.h:49
unsigned int
F3
#define F3(x, y, z)
Definition: TMD5.cxx:269
ROOT::Math::detail::close
@ close
Definition: GenVectorIO.h:55
gSystem
R__EXTERN TSystem * gSystem
Definition: TSystem.h:559
R__ASSERT
#define R__ASSERT(e)
Definition: TError.h:122
SysError
void SysError(const char *location, const char *msgfmt,...)
file
Definition: file.py:1
TMD5::Encode
void Encode(UChar_t *out, const UInt_t *in, UInt_t len)
Encodes input into output. Assumes len is a multiple of 4.
Definition: TMD5.cxx:240
UChar_t
unsigned char UChar_t
Definition: RtypesCore.h:38
Bytes.h
TSystem::GetErrno
static Int_t GetErrno()
Static function returning system error number.
Definition: TSystem.cxx:261
d
#define d(i)
Definition: RSha256.hxx:120
TMD5.h
TMD5::SetDigest
Int_t SetDigest(const char *md5ascii)
Set the digest from the ASCII representation 'md5ascii'.
Definition: TMD5.cxx:395
F1
#define F1(x, y, z)
Definition: TMD5.cxx:267
TMD5::fFinalized
Bool_t fFinalized
Definition: TMD5.h:54
int
Error
void Error(const char *location, const char *msgfmt,...)
TError.h