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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
|
//
// DigestEngine.h
//
// Library: Foundation
// Package: Crypt
// Module: DigestEngine
//
// Definition of class DigestEngine.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_DigestEngine_INCLUDED
#define Foundation_DigestEngine_INCLUDED
#include "Poco/Foundation.h"
#include <vector>
namespace Poco {
class Foundation_API DigestEngine
/// This class is an abstract base class
/// for all classes implementing a message
/// digest algorithm, like MD5Engine
/// and SHA1Engine.
/// Call update() repeatedly with data to
/// compute the digest from. When done,
/// call digest() to obtain the message
/// digest.
{
public:
using Digest = std::vector<unsigned char>;
DigestEngine();
virtual ~DigestEngine();
void update(const void* data, std::size_t length);
void update(char data);
void update(const std::string& data);
/// Updates the digest with the given data.
virtual std::size_t digestLength() const = 0;
/// Returns the length of the digest in bytes.
virtual void reset() = 0;
/// Resets the engine so that a new
/// digest can be computed.
virtual const Digest& digest() = 0;
/// Finishes the computation of the digest and
/// returns the message digest. Resets the engine
/// and can thus only be called once for every digest.
/// The returned reference is valid until the next
/// time digest() is called, or the engine object is destroyed.
static std::string digestToHex(const Digest& bytes, std::size_t length = 0);
/// Converts a message digest into a string of hexadecimal numbers.
/// If length is greater than zero, the output is truncated to length
/// bytes. If size is greater than the length of untruncated output,
/// InvalidArgumentException is thrown.
static Digest digestFromHex(const std::string& digest);
/// Converts a string created by digestToHex back to its Digest presentation
static bool constantTimeEquals(const Digest& d1, const Digest& d2);
/// Compares two Digest values using a constant-time comparison
/// algorithm. This can be used to prevent timing attacks
/// (as discussed in <https://codahale.com/a-lesson-in-timing-attacks/>).
protected:
virtual void updateImpl(const void* data, std::size_t length) = 0;
/// Updates the digest with the given data. Must be implemented
/// by subclasses.
private:
DigestEngine(const DigestEngine&);
DigestEngine& operator = (const DigestEngine&);
};
//
// inlines
//
inline void DigestEngine::update(const void* data, std::size_t length)
{
updateImpl(data, length);
}
inline void DigestEngine::update(char data)
{
updateImpl(&data, 1);
}
inline void DigestEngine::update(const std::string& data)
{
updateImpl(data.data(), data.size());
}
} // namespace Poco
#endif // Foundation_DigestEngine_INCLUDED
|
