blake3.hpp

Go to the documentation of this file.

/*
 * libxcks
 * Copyright (C) 2022 Julien Couot
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef INC_BLAKE3_HPP_3FD9634A_21F0_43D6_A445_D8860A200C6E
#define INC_BLAKE3_HPP_3FD9634A_21F0_43D6_A445_D8860A200C6E
 
//---------------------------------------------------------------------------
#include "checksumex.hpp"
//---------------------------------------------------------------------------
 
 
namespace libxcks
{
class BLAKE3 final : public ChecksumEx
{
 private:
  enum class Flags : uint8_t
  {
    CHUNK_START         = 1 << 0,
    CHUNK_END           = 1 << 1,
    PARENT              = 1 << 2,
    ROOT                = 1 << 3,
    KEYED_HASH          = 1 << 4,
    DERIVE_KEY_CONTEXT  = 1 << 5,
    DERIVE_KEY_MATERIAL = 1 << 6,
  };
 
  static constexpr size_t BLAKE3_KEY_LEN = 32;
  static constexpr size_t BLAKE3_OUT_LEN = 32;
  static constexpr size_t BLAKE3_BLOCK_LEN = 64;
  static constexpr size_t BLAKE3_MAX_DEPTH = 54;
  static constexpr size_t BLAKE3_CHUNK_LEN = 1024;
  static constexpr uint32_t IV[8] = { UINT32_C(0x6A09E667), UINT32_C(0xBB67AE85),
                                      UINT32_C(0x3C6EF372), UINT32_C(0xA54FF53A),
                                      UINT32_C(0x510E527F), UINT32_C(0x9B05688C),
                                      UINT32_C(0x1F83D9AB), UINT32_C(0x5BE0CD19) };
  static constexpr uint8_t MSG_SCHEDULE[7][16] =
  {
    { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
    { 2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8 },
    { 3, 4, 10, 12, 13, 2, 7, 14, 6, 5, 9, 0, 11, 15, 8, 1 },
    { 10, 7, 12, 9, 14, 3, 13, 15, 4, 0, 11, 2, 5, 8, 1, 6 },
    { 12, 13, 9, 11, 15, 10, 14, 8, 7, 2, 5, 3, 0, 1, 6, 4 },
    { 9, 14, 11, 5, 8, 12, 15, 1, 13, 3, 0, 10, 2, 6, 4, 7 },
    { 11, 15, 5, 0, 1, 9, 8, 6, 14, 10, 2, 12, 3, 4, 7, 13 },
  };
 
  class Output final
  {
   private:
    uint32_t input_cv[8];
    uint64_t counter;
    uint8_t   block[BLAKE3_BLOCK_LEN];
    uint8_t   block_len;
    uint8_t   flags;
 
   public:
    Output(const uint32_t input_cv[8], const uint8_t block[BLAKE3_BLOCK_LEN],
           uint8_t block_len, uint64_t counter, uint8_t flags);
    Output() = default;
    //Output(const Output&) = default;
    Output& operator=(const Output&) = default;
    void chainingValue(uint8_t cv[32]) const;
    void rootBytes(uint64_t seek, uint8_t *out, size_t out_len);
    static Output parentOutput(const uint8_t block[BLAKE3_BLOCK_LEN],
                               const uint32_t key[8], uint8_t flags);
  };
 
  class ChunkState final
  {
   private:
    uint32_t cv[8];
    uint64_t chunk_counter;
    uint8_t   buf[BLAKE3_BLOCK_LEN];
    uint8_t   buf_len;
    uint8_t   blocks_compressed;
    uint8_t   flags;
 
   private:
    size_t fillBuf(const uint8_t* input, size_t input_len);
    uint8_t maybeStartFlag() const;
 
   public:
    uint8_t getFlags() const { return flags; }
    uint64_t getChunkCounter() const { return chunk_counter; }
    void setChunkCounter(const uint64_t chunk_counter) { this->chunk_counter = chunk_counter; }
    void init(const uint32_t key[8], const uint8_t flags);
    void reset(const uint32_t key[8], const uint64_t chunk_counter);
    size_t len() const;
    void update(const uint8_t* input, size_t input_len);
    Output stateOutput() const;
  };
 
 protected:
  // State of computation between the single steps.
  uint32_t key[8];
  ChunkState chunk;
  uint8_t cv_stack_len;
  // The stack size is MAX_DEPTH + 1 because we do lazy merging. For example,
  // with 7 chunks, we have 3 entries in the stack. Adding an 8th chunk
  // requires a 4th entry, rather than merging everything down to 1, because we
  // don't know whether more input is coming. This is different from how the
  // reference implementation does things.
  uint8_t cv_stack[(BLAKE3_MAX_DEPTH + 1) * BLAKE3_OUT_LEN];
 
 private:
  static constexpr size_t simdDegree() { return 1; }
  static unsigned int popcnt(uint64_t x);
  static unsigned int highestOne(uint64_t x);
  static uint64_t roundDownToPowerOf2(uint64_t x);
  static uint32_t counterLow(uint64_t counter);
  static uint32_t counterHigh(uint64_t counter);
  static uint32_t load32(const void *src);
  static uint32_t rotr32(const uint32_t w, const uint32_t c);
  static size_t left_len(size_t content_len);
  static void store32(void *dst, uint32_t w);
  static void storeCvWords(uint8_t bytes_out[32], uint32_t cv_words[8]);
  static void g(uint32_t *state, const size_t a, const size_t b,
                const size_t c, const size_t d, const uint32_t x,
                const uint32_t y);
  static void roundFn(uint32_t state[16], const uint32_t *msg, size_t round);
  static void compressPre(uint32_t state[16], const uint32_t cv[8],
                          const uint8_t block[BLAKE3_BLOCK_LEN],
                          uint8_t block_len, uint64_t counter, uint8_t flags);
  static void compressInPlace(uint32_t cv[8], const uint8_t block[BLAKE3_BLOCK_LEN],
                              uint8_t block_len, uint64_t counter, uint8_t flags);
  static void compressXof(const uint32_t cv[8],
                          const uint8_t block[BLAKE3_BLOCK_LEN],
                          uint8_t block_len, uint64_t counter,
                          uint8_t flags, uint8_t out[64]);
  static void hashOne(const uint8_t *input, size_t blocks, const uint32_t key[8],
                      uint64_t counter, uint8_t flags, uint8_t flags_start,
                      uint8_t flags_end, uint8_t out[BLAKE3_OUT_LEN]);
  static void hashMany(const uint8_t *const *inputs, size_t num_inputs,
                       size_t blocks, const uint32_t key[8], uint64_t counter,
                       bool increment_counter, uint8_t flags, uint8_t flags_start,
                       uint8_t flags_end, uint8_t *out);
  static size_t compressChunksParallel(const uint8_t *input, size_t input_len,
                                       const uint32_t key[8],
                                       uint64_t chunk_counter, uint8_t flags,
                                       uint8_t *out);
  static size_t compressParentsParallel(const uint8_t *child_chaining_values,
                                        size_t num_chaining_values,
                                        const uint32_t key[8], uint8_t flags,
                                        uint8_t *out);
  static size_t compressSubtreeWide(const uint8_t *input, size_t input_len,
                                    const uint32_t key[8],
                                    uint64_t chunk_counter,
                                    uint8_t flags, uint8_t *out);
  static void compressSubtreeToParentNode(const uint8_t *input,
                                          size_t input_len,
                                          const uint32_t key[8],
                                          uint64_t chunk_counter,
                                          uint8_t flags,
                                          uint8_t out[2 * BLAKE3_OUT_LEN]);
 
 protected:
  void mergeCvStack(uint64_t total_len);
  void pushCv(uint8_t new_cv[BLAKE3_OUT_LEN], uint64_t chunk_counter);
  void finalizeSeek(uint64_t seek, uint8_t *out, size_t out_len);
 
 public:
  BLAKE3();
 
  void reset() override;
 
  uint8_t* getValue(uint8_t* buffer) const override;
 
  size_t getSize() const override { return BLAKE3_OUT_LEN; }
 
  void update(const uint8_t* buf, size_t len) override;
 
 public:
  std::string getName() const override
  {
    return getHashName();
  }
 
  ChecksumAlgoId getID() const override
  {
    return getIdentifier();
  }
 
  static std::string getHashName()
  {
    return "BLAKE3";
  }
 
  static constexpr ChecksumAlgoId getIdentifier()
  {
    return ChecksumAlgoId::BLAKE3;
  }
 
  static Checksum* getNewInstance()
  {
    return new BLAKE3();
  }
};
//---------------------------------------------------------------------------
}  // namespace libxcks
//---------------------------------------------------------------------------
 
#endif  // INC_BLAKE3_HPP_3FD9634A_21F0_43D6_A445_D8860A200C6E