82 std::span<std::span<const uint8_t>> inputs1,
83 std::span<std::span<const uint8_t>> inputs2)
override {
86 const size_t count = inputs1.size();
94 const auto rem =
common_prefix().subspan(m_prefix_full_bytes);
95 const size_t r = rem.size();
96 const size_t len1 = inputs1[0].size();
97 const size_t len2 = inputs2.empty() ? 0 : inputs2[0].size();
101 const auto padded_end =
checked_add(r, len1, len2, 1 + m_ctr_bytes + (m_block_bytes - 1));
102 BOTAN_ARG_CHECK(padded_end.has_value(),
"Hash_Engine::batch_hash inputs too long");
104 const size_t stream_len = r + len1 + len2;
105 const size_t blocks = *padded_end / m_block_bytes;
106 const size_t padded_len = m_block_bytes * blocks;
107 const uint64_t total_bits = 8 *
static_cast<uint64_t
>(
common_prefix().size() + len1 + len2);
113 const size_t d1_lo = (r + m_block_bytes - 1) / m_block_bytes;
114 const size_t d1_hi = (r + len1) / m_block_bytes;
115 const size_t d2_lo = (r + len1 + m_block_bytes - 1) / m_block_bytes;
116 const size_t d2_hi = (r + len1 + len2) / m_block_bytes;
118 std::array<Step, MAX_STEPS> steps{};
120 size_t scratch_blocks = 0;
122 for(
size_t b = 0; b < blocks;) {
124 Step& step = steps[nsteps++];
126 if(b >= d1_lo && b < d1_hi) {
127 step = Step{Step::Kind::Direct1, b, d1_hi, 0};
128 }
else if(b >= d2_lo && b < d2_hi) {
129 step = Step{Step::Kind::Direct2, b, d2_hi, 0};
132 if(b < d1_lo && d1_lo < d1_hi) {
133 e = std::min(e, d1_lo);
135 if(b < d2_lo && d2_lo < d2_hi) {
136 e = std::min(e, d2_lo);
138 step = Step{Step::Kind::Scratch, b, e, scratch_blocks};
139 scratch_blocks += e - b;
145 const size_t lane_stride = scratch_blocks * m_block_bytes;
146 if(m_scratch.size() < m_lanes * lane_stride) {
147 m_scratch.resize(m_lanes * lane_stride);
149 const auto scratch = [&](
size_t lane,
const Step& step) {
150 return &m_scratch[lane * lane_stride + step.slot * m_block_bytes];
155 for(
size_t i = 0; i != nsteps; ++i) {
156 const Step& step = steps[i];
157 if(step.kind != Step::Kind::Scratch) {
160 const size_t lo = step.lo * m_block_bytes;
161 const size_t hi = step.hi * m_block_bytes;
163 for(
size_t l = 0; l != m_lanes; ++l) {
164 uint8_t* dest = scratch(l, step);
166 copy_overlap(dest, lo, hi, rem, 0);
167 if(stream_len >= lo && stream_len < hi) {
168 dest[stream_len - lo] = 0x80;
171 if(hi == padded_len) {
172 store_be(total_bits, dest + (padded_len - 8 - lo));
177 for(
size_t base = 0; base < count; base += m_lanes) {
179 const auto lane_idx = [&](
size_t l) {
return std::min(base + l, count - 1); };
181 copy_mem(m_states, m_initial_states);
183 for(
size_t i = 0; i != nsteps; ++i) {
184 const Step& step = steps[i];
185 const size_t lo = step.lo * m_block_bytes;
186 const size_t hi = step.hi * m_block_bytes;
188 if(step.kind == Step::Kind::Direct1) {
189 for(
size_t l = 0; l != m_lanes; ++l) {
190 m_ptrs[l] = inputs1[lane_idx(l)].data() + (lo - r);
192 }
else if(step.kind == Step::Kind::Direct2) {
193 for(
size_t l = 0; l != m_lanes; ++l) {
194 m_ptrs[l] = inputs2[lane_idx(l)].data() + (lo - r - len1);
197 for(
size_t l = 0; l != m_lanes; ++l) {
198 uint8_t* dest = scratch(l, step);
199 copy_overlap(dest, lo, hi, inputs1[lane_idx(l)], r);
200 if(!inputs2.empty()) {
201 copy_overlap(dest, lo, hi, inputs2[lane_idx(l)], r + len1);
207 m_compress(m_states.data(), m_ptrs.data(), step.hi - step.lo);
210 m_extract(m_states.data(), m_digests.data());
212 const size_t used_lanes = std::min(m_lanes, count - base);
213 for(
size_t l = 0; l != used_lanes; ++l) {
214 copy_mem(outputs[base + l].first(m_output_length),
215 std::span(m_digests).subspan(l * DIGEST_BYTES, m_output_length));