Bitcoin ABC  0.22.12
P2P Digital Currency
chacha_poly_aead.cpp
Go to the documentation of this file.
1 // Copyright (c) 2019 The Bitcoin Core developers
2 // Distributed under the MIT software license, see the accompanying
3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 
5 #include <iostream>
6 
7 #include <bench/bench.h>
9 #include <crypto/poly1305.h> // for the POLY1305_TAGLEN constant
10 #include <hash.h>
11 
12 #include <cassert>
13 #include <limits>
14 
15 /* Number of bytes to process per iteration */
16 static constexpr uint64_t BUFFER_SIZE_TINY = 64;
17 static constexpr uint64_t BUFFER_SIZE_SMALL = 256;
18 static constexpr uint64_t BUFFER_SIZE_LARGE = 1024 * 1024;
19 
20 static const uint8_t k1[32] = {0};
21 static const uint8_t k2[32] = {0};
22 
23 static ChaCha20Poly1305AEAD aead(k1, 32, k2, 32);
24 
25 static void CHACHA20_POLY1305_AEAD(benchmark::State &state, size_t buffersize,
26  bool include_decryption) {
27  std::vector<uint8_t> in(
29  std::vector<uint8_t> out(
31  uint64_t seqnr_payload = 0;
32  uint64_t seqnr_aad = 0;
33  int aad_pos = 0;
34  uint32_t len = 0;
35  while (state.KeepRunning()) {
36  // encrypt or decrypt the buffer with a static key
37  assert(aead.Crypt(seqnr_payload, seqnr_aad, aad_pos, out.data(),
38  out.size(), in.data(), buffersize, true));
39 
40  if (include_decryption) {
41  // if we decrypt, include the GetLength
42  assert(aead.GetLength(&len, seqnr_aad, aad_pos, in.data()));
43  assert(aead.Crypt(seqnr_payload, seqnr_aad, aad_pos, out.data(),
44  out.size(), in.data(), buffersize, true));
45  }
46 
47  // increase main sequence number
48  seqnr_payload++;
49  // increase aad position (position in AAD keystream)
52  aad_pos = 0;
53  seqnr_aad++;
54  }
55  if (seqnr_payload + 1 == std::numeric_limits<uint64_t>::max()) {
56  // reuse of nonce+key is okay while benchmarking.
57  seqnr_payload = 0;
58  seqnr_aad = 0;
59  aad_pos = 0;
60  }
61  }
62 }
63 
64 static void
67 }
68 
69 static void
72 }
73 
76 }
77 
78 static void
81 }
82 
83 static void
86 }
87 
88 static void
91 }
92 
93 // Add Hash() (dbl-sha256) bench for comparison
94 
95 static void HASH(benchmark::State &state, size_t buffersize) {
96  uint8_t hash[CHash256::OUTPUT_SIZE];
97  std::vector<uint8_t> in(buffersize, 0);
98  while (state.KeepRunning()) {
99  CHash256().Write(in.data(), in.size()).Finalize(hash);
100  }
101 }
102 
103 static void HASH_64BYTES(benchmark::State &state) {
104  HASH(state, BUFFER_SIZE_TINY);
105 }
106 
107 static void HASH_256BYTES(benchmark::State &state) {
108  HASH(state, BUFFER_SIZE_SMALL);
109 }
110 
111 static void HASH_1MB(benchmark::State &state) {
112  HASH(state, BUFFER_SIZE_LARGE);
113 }
114 
121 BENCHMARK(HASH_64BYTES, 500000);
122 BENCHMARK(HASH_256BYTES, 250000);
123 BENCHMARK(HASH_1MB, 340);
#define POLY1305_TAGLEN
Definition: poly1305.h:12
static void HASH_256BYTES(benchmark::State &state)
static void CHACHA20_POLY1305_AEAD_64BYTES_ONLY_ENCRYPT(benchmark::State &state)
bool GetLength(uint32_t *len24_out, uint64_t seqnr_aad, int aad_pos, const uint8_t *ciphertext)
decrypts the 3 bytes AAD data and decodes it into a uint32_t field
static void HASH(benchmark::State &state, size_t buffersize)
static constexpr uint64_t BUFFER_SIZE_LARGE
static void CHACHA20_POLY1305_AEAD_1MB_ONLY_ENCRYPT(benchmark::State &state)
bool KeepRunning()
Definition: bench.h:75
A hasher class for Bitcoin&#39;s 256-bit hash (double SHA-256).
Definition: hash.h:22
static void CHACHA20_POLY1305_AEAD_64BYTES_ENCRYPT_DECRYPT(benchmark::State &state)
static void CHACHA20_POLY1305_AEAD_1MB_ENCRYPT_DECRYPT(benchmark::State &state)
BENCHMARK(CHACHA20_POLY1305_AEAD_64BYTES_ONLY_ENCRYPT, 500000)
static constexpr int CHACHA20_POLY1305_AEAD_AAD_LEN
static void CHACHA20_POLY1305_AEAD_256BYTES_ONLY_ENCRYPT(benchmark::State &state)
bool Crypt(uint64_t seqnr_payload, uint64_t seqnr_aad, int aad_pos, uint8_t *dest, size_t dest_len, const uint8_t *src, size_t src_len, bool is_encrypt)
Encrypts/decrypts a packet.
static void HASH_64BYTES(benchmark::State &state)
static const uint8_t k1[32]
CHash256 & Write(const uint8_t *data, size_t len)
Definition: hash.h:35
static void HASH_1MB(benchmark::State &state)
static void CHACHA20_POLY1305_AEAD_256BYTES_ENCRYPT_DECRYPT(benchmark::State &state)
static constexpr uint64_t BUFFER_SIZE_SMALL
static void CHACHA20_POLY1305_AEAD(benchmark::State &state, size_t buffersize, bool include_decryption)
static const size_t OUTPUT_SIZE
Definition: hash.h:27
static ChaCha20Poly1305AEAD aead(k1, 32, k2, 32)
static constexpr uint64_t BUFFER_SIZE_TINY
static constexpr int CHACHA20_ROUND_OUTPUT
static const uint8_t k2[32]