Coverage Report

Created: 2025-04-11 06:34

/src/botan/build/include/internal/botan/internal/sha2_64.h
Line
Count
Source (jump to first uncovered line)
1
/*
2
* SHA-{384,512}
3
* (C) 1999-2010,2015 Jack Lloyd
4
*
5
* Botan is released under the Simplified BSD License (see license.txt)
6
*/
7
8
#ifndef BOTAN_SHA_64BIT_H_
9
#define BOTAN_SHA_64BIT_H_
10
11
#include <botan/internal/mdx_hash.h>
12
13
namespace Botan {
14
15
/**
16
* SHA-384
17
*/
18
class SHA_384 final : public HashFunction {
19
   public:
20
      using digest_type = secure_vector<uint64_t>;
21
22
      static constexpr MD_Endian byte_endianness = MD_Endian::Big;
23
      static constexpr MD_Endian bit_endianness = MD_Endian::Big;
24
      static constexpr size_t block_bytes = 128;
25
      static constexpr size_t output_bytes = 48;
26
      static constexpr size_t ctr_bytes = 16;
27
28
      static void compress_n(digest_type& digest, std::span<const uint8_t> input, size_t blocks);
29
      static void init(digest_type& digest);
30
31
   public:
32
295
      std::string name() const override { return "SHA-384"; }
33
34
35.4k
      size_t output_length() const override { return output_bytes; }
35
36
2.68k
      size_t hash_block_size() const override { return block_bytes; }
37
38
      std::unique_ptr<HashFunction> new_object() const override;
39
40
      std::unique_ptr<HashFunction> copy_state() const override;
41
42
      std::string provider() const override;
43
44
5.12k
      void clear() override { m_md.clear(); }
45
46
   private:
47
      void add_data(std::span<const uint8_t> input) override;
48
49
      void final_result(std::span<uint8_t> output) override;
50
51
   private:
52
      MerkleDamgard_Hash<SHA_384> m_md;
53
};
54
55
/**
56
* SHA-512
57
*/
58
class SHA_512 final : public HashFunction {
59
   public:
60
      using digest_type = secure_vector<uint64_t>;
61
62
      static constexpr MD_Endian byte_endianness = MD_Endian::Big;
63
      static constexpr MD_Endian bit_endianness = MD_Endian::Big;
64
      static constexpr size_t block_bytes = 128;
65
      static constexpr size_t output_bytes = 64;
66
      static constexpr size_t ctr_bytes = 16;
67
68
      static void compress_n(digest_type& digest, std::span<const uint8_t> input, size_t blocks);
69
      static void init(digest_type& digest);
70
71
   public:
72
56
      std::string name() const override { return "SHA-512"; }
73
74
113
      size_t output_length() const override { return output_bytes; }
75
76
0
      size_t hash_block_size() const override { return block_bytes; }
77
78
      std::unique_ptr<HashFunction> new_object() const override;
79
80
      std::unique_ptr<HashFunction> copy_state() const override;
81
82
      std::string provider() const override;
83
84
0
      void clear() override { m_md.clear(); }
85
86
   public:
87
      static void compress_digest(digest_type& digest, std::span<const uint8_t> input, size_t blocks);
88
89
#if defined(BOTAN_HAS_SHA2_64_X86_AVX2)
90
      static void compress_digest_x86_avx2(digest_type& digest, std::span<const uint8_t> input, size_t blocks);
91
#endif
92
93
#if defined(BOTAN_HAS_SHA2_64_X86)
94
      static void compress_digest_x86(digest_type& digest, std::span<const uint8_t> input, size_t blocks);
95
#endif
96
97
#if defined(BOTAN_HAS_SHA2_64_ARMV8)
98
      static void compress_digest_armv8(digest_type& digest, std::span<const uint8_t> input, size_t blocks);
99
#endif
100
101
   private:
102
      void add_data(std::span<const uint8_t> input) override;
103
104
      void final_result(std::span<uint8_t> output) override;
105
106
   private:
107
      MerkleDamgard_Hash<SHA_512> m_md;
108
};
109
110
/**
111
* SHA-512/256
112
*/
113
class SHA_512_256 final : public HashFunction {
114
   public:
115
      using digest_type = secure_vector<uint64_t>;
116
117
      static constexpr MD_Endian byte_endianness = MD_Endian::Big;
118
      static constexpr MD_Endian bit_endianness = MD_Endian::Big;
119
      static constexpr size_t block_bytes = 128;
120
      static constexpr size_t output_bytes = 32;
121
      static constexpr size_t ctr_bytes = 16;
122
123
      static void compress_n(digest_type& digest, std::span<const uint8_t> input, size_t blocks);
124
      static void init(digest_type& digest);
125
126
   public:
127
453
      std::string name() const override { return "SHA-512-256"; }
128
129
898
      size_t output_length() const override { return output_bytes; }
130
131
0
      size_t hash_block_size() const override { return block_bytes; }
132
133
      std::unique_ptr<HashFunction> new_object() const override;
134
135
      std::unique_ptr<HashFunction> copy_state() const override;
136
137
      std::string provider() const override;
138
139
0
      void clear() override { m_md.clear(); }
140
141
   private:
142
      void add_data(std::span<const uint8_t> input) override;
143
144
      void final_result(std::span<uint8_t> output) override;
145
146
   private:
147
      MerkleDamgard_Hash<SHA_512_256> m_md;
148
};
149
150
}  // namespace Botan
151
152
#endif