LCOV - code coverage report
Current view: top level - src/crypto - sha3.cpp (source / functions) Hit Total Coverage
Test: total_coverage.info Lines: 106 106 100.0 %
Date: 2020-09-26 01:30:44 Functions: 5 5 100.0 %

          Line data    Source code
       1             : // Copyright (c) 2020 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             : // Based on https://github.com/mjosaarinen/tiny_sha3/blob/master/sha3.c
       6             : // by Markku-Juhani O. Saarinen <mjos@iki.fi>
       7             : 
       8             : #include <crypto/sha3.h>
       9             : #include <crypto/common.h>
      10             : #include <span.h>
      11             : 
      12             : #include <algorithm>
      13             : #include <array> // For std::begin and std::end.
      14             : 
      15             : #include <stdint.h>
      16             : 
      17             : // Internal implementation code.
      18             : namespace
      19             : {
      20   238990392 : uint64_t Rotl(uint64_t x, int n) { return (x << n) | (x >> (64 - n)); }
      21             : } // namespace
      22             : 
      23      343377 : void KeccakF(uint64_t (&st)[25])
      24             : {
      25             :     static constexpr uint64_t RNDC[24] = {
      26             :         0x0000000000000001, 0x0000000000008082, 0x800000000000808a, 0x8000000080008000,
      27             :         0x000000000000808b, 0x0000000080000001, 0x8000000080008081, 0x8000000000008009,
      28             :         0x000000000000008a, 0x0000000000000088, 0x0000000080008009, 0x000000008000000a,
      29             :         0x000000008000808b, 0x800000000000008b, 0x8000000000008089, 0x8000000000008003,
      30             :         0x8000000000008002, 0x8000000000000080, 0x000000000000800a, 0x800000008000000a,
      31             :         0x8000000080008081, 0x8000000000008080, 0x0000000080000001, 0x8000000080008008
      32             :     };
      33             :     static constexpr int ROUNDS = 24;
      34             : 
      35     8584425 :     for (int round = 0; round < ROUNDS; ++round) {
      36             :         uint64_t bc0, bc1, bc2, bc3, bc4, t;
      37             : 
      38             :         // Theta
      39     8241048 :         bc0 = st[0] ^ st[5] ^ st[10] ^ st[15] ^ st[20];
      40     8241048 :         bc1 = st[1] ^ st[6] ^ st[11] ^ st[16] ^ st[21];
      41     8241048 :         bc2 = st[2] ^ st[7] ^ st[12] ^ st[17] ^ st[22];
      42     8241048 :         bc3 = st[3] ^ st[8] ^ st[13] ^ st[18] ^ st[23];
      43     8241048 :         bc4 = st[4] ^ st[9] ^ st[14] ^ st[19] ^ st[24];
      44     8241048 :         t = bc4 ^ Rotl(bc1, 1); st[0] ^= t; st[5] ^= t; st[10] ^= t; st[15] ^= t; st[20] ^= t;
      45     8241048 :         t = bc0 ^ Rotl(bc2, 1); st[1] ^= t; st[6] ^= t; st[11] ^= t; st[16] ^= t; st[21] ^= t;
      46     8241048 :         t = bc1 ^ Rotl(bc3, 1); st[2] ^= t; st[7] ^= t; st[12] ^= t; st[17] ^= t; st[22] ^= t;
      47     8241048 :         t = bc2 ^ Rotl(bc4, 1); st[3] ^= t; st[8] ^= t; st[13] ^= t; st[18] ^= t; st[23] ^= t;
      48     8241048 :         t = bc3 ^ Rotl(bc0, 1); st[4] ^= t; st[9] ^= t; st[14] ^= t; st[19] ^= t; st[24] ^= t;
      49             : 
      50             :         // Rho Pi
      51     8241048 :         t = st[1];
      52     8241048 :         bc0 = st[10]; st[10] = Rotl(t, 1); t = bc0;
      53     8241048 :         bc0 = st[7]; st[7] = Rotl(t, 3); t = bc0;
      54     8241048 :         bc0 = st[11]; st[11] = Rotl(t, 6); t = bc0;
      55     8241048 :         bc0 = st[17]; st[17] = Rotl(t, 10); t = bc0;
      56     8241048 :         bc0 = st[18]; st[18] = Rotl(t, 15); t = bc0;
      57     8241048 :         bc0 = st[3]; st[3] = Rotl(t, 21); t = bc0;
      58     8241048 :         bc0 = st[5]; st[5] = Rotl(t, 28); t = bc0;
      59     8241048 :         bc0 = st[16]; st[16] = Rotl(t, 36); t = bc0;
      60     8241048 :         bc0 = st[8]; st[8] = Rotl(t, 45); t = bc0;
      61     8241048 :         bc0 = st[21]; st[21] = Rotl(t, 55); t = bc0;
      62     8241048 :         bc0 = st[24]; st[24] = Rotl(t, 2); t = bc0;
      63     8241048 :         bc0 = st[4]; st[4] = Rotl(t, 14); t = bc0;
      64     8241048 :         bc0 = st[15]; st[15] = Rotl(t, 27); t = bc0;
      65     8241048 :         bc0 = st[23]; st[23] = Rotl(t, 41); t = bc0;
      66     8241048 :         bc0 = st[19]; st[19] = Rotl(t, 56); t = bc0;
      67     8241048 :         bc0 = st[13]; st[13] = Rotl(t, 8); t = bc0;
      68     8241048 :         bc0 = st[12]; st[12] = Rotl(t, 25); t = bc0;
      69     8241048 :         bc0 = st[2]; st[2] = Rotl(t, 43); t = bc0;
      70     8241048 :         bc0 = st[20]; st[20] = Rotl(t, 62); t = bc0;
      71     8241048 :         bc0 = st[14]; st[14] = Rotl(t, 18); t = bc0;
      72     8241048 :         bc0 = st[22]; st[22] = Rotl(t, 39); t = bc0;
      73     8241048 :         bc0 = st[9]; st[9] = Rotl(t, 61); t = bc0;
      74     8241048 :         bc0 = st[6]; st[6] = Rotl(t, 20); t = bc0;
      75     8241048 :         st[1] = Rotl(t, 44);
      76             : 
      77             :         // Chi Iota
      78     8241048 :         bc0 = st[0]; bc1 = st[1]; bc2 = st[2]; bc3 = st[3]; bc4 = st[4];
      79     8241048 :         st[0] = bc0 ^ (~bc1 & bc2) ^ RNDC[round];
      80     8241048 :         st[1] = bc1 ^ (~bc2 & bc3);
      81     8241048 :         st[2] = bc2 ^ (~bc3 & bc4);
      82     8241048 :         st[3] = bc3 ^ (~bc4 & bc0);
      83     8241048 :         st[4] = bc4 ^ (~bc0 & bc1);
      84     8241048 :         bc0 = st[5]; bc1 = st[6]; bc2 = st[7]; bc3 = st[8]; bc4 = st[9];
      85     8241048 :         st[5] = bc0 ^ (~bc1 & bc2);
      86     8241048 :         st[6] = bc1 ^ (~bc2 & bc3);
      87     8241048 :         st[7] = bc2 ^ (~bc3 & bc4);
      88     8241048 :         st[8] = bc3 ^ (~bc4 & bc0);
      89     8241048 :         st[9] = bc4 ^ (~bc0 & bc1);
      90     8241048 :         bc0 = st[10]; bc1 = st[11]; bc2 = st[12]; bc3 = st[13]; bc4 = st[14];
      91     8241048 :         st[10] = bc0 ^ (~bc1 & bc2);
      92     8241048 :         st[11] = bc1 ^ (~bc2 & bc3);
      93     8241048 :         st[12] = bc2 ^ (~bc3 & bc4);
      94     8241048 :         st[13] = bc3 ^ (~bc4 & bc0);
      95     8241048 :         st[14] = bc4 ^ (~bc0 & bc1);
      96     8241048 :         bc0 = st[15]; bc1 = st[16]; bc2 = st[17]; bc3 = st[18]; bc4 = st[19];
      97     8241048 :         st[15] = bc0 ^ (~bc1 & bc2);
      98     8241048 :         st[16] = bc1 ^ (~bc2 & bc3);
      99     8241048 :         st[17] = bc2 ^ (~bc3 & bc4);
     100     8241048 :         st[18] = bc3 ^ (~bc4 & bc0);
     101     8241048 :         st[19] = bc4 ^ (~bc0 & bc1);
     102     8241048 :         bc0 = st[20]; bc1 = st[21]; bc2 = st[22]; bc3 = st[23]; bc4 = st[24];
     103     8241048 :         st[20] = bc0 ^ (~bc1 & bc2);
     104     8241048 :         st[21] = bc1 ^ (~bc2 & bc3);
     105     8241048 :         st[22] = bc2 ^ (~bc3 & bc4);
     106     8241048 :         st[23] = bc3 ^ (~bc4 & bc0);
     107     8241048 :         st[24] = bc4 ^ (~bc0 & bc1);
     108             :     }
     109      343377 : }
     110             : 
     111         231 : SHA3_256& SHA3_256::Write(Span<const unsigned char> data)
     112             : {
     113         231 :     if (m_bufsize && m_bufsize + data.size() >= sizeof(m_buffer)) {
     114             :         // Fill the buffer and process it.
     115          53 :         std::copy(data.begin(), data.begin() + sizeof(m_buffer) - m_bufsize, m_buffer + m_bufsize);
     116          53 :         data = data.subspan(sizeof(m_buffer) - m_bufsize);
     117          53 :         m_state[m_pos++] ^= ReadLE64(m_buffer);
     118          53 :         m_bufsize = 0;
     119          53 :         if (m_pos == RATE_BUFFERS) {
     120           3 :             KeccakF(m_state);
     121           3 :             m_pos = 0;
     122           3 :         }
     123             :     }
     124     1379600 :     while (data.size() >= sizeof(m_buffer)) {
     125             :         // Process chunks directly from the buffer.
     126     1379369 :         m_state[m_pos++] ^= ReadLE64(data.data());
     127     1379369 :         data = data.subspan(8);
     128     1379369 :         if (m_pos == RATE_BUFFERS) {
     129       81109 :             KeccakF(m_state);
     130       81109 :             m_pos = 0;
     131       81109 :         }
     132             :     }
     133         231 :     if (data.size()) {
     134             :         // Keep the remainder in the buffer.
     135         169 :         std::copy(data.begin(), data.end(), m_buffer + m_bufsize);
     136         169 :         m_bufsize += data.size();
     137         169 :     }
     138         231 :     return *this;
     139             : }
     140             : 
     141         121 : SHA3_256& SHA3_256::Finalize(Span<unsigned char> output)
     142             : {
     143         121 :     assert(output.size() == OUTPUT_SIZE);
     144         121 :     std::fill(m_buffer + m_bufsize, m_buffer + sizeof(m_buffer), 0);
     145         121 :     m_buffer[m_bufsize] ^= 0x06;
     146         121 :     m_state[m_pos] ^= ReadLE64(m_buffer);
     147         121 :     m_state[RATE_BUFFERS - 1] ^= 0x8000000000000000;
     148         121 :     KeccakF(m_state);
     149         605 :     for (unsigned i = 0; i < 4; ++i) {
     150         484 :         WriteLE64(output.data() + 8 * i, m_state[i]);
     151             :     }
     152         121 :     return *this;
     153             : }
     154             : 
     155          55 : SHA3_256& SHA3_256::Reset()
     156             : {
     157          55 :     m_bufsize = 0;
     158          55 :     m_pos = 0;
     159          55 :     std::fill(std::begin(m_state), std::end(m_state), 0);
     160          55 :     return *this;
     161             : }

Generated by: LCOV version 1.15