nerdcruft/libcruft-crypto
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

rename util namespace to cruft

Browse Source
This commit is contained in:
Danny Robson 2018-08-05 14:51:17 +10:00
parent 38888bcfeb
commit eecf799753
40 changed files with 117 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
CMakeLists.txt
View File

@ -3,12 +3,6 @@ cmake_minimum_required(VERSION 3.7.0)
project(cruft-crypto CXX) project(cruft-crypto CXX)
###############################################################################
if (NOT TARGET cruft-util)
message (FATAL_ERROR "cruft-util was not found")
endif ()
############################################################################### ###############################################################################
list (APPEND sources list (APPEND sources
fwd.hpp fwd.hpp
@ -104,7 +98,7 @@ endif ()
############################################################################### ###############################################################################
add_library (cruft-crypto STATIC ${sources}) add_library (cruft-crypto STATIC ${sources})
target_link_libraries (cruft-crypto INTERFACE cruft-util) target_link_libraries (cruft-crypto INTERFACE cruft)
##----------------------------------------------------------------------------- ##-----------------------------------------------------------------------------

24
hash/blake.cpp
View File

@ -148,16 +148,16 @@ G (int i,
const auto k = permute[r][2 * i + 1]; const auto k = permute[r][2 * i + 1];
a = a + b + (m[j] ^ traits<width>::pi[k]); a = a + b + (m[j] ^ traits<width>::pi[k]);
d = util::rotater (d ^ a, traits<width>::rotations[0]); d = cruft::rotater (d ^ a, traits<width>::rotations[0]);
c = c + d; c = c + d;
b = util::rotater (b ^ c, traits<width>::rotations[1]); b = cruft::rotater (b ^ c, traits<width>::rotations[1]);
a = a + b + (m[k] ^ traits<width>::pi[j]); a = a + b + (m[k] ^ traits<width>::pi[j]);
d = util::rotater (d ^ a, traits<width>::rotations[2]); d = cruft::rotater (d ^ a, traits<width>::rotations[2]);
c = c + d; c = c + d;
b = util::rotater (b ^ c, traits<width>::rotations[3]); b = cruft::rotater (b ^ c, traits<width>::rotations[3]);
} }
@ -212,8 +212,8 @@ compress (
template <int width> template <int width>
typename blake<width>::digest_t typename blake<width>::digest_t
blake<width>::operator() ( blake<width>::operator() (
util::view<const uint8_t*> data, cruft::view<const uint8_t*> data,
util::view<const uint8_t*> salt cruft::view<const uint8_t*> salt
) const { ) const {
std::array<typename traits<width>::word_t, 4> fwd {}; std::array<typename traits<width>::word_t, 4> fwd {};
@ -228,7 +228,7 @@ blake<width>::operator() (
template <int width> template <int width>
typename blake<width>::digest_t typename blake<width>::digest_t
blake<width>::operator() ( blake<width>::operator() (
util::view<const uint8_t *> data, cruft::view<const uint8_t *> data,
const std::array<typename traits<width>::word_t, 4> salt const std::array<typename traits<width>::word_t, 4> salt
) const noexcept { ) const noexcept {
auto h = traits<width>::iv; auto h = traits<width>::iv;
@ -249,7 +249,7 @@ blake<width>::operator() (
// perform the simple case where we're consuming whole blocks // perform the simple case where we're consuming whole blocks
for (auto last = data.cend (); for (auto last = data.cend ();
util::cast::sign<size_t> (last - cursor) >= sizeof (dw); cruft::cast::sign<size_t> (last - cursor) >= sizeof (dw);
cursor += sizeof (dw)) cursor += sizeof (dw))
{ {
// use the number of bits as the size // use the number of bits as the size
@ -260,7 +260,7 @@ blake<width>::operator() (
std::cbegin (dw), std::cbegin (dw),
std::cend (dw), std::cend (dw),
std::begin (dw), std::begin (dw),
util::ntoh<word_t> cruft::ntoh<word_t>
); );
h = compress<width> (h, dw, salt, t); h = compress<width> (h, dw, salt, t);
} }
@ -293,7 +293,7 @@ blake<width>::operator() (
std::cbegin (dw), std::cbegin (dw),
std::cend (dw), std::cend (dw),
std::begin (dw), std::begin (dw),
util::ntoh<word_t> cruft::ntoh<word_t>
); );
h = compress<width> (h, dw, salt, t); h = compress<width> (h, dw, salt, t);
@ -315,12 +315,12 @@ blake<width>::operator() (
std::cbegin (dw), std::cbegin (dw),
std::cend (dw) - 2, std::cend (dw) - 2,
std::begin (dw), std::begin (dw),
util::ntoh<word_t> cruft::ntoh<word_t>
); );
h = compress<width> (h, dw, salt, empty ? 0 : t); h = compress<width> (h, dw, salt, empty ? 0 : t);
} }
std::transform (std::cbegin (h), std::cend (h), std::begin (h), util::hton<word_t>); std::transform (std::cbegin (h), std::cend (h), std::begin (h), cruft::hton<word_t>);
digest_t d; digest_t d;
memcpy (d.data (), h.data (), sizeof (d)); memcpy (d.data (), h.data (), sizeof (d));
return d; return d;

8
hash/blake.hpp
View File

@ -87,14 +87,14 @@ namespace cruft::crypto::hash {
digest_t operator() ( digest_t operator() (
util::view<const uint8_t*> data, cruft::view<const uint8_t*> data,
util::view<const uint8_t*> salt cruft::view<const uint8_t*> salt
) const; ) const;
digest_t operator() (util::view<const uint8_t*> data, digest_t operator() (cruft::view<const uint8_t*> data,
const std::array<word_t,4> salt) const noexcept; const std::array<word_t,4> salt) const noexcept;
digest_t operator() (util::view<const uint8_t*> data) const noexcept digest_t operator() (cruft::view<const uint8_t*> data) const noexcept
{ {
return (*this) (data, {0,0,0,0}); return (*this) (data, {0,0,0,0});
} }

30
hash/blake2.cpp
View File

@ -20,7 +20,7 @@ using cruft::crypto::hash::blake2;
// blake2b: uint64_t // blake2b: uint64_t
struct traits { struct traits {
static constexpr int word_bits = 64; static constexpr int word_bits = 64;
using word_t = typename util::bits_type<word_bits>::uint; using word_t = typename cruft::bits_type<word_bits>::uint;
static constexpr int F_rounds = 12; static constexpr int F_rounds = 12;
static constexpr int block_bytes = 128; // bb static constexpr int block_bytes = 128; // bb
static constexpr int max_hash_bytes = 64; // nn static constexpr int max_hash_bytes = 64; // nn
@ -66,16 +66,16 @@ void
G (std::array<word_t,16> &v, int a, int b, int c, int d, word_t x, word_t y) G (std::array<word_t,16> &v, int a, int b, int c, int d, word_t x, word_t y)
{ {
v[a] = v[a] + v[b] + x; v[a] = v[a] + v[b] + x;
v[d] = util::rotater (v[d] ^ v[a], traits::rotations[0]); v[d] = cruft::rotater (v[d] ^ v[a], traits::rotations[0]);
v[c] = v[c] + v[d]; v[c] = v[c] + v[d];
v[b] = util::rotater (v[b] ^ v[c], traits::rotations[1]); v[b] = cruft::rotater (v[b] ^ v[c], traits::rotations[1]);
v[a] = v[a] + v[b] + y; v[a] = v[a] + v[b] + y;
v[d] = util::rotater (v[d] ^ v[a], traits::rotations[2]); v[d] = cruft::rotater (v[d] ^ v[a], traits::rotations[2]);
v[c] = v[c] + v[d]; v[c] = v[c] + v[d];
v[b] = util::rotater (v[b] ^ v[c], traits::rotations[3]); v[b] = cruft::rotater (v[b] ^ v[c], traits::rotations[3]);
} }
@ -123,15 +123,15 @@ F (std::array<word_t,8> h, const word_t m[16], uint64_t t, bool f)
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
blake2::blake2 () noexcept: blake2::blake2 () noexcept:
blake2 (util::view<const uint8_t*>{nullptr}) blake2 (cruft::view<const uint8_t*>{nullptr})
{ ; } { ; }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
blake2::blake2 (util::view<const uint8_t *> key) blake2::blake2 (cruft::view<const uint8_t *> key)
{ {
// don't give the user flexibility to provide too much key // don't give the user flexibility to provide too much key
if (key.size () > traits::max_key_bytes) if (key.size () > ::traits::max_key_bytes)
throw std::invalid_argument ("key is too large"); throw std::invalid_argument ("key is too large");
std::fill (m_salt.begin (), m_salt.end (), 0); std::fill (m_salt.begin (), m_salt.end (), 0);
@ -142,15 +142,15 @@ blake2::blake2 (util::view<const uint8_t *> key)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
blake2::digest_t blake2::digest_t
blake2::operator() (util::view<const uint8_t *> data) const noexcept blake2::operator() (cruft::view<const uint8_t *> data) const noexcept
{ {
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-align" #pragma GCC diagnostic ignored "-Wcast-align"
auto h = traits::iv; auto h = ::traits::iv;
h[0] ^= 0x01010000 ^ (m_keylen << 8) ^ sizeof (digest_t); h[0] ^= 0x01010000 ^ (m_keylen << 8) ^ sizeof (digest_t);
if (m_keylen) if (m_keylen)
h = F (h, reinterpret_cast<const word_t*> (m_salt.data ()), traits::block_bytes, data.empty ()); h = F (h, reinterpret_cast<const word_t*> (m_salt.data ()), ::traits::block_bytes, data.empty ());
// special case for the empty key and empty data // special case for the empty key and empty data
if (!m_keylen && data.empty ()) { if (!m_keylen && data.empty ()) {
@ -158,13 +158,13 @@ blake2::operator() (util::view<const uint8_t *> data) const noexcept
h = F (h, zeroes.data (), 0, true); h = F (h, zeroes.data (), 0, true);
} }
uint64_t counter = m_keylen?traits::block_bytes:0; uint64_t counter = m_keylen?::traits::block_bytes:0;
auto cursor = data.begin (); auto cursor = data.begin ();
while (cursor + traits::block_bytes < data.end ()) { while (cursor + ::traits::block_bytes < data.end ()) {
counter += traits::block_bytes; counter += ::traits::block_bytes;
h = F (h, reinterpret_cast<const word_t*> (cursor), counter, false); h = F (h, reinterpret_cast<const word_t*> (cursor), counter, false);
cursor += traits::block_bytes; cursor += ::traits::block_bytes;
} }
if (cursor != data.cend ()) { if (cursor != data.cend ()) {

4
hash/blake2.hpp
View File

@ -23,9 +23,9 @@ namespace cruft::crypto::hash {
blake2 () noexcept; blake2 () noexcept;
blake2 (const salt_t&) noexcept; blake2 (const salt_t&) noexcept;
blake2 (util::view<const uint8_t*> key); blake2 (cruft::view<const uint8_t*> key);
digest_t operator() (util::view<const uint8_t*>) const noexcept; digest_t operator() (cruft::view<const uint8_t*>) const noexcept;
private: private:
using state_t = std::array<uint64_t,8>; using state_t = std::array<uint64_t,8>;

2
hash/hmac.hpp
View File

@ -25,7 +25,7 @@ namespace cruft::crypto::hash {
//--------------------------------------------------------------------- //---------------------------------------------------------------------
HMAC (util::view<const std::uint8_t*> key) HMAC (cruft::view<const std::uint8_t*> key)
{ {
CHECK (!key.empty ()); CHECK (!key.empty ());

6
hash/hotp.cpp
View File

@ -16,7 +16,7 @@ using cruft::crypto::hash::HOTP;
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
HOTP::HOTP (util::view<const char*> _key, uint64_t _counter): HOTP::HOTP (cruft::view<const char*> _key, uint64_t _counter):
m_counter (_counter), m_counter (_counter),
m_hash (_key.template cast<const uint8_t*> ()) m_hash (_key.template cast<const uint8_t*> ())
{ ; } { ; }
@ -32,9 +32,9 @@ HOTP::value (void)
uint8_t bytes[8]; uint8_t bytes[8];
}; };
number = util::htob (m_counter); number = cruft::htob (m_counter);
auto res = truncate (m_hash (util::make_cview (bytes))); auto res = truncate (m_hash (cruft::make_cview (bytes)));
++m_counter; ++m_counter;
return res % 1'000'000; return res % 1'000'000;
} }

2
hash/hotp.hpp
View File

@ -20,7 +20,7 @@ namespace cruft::crypto::hash {
/// HMAC one-time password (RFC 4226) /// HMAC one-time password (RFC 4226)
class HOTP { class HOTP {
public: public:
HOTP (util::view<const char*> key, uint64_t counter); HOTP (cruft::view<const char*> key, uint64_t counter);
unsigned value (void); unsigned value (void);
uint64_t counter (void) const; uint64_t counter (void) const;

6
hash/md2.cpp
View File

@ -50,7 +50,7 @@ static const size_t M_LENGTH = 16;
static void static void
transform (std::array<uint8_t,16> &C, std::array<uint8_t,48> &X) noexcept transform (std::array<uint8_t,16> &C, std::array<uint8_t,48> &X) noexcept
{ {
util::view M { X.data () + M_OFFSET, M_LENGTH }; cruft::view M { X.data () + M_OFFSET, M_LENGTH };
// Update the checksum. // Update the checksum.
// XXX: I can't see why we need the xor-assign from the spec, but it's the // XXX: I can't see why we need the xor-assign from the spec, but it's the
@ -77,13 +77,13 @@ transform (std::array<uint8_t,16> &C, std::array<uint8_t,48> &X) noexcept
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
MD2::digest_t MD2::digest_t
MD2::operator() (const util::view<const uint8_t*> data) const noexcept MD2::operator() (const cruft::view<const uint8_t*> data) const noexcept
{ {
// zero initialise the state vectors, and create a simple window `M' into // zero initialise the state vectors, and create a simple window `M' into
// the middle of the `X' state vector. // the middle of the `X' state vector.
std::array<uint8_t,16> C {}; std::array<uint8_t,16> C {};
std::array<uint8_t,48> X {}; std::array<uint8_t,48> X {};
const util::view M { std::begin (X) + M_OFFSET, M_LENGTH }; const cruft::view M { std::begin (X) + M_OFFSET, M_LENGTH };
// process each complete block by copying to the window `M' and // process each complete block by copying to the window `M' and
// transforming X and C. // transforming X and C.

2
hash/md2.hpp
View File

@ -22,7 +22,7 @@ namespace cruft::crypto::hash {
typedef std::array<uint8_t,16> digest_t; typedef std::array<uint8_t,16> digest_t;
public: public:
digest_t operator() (util::view<const uint8_t*>) const noexcept; digest_t operator() (cruft::view<const uint8_t*>) const noexcept;
}; };
} }

8
hash/md4.cpp
View File

@ -63,7 +63,7 @@ transform (std::array<uint32_t,4> &ABCD, const std::array<uint32_t,16> &X) noexc
#define ROUND1(a,b,c,d,k,s) do { \ #define ROUND1(a,b,c,d,k,s) do { \
(a) += F((b), (c), (d)) + X[k]; \ (a) += F((b), (c), (d)) + X[k]; \
(a) = util::rotatel ((a), (s)); \ (a) = cruft::rotatel ((a), (s)); \
} while (0) } while (0)
ROUND1(A,B,C,D, 0, 3); ROUND1(A,B,C,D, 0, 3);
@ -88,7 +88,7 @@ transform (std::array<uint32_t,4> &ABCD, const std::array<uint32_t,16> &X) noexc
#define ROUND2(a,b,c,d,k,s) do { \ #define ROUND2(a,b,c,d,k,s) do { \
(a) += G((b),(c),(d)) + X[k] + 0x5A827999u; \ (a) += G((b),(c),(d)) + X[k] + 0x5A827999u; \
(a) = util::rotatel ((a), (s)); \ (a) = cruft::rotatel ((a), (s)); \
} while (0) } while (0)
ROUND2(A,B,C,D, 0, 3); ROUND2(A,B,C,D, 0, 3);
@ -113,7 +113,7 @@ transform (std::array<uint32_t,4> &ABCD, const std::array<uint32_t,16> &X) noexc
#define ROUND3(a,b,c,d,k,s) do { \ #define ROUND3(a,b,c,d,k,s) do { \
(a) += H((b),(c),(d)) + X[k] + 0x6ED9EBA1u; \ (a) += H((b),(c),(d)) + X[k] + 0x6ED9EBA1u; \
(a) = util::rotatel ((a), (s)); \ (a) = cruft::rotatel ((a), (s)); \
} while (0) } while (0)
ROUND3(A,B,C,D, 0, 3); ROUND3(A,B,C,D, 0, 3);
@ -145,7 +145,7 @@ transform (std::array<uint32_t,4> &ABCD, const std::array<uint32_t,16> &X) noexc
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
MD4::digest_t MD4::digest_t
MD4::operator() (util::view<const uint8_t*> data) noexcept MD4::operator() (cruft::view<const uint8_t*> data) noexcept
{ {
/* RESET */ /* RESET */
uint64_t total = 0; uint64_t total = 0;

2
hash/md4.hpp
View File

@ -21,7 +21,7 @@ namespace cruft::crypto::hash {
public: public:
using digest_t = std::array<uint8_t,16>; using digest_t = std::array<uint8_t,16>;
digest_t operator() (util::view<const uint8_t*>) noexcept; digest_t operator() (cruft::view<const uint8_t*>) noexcept;
}; };
} }

16
hash/md5.cpp
View File

@ -95,7 +95,7 @@ static constexpr uint32_t INITIAL_D = 0x10325476;
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
typename MD5::digest_t typename MD5::digest_t
MD5::operator() (util::view<const uint8_t*> a) const noexcept MD5::operator() (cruft::view<const uint8_t*> a) const noexcept
{ {
return (*this)(a, nullptr); return (*this)(a, nullptr);
} }
@ -103,7 +103,7 @@ MD5::operator() (util::view<const uint8_t*> a) const noexcept
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
typename MD5::digest_t typename MD5::digest_t
MD5::operator() (util::view<const uint8_t*> a, util::view<const uint8_t*> b) const noexcept MD5::operator() (cruft::view<const uint8_t*> a, cruft::view<const uint8_t*> b) const noexcept
{ {
return (*this)(a, b, nullptr); return (*this)(a, b, nullptr);
} }
@ -112,9 +112,9 @@ MD5::operator() (util::view<const uint8_t*> a, util::view<const uint8_t*> b) con
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
typename MD5::digest_t typename MD5::digest_t
MD5::operator() ( MD5::operator() (
const util::view<const uint8_t*> data_a, const cruft::view<const uint8_t*> data_a,
const util::view<const uint8_t*> data_b, const cruft::view<const uint8_t*> data_b,
const util::view<const uint8_t*> data_c const cruft::view<const uint8_t*> data_c
) const noexcept { ) const noexcept {
union { union {
std::array<uint32_t,16> w; std::array<uint32_t,16> w;
@ -137,8 +137,8 @@ MD5::operator() (
// note we pass in a windowed view of the state block, not the whole // note we pass in a windowed view of the state block, not the whole
// thing. // thing.
util::transform_by_block ( cruft::transform_by_block (
util::view {X.b}, cruft::view {X.b},
[&,this] (auto) { ABCD = transform (ABCD, X.w); }, [&,this] (auto) { ABCD = transform (ABCD, X.w); },
data_a, data_b, data_c data_a, data_b, data_c
); );
@ -193,7 +193,7 @@ MD5::transform (
#define ROUNDx(a,b,c,d,k,s,i,f) do { \ #define ROUNDx(a,b,c,d,k,s,i,f) do { \
(a) += (f)((b), (c), (d)) + X[k] + T[i]; \ (a) += (f)((b), (c), (d)) + X[k] + T[i]; \
(a) = util::rotatel ((a), (s)); \ (a) = cruft::rotatel ((a), (s)); \
(a) += (b); \ (a) += (b); \
} while (0) } while (0)

6
hash/md5.hpp
View File

@ -25,9 +25,9 @@ namespace cruft::crypto::hash {
static const size_t DIGEST_SIZE = 16; static const size_t DIGEST_SIZE = 16;
public: public:
digest_t operator() (util::view<const uint8_t*>) const noexcept; digest_t operator() (cruft::view<const uint8_t*>) const noexcept;
digest_t operator() (util::view<const uint8_t*>,util::view<const uint8_t*>) const noexcept; digest_t operator() (cruft::view<const uint8_t*>,cruft::view<const uint8_t*>) const noexcept;
digest_t operator() (util::view<const uint8_t*>,util::view<const uint8_t*>,util::view<const uint8_t*>) const noexcept; digest_t operator() (cruft::view<const uint8_t*>,cruft::view<const uint8_t*>,cruft::view<const uint8_t*>) const noexcept;
private: private:
std::array<uint32_t,4> std::array<uint32_t,4>

2
hash/md6.cpp
View File

@ -14,7 +14,7 @@ using cruft::crypto::hash::MD6;
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#if 0 #if 0
MD6::digest_t MD6::digest_t
MD6::operator() (util::view<const uint8_t*> data) const noexcept MD6::operator() (cruft::view<const uint8_t*> data) const noexcept
{ {
static constexpr int rounds = 40 + digest_size / 4; static constexpr int rounds = 40 + digest_size / 4;
static constexpr int mode_control = 64; static constexpr int mode_control = 64;

2
hash/md6.hpp
View File

@ -20,7 +20,7 @@ namespace cruft::crypto::hash {
using digest_t = std::array<uint8_t,digest_size/8>; using digest_t = std::array<uint8_t,digest_size/8>;
digest_t operator() (util::view<const uint8_t*> data) const noexcept; digest_t operator() (cruft::view<const uint8_t*> data) const noexcept;
}; };
}; };

8
hash/ripemd.cpp
View File

@ -75,9 +75,9 @@ transform (uint32_t state[5], const uint32_t d32[16])
#define ROUND(f,a,b,c,d,e,o,x,s) { \ #define ROUND(f,a,b,c,d,e,o,x,s) { \
a += f(b, c, d); \ a += f(b, c, d); \
a += d32[x] + o; \ a += d32[x] + o; \
a = util::rotatel (a, s); \ a = cruft::rotatel (a, s); \
a += e; \ a += e; \
c = util::rotatel (c, 10); \ c = cruft::rotatel (c, 10); \
} }
#define R1a(a,b,c,d,e,x,s) ROUND(f1,a,b,c,d,e,0x00000000u,x,s) #define R1a(a,b,c,d,e,x,s) ROUND(f1,a,b,c,d,e,0x00000000u,x,s)
@ -293,7 +293,7 @@ transform (uint32_t state[5], const uint32_t d32[16])
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
RIPEMD::digest_t RIPEMD::digest_t
RIPEMD::operator() (const util::view<const uint8_t*> data) RIPEMD::operator() (const cruft::view<const uint8_t*> data)
{ {
struct { struct {
union { union {
@ -324,7 +324,7 @@ RIPEMD::operator() (const util::view<const uint8_t*> data)
while (cursor < len) { while (cursor < len) {
size_t width = sizeof (m_buffer.d08) - m_buffer.size; size_t width = sizeof (m_buffer.d08) - m_buffer.size;
size_t chunk = util::min (width, len - cursor); size_t chunk = cruft::min (width, len - cursor);
memcpy (m_buffer.d08 + m_buffer.size, base + cursor, chunk); memcpy (m_buffer.d08 + m_buffer.size, base + cursor, chunk);
m_length += chunk; m_length += chunk;

2
hash/ripemd.hpp
View File

@ -21,7 +21,7 @@ namespace cruft::crypto::hash {
public: public:
typedef std::array<uint8_t,20> digest_t; typedef std::array<uint8_t,20> digest_t;
digest_t operator() (util::view<const uint8_t*>); digest_t operator() (cruft::view<const uint8_t*>);
}; };
} }

18
hash/sha1.cpp
View File

@ -92,12 +92,12 @@ process (std::array<uint32_t,5> &H, std::array<uint32_t,16+64> &W)
std::end (W), std::end (W),
std::begin (W), std::begin (W),
[] (uint32_t x) { [] (uint32_t x) {
return util::ntoh (x); return cruft::ntoh (x);
}); });
// Initialise the work buffer and the state variables // Initialise the work buffer and the state variables
for (size_t t = 16; t < 80; ++t) for (size_t t = 16; t < 80; ++t)
W[t] = util::rotatel (W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1); W[t] = cruft::rotatel (W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1);
uint32_t A = H[0], uint32_t A = H[0],
B = H[1], B = H[1],
@ -107,10 +107,10 @@ process (std::array<uint32_t,5> &H, std::array<uint32_t,16+64> &W)
// Perform each of the four rounds // Perform each of the four rounds
#define ROTATE_STATE(i) do { \ #define ROTATE_STATE(i) do { \
uint32_t temp = util::rotatel (A, 5) + f_##i (B, C, D) + E + W[t] + K_##i; \ uint32_t temp = cruft::rotatel (A, 5) + f_##i (B, C, D) + E + W[t] + K_##i; \
E = D; \ E = D; \
D = C; \ D = C; \
C = util::rotatel (B, 30); \ C = cruft::rotatel (B, 30); \
B = A; \ B = A; \
A = temp; \ A = temp; \
} while (0) } while (0)
@ -131,7 +131,7 @@ process (std::array<uint32_t,5> &H, std::array<uint32_t,16+64> &W)
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
SHA1::digest_t SHA1::digest_t
SHA1::operator() (util::view<const uint8_t*> data) noexcept SHA1::operator() (cruft::view<const uint8_t*> data) noexcept
{ {
return (*this) (data, nullptr); return (*this) (data, nullptr);
} }
@ -140,8 +140,8 @@ SHA1::operator() (util::view<const uint8_t*> data) noexcept
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
SHA1::digest_t SHA1::digest_t
SHA1::operator() ( SHA1::operator() (
util::view<const uint8_t*> data_a, cruft::view<const uint8_t*> data_a,
util::view<const uint8_t*> data_b cruft::view<const uint8_t*> data_b
) noexcept { ) noexcept {
/* RESET */ /* RESET */
uint64_t total = 0; uint64_t total = 0;
@ -160,7 +160,7 @@ SHA1::operator() (
/* UPDATE */ /* UPDATE */
transform_by_block ( transform_by_block (
util::view {state.c.data (), BLOCK_BYTES }, cruft::view {state.c.data (), BLOCK_BYTES },
[&] (auto) { process (H.w, state.W); }, [&] (auto) { process (H.w, state.W); },
data_a, data_b data_a, data_b
); );
@ -204,6 +204,6 @@ SHA1::operator() (
} }
/* DIGEST */ /* DIGEST */
std::transform (std::begin (H.w), std::end (H.w), std::begin (H.w), util::hton<uint32_t>); std::transform (std::begin (H.w), std::end (H.w), std::begin (H.w), cruft::hton<uint32_t>);
return H.b; return H.b;
} }

4
hash/sha1.hpp
View File

@ -28,8 +28,8 @@ namespace cruft::crypto::hash {
//digest_t //digest_t
//operator() (DataT&&...); //operator() (DataT&&...);
digest_t operator() (util::view<const uint8_t*>, util::view<const uint8_t*>) noexcept; digest_t operator() (cruft::view<const uint8_t*>, cruft::view<const uint8_t*>) noexcept;
digest_t operator() (util::view<const uint8_t*>) noexcept; digest_t operator() (cruft::view<const uint8_t*>) noexcept;
}; };
} }

14
hash/sha2.cpp
View File

@ -86,9 +86,9 @@ static constexpr \
uint32_t \ uint32_t \
NAME (uint32_t x) \ NAME (uint32_t x) \
{ \ { \
return util::rotater (x, (r0)) ^ \ return cruft::rotater (x, (r0)) ^ \
util::rotater (x, (r1)) ^ \ cruft::rotater (x, (r1)) ^ \
util::rotater (x, (r2)); \ cruft::rotater (x, (r2)); \
} }
FUNC(S0, 2, 13, 22) FUNC(S0, 2, 13, 22)
@ -103,8 +103,8 @@ static constexpr \
uint32_t \ uint32_t \
NAME (uint32_t x) \ NAME (uint32_t x) \
{ \ { \
return util::rotater (x, (r0)) ^ \ return cruft::rotater (x, (r0)) ^ \
util::rotater (x, (r1)) ^ \ cruft::rotater (x, (r1)) ^ \
(x >> (s)); \ (x >> (s)); \
} }
@ -176,7 +176,7 @@ H_512[] = {
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
SHA256::digest_t SHA256::digest_t
SHA256::operator() (util::view<const uint8_t*> data) noexcept SHA256::operator() (cruft::view<const uint8_t*> data) noexcept
{ {
(void)K_80; (void)K_80;
(void)H_224; (void)H_224;
@ -266,7 +266,7 @@ SHA256::process (void)
// Initialise the message schedule, W // Initialise the message schedule, W
uint32_t W[64]; uint32_t W[64];
std::transform (M.begin (), M.end (), std::begin (W), util::ntoh<uint32_t>); std::transform (M.begin (), M.end (), std::begin (W), cruft::ntoh<uint32_t>);
for (size_t i = 16; i < 64; ++i) for (size_t i = 16; i < 64; ++i)
W[i] = s1(W[i - 2]) + W[i - 7] + s0 (W[i - 15]) + W[i - 16]; W[i] = s1(W[i - 2]) + W[i - 7] + s0 (W[i - 15]) + W[i - 16];

2
hash/sha2.hpp
View File

@ -23,7 +23,7 @@ namespace cruft::crypto::hash {
typedef std::array<uint8_t,32> digest_t; typedef std::array<uint8_t,32> digest_t;
public: public:
digest_t operator() (util::view<const uint8_t*>) noexcept; digest_t operator() (cruft::view<const uint8_t*>) noexcept;
private: private:
void process (void); void process (void);

4
stream/salsa.cpp
View File

@ -20,7 +20,7 @@ cruft::crypto::stream::salsa20 (const std::array<uint8_t,64> bytes) noexcept
auto y = x; auto y = x;
for (auto &t: x) for (auto &t: x)
t = util::ltoh (t); t = cruft::ltoh (t);
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
x = salsa::doubleround (x); x = salsa::doubleround (x);
@ -29,7 +29,7 @@ cruft::crypto::stream::salsa20 (const std::array<uint8_t,64> bytes) noexcept
x[i] += y[i]; x[i] += y[i];
for (auto &t: x) for (auto &t: x)
t = util::htol (t); t = cruft::htol (t);
return *reinterpret_cast<std::array<uint8_t,64>*> (&x); return *reinterpret_cast<std::array<uint8_t,64>*> (&x);
#pragma GCC diagnostic pop #pragma GCC diagnostic pop

2
stream/salsa.hpp
View File

@ -24,7 +24,7 @@ namespace cruft::crypto::stream::salsa {
uint32_t uint32_t
R (uint32_t a, uint32_t b, uint32_t c, uint32_t k) R (uint32_t a, uint32_t b, uint32_t c, uint32_t k)
{ {
return b ^ util::rotatel (a + c, k); return b ^ cruft::rotatel (a + c, k);
} }

2
test/block/tea.cpp
View File

@ -41,7 +41,7 @@ main ()
}, },
}; };
util::TAP::logger tap; cruft::TAP::logger tap;
for (size_t i = 0; i < std::size (TESTS); ++i) { for (size_t i = 0; i < std::size (TESTS); ++i) {
const auto &t = TESTS[i]; const auto &t = TESTS[i];

2
test/block/xtea.cpp
View File

@ -39,7 +39,7 @@ main ()
}, },
}; };
util::TAP::logger tap; cruft::TAP::logger tap;
for (size_t i = 0; i < std::size (TESTS); ++i) { for (size_t i = 0; i < std::size (TESTS); ++i) {
const auto &t = TESTS[i]; const auto &t = TESTS[i];

2
test/block/xxtea.cpp
View File

@ -94,7 +94,7 @@ main ()
}, },
}; };
util::TAP::logger tap; cruft::TAP::logger tap;
for (size_t i = 0; i < std::size (TESTS); ++i) { for (size_t i = 0; i < std::size (TESTS); ++i) {
const auto &t = TESTS[i]; const auto &t = TESTS[i];

2
test/hash/blake.cpp
View File

@ -161,7 +161,7 @@ static const struct {
int int
main () main ()
{ {
util::TAP::logger tap; cruft::TAP::logger tap;
for (const auto &t: TESTS) { for (const auto &t: TESTS) {
blake<256> h256; blake<256> h256;

2
test/hash/blake2.cpp
View File

@ -119,7 +119,7 @@ static const struct {
int int
main () main ()
{ {
util::TAP::logger tap; cruft::TAP::logger tap;
for (const auto &t: TESTS2b) { for (const auto &t: TESTS2b) {
blake2 h (t.salt); blake2 h (t.salt);

2
test/hash/hmac.cpp
View File

@ -276,7 +276,7 @@ static const struct {
int int
main (int, char**) main (int, char**)
{ {
util::TAP::logger tap; cruft::TAP::logger tap;
for (size_t i = 0; i < std::size (TESTS); ++i) for (size_t i = 0; i < std::size (TESTS); ++i)
tap.expect (TESTS[i].fun (TESTS[i].key, TESTS[i].dat, TESTS[i].res), "standard test vector %zu", i); tap.expect (TESTS[i].fun (TESTS[i].key, TESTS[i].dat, TESTS[i].res), "standard test vector %zu", i);

2
test/hash/hotp.cpp
View File

@ -26,7 +26,7 @@ main (int, char**)
}; };
util::TAP::logger tap; cruft::TAP::logger tap;
for (auto &i: EXPECTED) for (auto &i: EXPECTED)
tap.expect_eq (i, h.value (), "sequence"); tap.expect_eq (i, h.value (), "sequence");

4
test/hash/md2.cpp
View File

@ -48,13 +48,13 @@ main (int, char **) {
const MD2 h; const MD2 h;
for (const auto &i: TESTS) { for (const auto &i: TESTS) {
if (h (util::view{i.input}.cast<const uint8_t*> ()) != i.output) { if (h (cruft::view{i.input}.cast<const uint8_t*> ()) != i.output) {
std::cerr << "Failed on " << i.input << "\n"; std::cerr << "Failed on " << i.input << "\n";
success = false; success = false;
} }
} }
util::TAP::logger tap; cruft::TAP::logger tap;
tap.expect (success, "test vectors"); tap.expect (success, "test vectors");
return tap.status (); return tap.status ();
} }

4
test/hash/md4.cpp
View File

@ -56,13 +56,13 @@ main (int, char**) {
MD4 h; MD4 h;
for (auto i: TESTS) { for (auto i: TESTS) {
if (h (util::view{i.input}.cast <const uint8_t*> ()) != i.output) { if (h (cruft::view{i.input}.cast <const uint8_t*> ()) != i.output) {
std::cerr << "Failed on '" << i.input << "'\n"; std::cerr << "Failed on '" << i.input << "'\n";
success = false; success = false;
} }
} }
util::TAP::logger tap; cruft::TAP::logger tap;
tap.expect (success, "test vectors"); tap.expect (success, "test vectors");
return tap.status (); return tap.status ();
} }

4
test/hash/md5.cpp
View File

@ -65,7 +65,7 @@ main (int, char**) {
} }
}; };
util::TAP::logger tap; cruft::TAP::logger tap;
MD5 h; MD5 h;
for (const auto &t: TESTS) for (const auto &t: TESTS)
@ -84,7 +84,7 @@ main (int, char**) {
for (auto l: { 2, 64, 80}) { for (auto l: { 2, 64, 80}) {
std::vector<uint8_t> data (l); std::vector<uint8_t> data (l);
std::iota (std::begin (data), std::end (data), 0); std::iota (std::begin (data), std::end (data), 0);
util::view root {data}; cruft::view root {data};
const auto &[a,b] = root.split (root.begin () + l / 2); const auto &[a,b] = root.split (root.begin () + l / 2);
tap.expect_eq (h (a,b), h(root), "split data hash equality, %! bytes", l); tap.expect_eq (h (a,b), h(root), "split data hash equality, %! bytes", l);
}; };

2
test/hash/ripemd.cpp
View File

@ -118,7 +118,7 @@ struct {
int int
main(int, char**) { main(int, char**) {
util::TAP::logger tap; cruft::TAP::logger tap;
// Check against simple test vectors // Check against simple test vectors
for (const auto &t: TESTS) { for (const auto &t: TESTS) {

2
test/hash/sha1.cpp
View File

@ -27,7 +27,7 @@ operator"" _u8s (const char *str, size_t len)
int int
main (int, char**) main (int, char**)
{ {
util::TAP::logger tap; cruft::TAP::logger tap;
static const struct { static const struct {
const char *msg; const char *msg;

4
test/hash/sha2.cpp
View File

@ -52,11 +52,11 @@ static const struct {
int int
main (int, char **) { main (int, char **) {
util::TAP::logger tap; cruft::TAP::logger tap;
for (const auto &i: TESTS) { for (const auto &i: TESTS) {
SHA256 obj; SHA256 obj;
tap.expect_eq (obj (util::view{i.input}.cast<const uint8_t*> ()), i.output, "%s", i.msg); tap.expect_eq (obj (cruft::view{i.input}.cast<const uint8_t*> ()), i.output, "%s", i.msg);
} }
return tap.status (); return tap.status ();

2
test/stream/rc4.cpp
View File

@ -12,7 +12,7 @@ using cruft::crypto::stream::RC4;
int int
main () main ()
{ {
util::TAP::logger tap; cruft::TAP::logger tap;
// Test vectors from RFC 6229. // Test vectors from RFC 6229.
static const size_t OFFSETS[] = { static const size_t OFFSETS[] = {

12
test/stream/salsa.cpp
View File

@ -5,7 +5,7 @@
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
void void
test_quarter (util::TAP::logger &tap) test_quarter (cruft::TAP::logger &tap)
{ {
static const struct { static const struct {
std::array<uint32_t, 4> a, b; std::array<uint32_t, 4> a, b;
@ -37,7 +37,7 @@ test_quarter (util::TAP::logger &tap)
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
void void
test_row (util::TAP::logger &tap) test_row (cruft::TAP::logger &tap)
{ {
static const struct { static const struct {
std::array<uint32_t, 16> a, b; std::array<uint32_t, 16> a, b;
@ -73,7 +73,7 @@ test_row (util::TAP::logger &tap)
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
void void
test_col (util::TAP::logger &tap) test_col (cruft::TAP::logger &tap)
{ {
static const struct { static const struct {
std::array<uint32_t,16> a, b; std::array<uint32_t,16> a, b;
@ -107,7 +107,7 @@ test_col (util::TAP::logger &tap)
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
void void
test_doubleround (util::TAP::logger &tap) test_doubleround (cruft::TAP::logger &tap)
{ {
static const struct { static const struct {
std::array<uint32_t,16> a, b; std::array<uint32_t,16> a, b;
@ -141,7 +141,7 @@ test_doubleround (util::TAP::logger &tap)
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
void void
test_salsa20 (util::TAP::logger &tap) test_salsa20 (cruft::TAP::logger &tap)
{ {
static const struct { static const struct {
std::array<uint8_t,64> a, b; std::array<uint8_t,64> a, b;
@ -237,7 +237,7 @@ test_salsa20 (util::TAP::logger &tap)
int int
main (void) main (void)
{ {
util::TAP::logger tap; cruft::TAP::logger tap;
test_quarter (tap); test_quarter (tap);
test_row (tap); test_row (tap);

10
tools/hash.cpp
View File

@ -53,7 +53,7 @@ template <size_t S>
std::ostream& std::ostream&
print_digest (std::ostream &os, std::array<uint8_t,S> digest) print_digest (std::ostream &os, std::array<uint8_t,S> digest)
{ {
util::stream::scoped::flags f (os); cruft::stream::scoped::flags f (os);
os << std::hex; os << std::hex;
for (auto c: digest) for (auto c: digest)
@ -65,7 +65,7 @@ print_digest (std::ostream &os, std::array<uint8_t,S> digest)
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
static void static void
compute (const std::string &name, const util::view<const uint8_t*> data) compute (const std::string &name, const cruft::view<const uint8_t*> data)
{ {
#define stream(TYPE, ...) do { \ #define stream(TYPE, ...) do { \
if (name != #TYPE) \ if (name != #TYPE) \
@ -73,7 +73,7 @@ compute (const std::string &name, const util::view<const uint8_t*> data)
\ \
print_digest ( \ print_digest ( \
std::cout, \ std::cout, \
util::hash::TYPE{} (data) \ cruft::hash::TYPE{} (data) \
) << '\n'; \ ) << '\n'; \
return; \ return; \
} while (0); } while (0);
@ -126,8 +126,8 @@ main (int argc, char **argv)
} }
if (strcmp (argv[ARG_INPUT], "-")) { if (strcmp (argv[ARG_INPUT], "-")) {
const util::mapped_file src (argv[ARG_INPUT]); const cruft::mapped_file src (argv[ARG_INPUT]);
compute (argv[ARG_HASH], util::view{src}); compute (argv[ARG_HASH], cruft::view{src});
return EXIT_SUCCESS; return EXIT_SUCCESS;
} else { } else {