1  // Copyright (c) 2014-present 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  #ifndef BITCOIN_CRYPTO_COMMON_H
  6  #define BITCOIN_CRYPTO_COMMON_H
  7  
  8  #include <compat/endian.h>
  9  
 10  #include <concepts>
 11  #include <cstddef>
 12  #include <cstdint>
 13  #include <cstring>
 14  
 15  template <typename B>
 16  concept ByteType = std::same_as<B, unsigned char> || std::same_as<B, std::byte>;
 17  
 18  template <ByteType B>
 19  inline uint16_t ReadLE16(const B* ptr)
 20  {
 21      uint16_t x;
 22      memcpy(&x, ptr, 2);
 23      return le16toh_internal(x);
 24  }
 25  
 26  template <ByteType B>
 27  inline uint32_t ReadLE32(const B* ptr)
 28  {
 29      uint32_t x;
 30      memcpy(&x, ptr, 4);
 31      return le32toh_internal(x);
 32  }
 33  
 34  template <ByteType B>
 35  inline uint64_t ReadLE64(const B* ptr)
 36  {
 37      uint64_t x;
 38      memcpy(&x, ptr, 8);
 39      return le64toh_internal(x);
 40  }
 41  
 42  template <ByteType B>
 43  inline void WriteLE16(B* ptr, uint16_t x)
 44  {
 45      uint16_t v = htole16_internal(x);
 46      memcpy(ptr, &v, 2);
 47  }
 48  
 49  template <ByteType B>
 50  inline void WriteLE32(B* ptr, uint32_t x)
 51  {
 52      uint32_t v = htole32_internal(x);
 53      memcpy(ptr, &v, 4);
 54  }
 55  
 56  template <ByteType B>
 57  inline void WriteLE64(B* ptr, uint64_t x)
 58  {
 59      uint64_t v = htole64_internal(x);
 60      memcpy(ptr, &v, 8);
 61  }
 62  
 63  template <ByteType B>
 64  inline uint16_t ReadBE16(const B* ptr)
 65  {
 66      uint16_t x;
 67      memcpy(&x, ptr, 2);
 68      return be16toh_internal(x);
 69  }
 70  
 71  template <ByteType B>
 72  inline uint32_t ReadBE32(const B* ptr)
 73  {
 74      uint32_t x;
 75      memcpy(&x, ptr, 4);
 76      return be32toh_internal(x);
 77  }
 78  
 79  template <ByteType B>
 80  inline uint64_t ReadBE64(const B* ptr)
 81  {
 82      uint64_t x;
 83      memcpy(&x, ptr, 8);
 84      return be64toh_internal(x);
 85  }
 86  
 87  template <ByteType B>
 88  inline void WriteBE16(B* ptr, uint16_t x)
 89  {
 90      uint16_t v = htobe16_internal(x);
 91      memcpy(ptr, &v, 2);
 92  }
 93  
 94  template <ByteType B>
 95  inline void WriteBE32(B* ptr, uint32_t x)
 96  {
 97      uint32_t v = htobe32_internal(x);
 98      memcpy(ptr, &v, 4);
 99  }
100  
101  template <ByteType B>
102  inline void WriteBE64(B* ptr, uint64_t x)
103  {
104      uint64_t v = htobe64_internal(x);
105      memcpy(ptr, &v, 8);
106  }
107  
108  #endif // BITCOIN_CRYPTO_COMMON_H