blob: a913eed54115dcd207dc3d09a3adfcf1111af236 (
plain) (
blame)
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
|
#pragma once
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif
//====- SHA256.cpp - SHA256 implementation ---*- C++ -* ======//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
/*
* The SHA-256 Secure Hash Standard was published by NIST in 2002.
*
* http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf
*
* The implementation is based on nacl's sha256 implementation [0] and LLVM's
* pre-exsiting SHA1 code [1].
*
* [0] https://hyperelliptic.org/nacl/nacl-20110221.tar.bz2 (public domain
* code)
* [1] llvm/lib/Support/SHA1.{h,cpp}
*/
//===----------------------------------------------------------------------===//
#ifndef LLVM_SUPPORT_SHA256_H
#define LLVM_SUPPORT_SHA256_H
#include <array>
#include <cstdint>
namespace llvm {
template <typename T> class ArrayRef;
class StringRef;
class SHA256 {
public:
explicit SHA256() { init(); }
/// Reinitialize the internal state
void init();
/// Digest more data.
void update(ArrayRef<uint8_t> Data);
/// Digest more data.
void update(StringRef Str);
/// Return a reference to the current raw 256-bits SHA256 for the digested
/// data since the last call to init(). This call will add data to the
/// internal state and as such is not suited for getting an intermediate
/// result (see result()).
StringRef final();
/// Return a reference to the current raw 256-bits SHA256 for the digested
/// data since the last call to init(). This is suitable for getting the
/// SHA256 at any time without invalidating the internal state so that more
/// calls can be made into update.
StringRef result();
/// Returns a raw 256-bit SHA256 hash for the given data.
static std::array<uint8_t, 32> hash(ArrayRef<uint8_t> Data);
private:
/// Define some constants.
/// "static constexpr" would be cleaner but MSVC does not support it yet.
enum { BLOCK_LENGTH = 64 };
enum { HASH_LENGTH = 32 };
// Internal State
struct {
union {
uint8_t C[BLOCK_LENGTH];
uint32_t L[BLOCK_LENGTH / 4];
} Buffer;
uint32_t State[HASH_LENGTH / 4];
uint32_t ByteCount;
uint8_t BufferOffset;
} InternalState;
// Internal copy of the hash, populated and accessed on calls to result()
uint32_t HashResult[HASH_LENGTH / 4];
// Helper
void writebyte(uint8_t data);
void hashBlock();
void addUncounted(uint8_t data);
void pad();
};
} // namespace llvm
#endif // LLVM_SUPPORT_SHA256_H
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
|
