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

block: use src _and_ dest views for encyption/decryption

Browse Source
This commit is contained in:
Danny Robson 2018-12-02 14:20:16 +11:00
parent 38e8aa70d6
commit 5509999f44
9 changed files with 146 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
block/tea.cpp
View File

@ -15,11 +15,10 @@ using cruft::crypto::block::TEA;
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
static const u32 MAGIC = 0x9E3779B9; static u32 constexpr MAGIC = 0x9E3779B9;
// each iteration performs two feistel rounds, for a total of 64 static int constexpr ITERATIONS = 64;
static const unsigned ITERATIONS = 32;
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
@ -30,47 +29,52 @@ TEA::TEA (key_t _key)
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
void void
TEA::encrypt (cruft::view<word_t*> data) TEA::encrypt (cruft::view<word_t*> dst, cruft::view<word_t const*> src)
{ {
if (data.size () % 2) if (dst.size () != src.size ())
throw std::invalid_argument ("mismatching encode/decode buffer sizes");
if (src.size () % 2)
throw std::invalid_argument ("TEA requires even data count"); throw std::invalid_argument ("TEA requires even data count");
for (auto cursor = data.begin (), last = data.end (); cursor < last; ) { for (size_t i = 0, last = src.size (); i < last; i += 2) {
word_t sum = 0; word_t sum = 0;
word_t v0 = cursor[0]; word_t v0 = src[i + 0];
word_t v1 = cursor[1]; word_t v1 = src[i + 1];
for (unsigned i = 0; i < ITERATIONS; ++i) { for (int j = 0; j < ITERATIONS; j += 2) {
sum += MAGIC; sum += MAGIC;
v0 += ((v1 << 4) + m_key[0]) ^ (v1 + sum) ^ ((v1 >> 5) + m_key[1]); v0 += ((v1 << 4) + m_key[0]) ^ (v1 + sum) ^ ((v1 >> 5) + m_key[1]);
v1 += ((v0 << 4) + m_key[2]) ^ (v0 + sum) ^ ((v0 >> 5) + m_key[3]); v1 += ((v0 << 4) + m_key[2]) ^ (v0 + sum) ^ ((v0 >> 5) + m_key[3]);
} }
*cursor++ = v0; dst[i + 0] = v0;
*cursor++ = v1; dst[i + 1] = v1;
} }
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void void
TEA::decrypt (cruft::view<word_t*> data) TEA::decrypt (cruft::view<word_t*> dst, cruft::view<word_t const*> src)
{ {
if (data.size () % 2) if (dst.size () != src.size ())
throw std::invalid_argument ("mismatching encode/decode buffer sizes");
if (src.size () % 2)
throw std::invalid_argument ("TEA requires even data count"); throw std::invalid_argument ("TEA requires even data count");
for (auto cursor = data.begin (), last = data.end (); cursor < last; ) { for (size_t i = 0, last = src.size (); i < last; i += 2) {
word_t sum = MAGIC << 5; word_t sum = MAGIC << 5;
word_t v0 = cursor[0]; word_t v0 = src[i + 0];
word_t v1 = cursor[1]; word_t v1 = src[i + 1];
for (unsigned i = 0; i < ITERATIONS; ++i) { for (int j = 0; j < ITERATIONS; j += 2) {
v1 -= ((v0 << 4) + m_key[2]) ^ (v0 + sum) ^ ((v0 >> 5) + m_key[3]); v1 -= ((v0 << 4) + m_key[2]) ^ (v0 + sum) ^ ((v0 >> 5) + m_key[3]);
v0 -= ((v1 << 4) + m_key[0]) ^ (v1 + sum) ^ ((v1 >> 5) + m_key[1]); v0 -= ((v1 << 4) + m_key[0]) ^ (v1 + sum) ^ ((v1 >> 5) + m_key[1]);
sum -= MAGIC; sum -= MAGIC;
} }
*cursor++ = v0; dst[i + 0] = v0;
*cursor++ = v1; dst[i + 1] = v1;
} }
} }

21
block/tea.hpp
View File

@ -24,11 +24,28 @@ namespace cruft::crypto::block {
public: public:
using key_t = std::array<u32,4>; using key_t = std::array<u32,4>;
using word_t = u32; using word_t = u32;
static constexpr std::size_t block_size = sizeof (word_t) * 2;
explicit TEA (key_t); explicit TEA (key_t);
void encrypt (cruft::view<word_t*> data); /// Encrypt the contents of `src` into the buffer `dst`.
void decrypt (cruft::view<word_t*> data); ///
/// src and dst are assumed to be equal sizes, multiples of block_size
/// bytes, and suitably aligned for SIMD.
///
/// \param dst The location of the output
/// \param src The location of the input
void encrypt (cruft::view<word_t*> dst, cruft::view<word_t const*> src);
/// Decrypt the contents of `src` into the buffer `dst`.
///
/// src and dst are assumed to be equal sizes, multiples of block_size
/// bytes, and suitably aligned for SIMD.
///
/// \param dst The location of the output
/// \param src The location of the input
void decrypt (cruft::view<word_t*> dst, cruft::view<word_t const*> src);
private: private:
key_t const m_key; key_t const m_key;

38
block/xtea.cpp
View File

@ -12,7 +12,7 @@ using cruft::crypto::block::XTEA;
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
static const u32 MAGIC = 0x9E3779B9; static const uint32_t MAGIC = 0x9E3779B9;
// each iteration performs two feistel rounds, for a total of 64 // each iteration performs two feistel rounds, for a total of 64
static const unsigned ITERATIONS = 32; static const unsigned ITERATIONS = 32;
@ -26,47 +26,51 @@ XTEA::XTEA (key_t _key):
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void void
XTEA::encrypt (cruft::view<word_t*> data) XTEA::encrypt (cruft::view<word_t*> dst, cruft::view<word_t const*> src)
{ {
if (data.size () % 2) if (dst.size () != src.size ())
throw std::invalid_argument ("mismatching encode/decode buffer sizes");
if (src.size () % 2)
throw std::invalid_argument ("XTEA requires even data count"); throw std::invalid_argument ("XTEA requires even data count");
for (auto cursor = data.begin (), last = data.end (); cursor < last; ) { for (size_t i = 0, last = src.size (); i != last; i += 2) {
uint32_t sum = 0; uint32_t sum = 0;
uint32_t v0 = cursor[0]; uint32_t v0 = src[i + 0];
uint32_t v1 = cursor[1]; uint32_t v1 = src[i + 1];
for (unsigned i = 0; i < ITERATIONS; ++i) { for (unsigned j = 0; j < ITERATIONS; ++j) {
v0 += (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + m_key[sum & 3]); v0 += (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + m_key[sum & 3]);
sum += MAGIC; sum += MAGIC;
v1 += (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + m_key[(sum >> 11) & 3]); v1 += (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + m_key[(sum >> 11) & 3]);
} }
*cursor++ = v0; dst[i + 0] = v0;
*cursor++ = v1; dst[i + 1] = v1;
} }
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void void
XTEA::decrypt (cruft::view<word_t*> data) XTEA::decrypt (cruft::view<word_t*> dst, cruft::view<word_t const*> src)
{ {
if (data.size () % 2) if (dst.size () != src.size ())
throw std::invalid_argument ("mismatching encode/decode buffer sizes");
if (src.size () % 2)
throw std::invalid_argument ("XTEA requires even data count"); throw std::invalid_argument ("XTEA requires even data count");
for (auto cursor = data.begin (), last = data.end (); cursor < last; ) { for (size_t i = 0, last = src.size (); i != last; i += 2) {
uint32_t sum = ITERATIONS * MAGIC; uint32_t sum = ITERATIONS * MAGIC;
uint32_t v0 = cursor[0]; uint32_t v0 = src[i + 0];
uint32_t v1 = cursor[1]; uint32_t v1 = src[i + 1];
for (unsigned i = 0; i < ITERATIONS; ++i) { for (unsigned j = 0; j < ITERATIONS; ++j) {
v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + m_key[(sum >> 11) & 3]); v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + m_key[(sum >> 11) & 3]);
sum -= MAGIC; sum -= MAGIC;
v0 -= (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + m_key[sum & 3]); v0 -= (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + m_key[sum & 3]);
} }
*cursor++ = v0; dst[i + 0] = v0;
*cursor++ = v1; dst[i + 1] = v1;
} }
} }

23
block/xtea.hpp
View File

@ -24,13 +24,30 @@ namespace cruft::crypto::block {
public: public:
using key_t = std::array<u32,4>; using key_t = std::array<u32,4>;
using word_t = u32; using word_t = u32;
static constexpr std::size_t block_size = sizeof (word_t) * 2;
explicit XTEA (key_t); explicit XTEA (key_t);
void encrypt (cruft::view<word_t*> data); /// Encrypt the contents of `src` into the buffer `dst`.
void decrypt (cruft::view<word_t*> data); ///
/// src and dst are assumed to be equal sizes, multiples of block_size
/// bytes, and suitably aligned for SIMD.
///
/// \param dst The location of the output
/// \param src The location of the input
void encrypt (cruft::view<word_t*> dst, cruft::view<word_t const*> src);
/// Decrypt the contents of `src` into the buffer `dst`.
///
/// src and dst are assumed to be equal sizes, multiples of block_size
/// bytes, and suitably aligned for SIMD.
///
/// \param dst The location of the output
/// \param src The location of the input
void decrypt (cruft::view<word_t*> dst, cruft::view<word_t const*> src);
private: private:
key_t m_key; key_t const m_key;
}; };
} }

46
block/xxtea.cpp
View File

@ -15,7 +15,7 @@
using cruft::crypto::block::XXTEA; using cruft::crypto::block::XXTEA;
//----------------------------------------------------------------------------- ///////////////////////////////////////////////////////////////////////////////
static const u32 MAGIC = 0x9E3779B9; static const u32 MAGIC = 0x9E3779B9;
@ -33,22 +33,26 @@ mix (u32 Z,
} }
//----------------------------------------------------------------------------- ///////////////////////////////////////////////////////////////////////////////
XXTEA::XXTEA (key_t _key): XXTEA::XXTEA (key_t _key):
m_key (_key) m_key (_key)
{ ; } { ; }
//----------------------------------------------------------------------------- ///////////////////////////////////////////////////////////////////////////////
void void
XXTEA::encrypt (cruft::view<word_t*> data) XXTEA::encrypt (cruft::view<word_t*> dst, cruft::view<word_t const*> src)
{ {
if (data.size () < 2) if (dst.size () != src.size ())
throw std::invalid_argument ("mismatching encode/decode buffer sizes");
if (src.size () < 2)
throw std::invalid_argument ("minimum blocksize is 64 bits"); throw std::invalid_argument ("minimum blocksize is 64 bits");
auto const count = data.size (); std::copy (src.begin (), src.end (), dst.begin ());
auto const count = src.size ();
uint32_t sum = 0; uint32_t sum = 0;
uint32_t z = data[count - 1]; uint32_t z = dst[count - 1];
uint32_t y, p; uint32_t y, p;
unsigned rounds = 6 + 52 / count; unsigned rounds = 6 + 52 / count;
@ -58,42 +62,46 @@ XXTEA::encrypt (cruft::view<word_t*> data)
uint32_t e = (sum >> 2) & 3; uint32_t e = (sum >> 2) & 3;
for (p = 0; p < count - 1; p++) { for (p = 0; p < count - 1; p++) {
y = data[p + 1]; y = dst[p + 1];
z = data[p] += ::mix (z, y, sum, e, p, m_key.data ()); z = dst[p ] += ::mix (z, y, sum, e, p, m_key.data ());
} }
y = data[0]; y = dst[0];
z = data[count - 1] += ::mix (z, y, sum, e, p, m_key.data ()); z = dst[count - 1] += ::mix (z, y, sum, e, p, m_key.data ());
} while (--rounds); } while (--rounds);
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void void
XXTEA::decrypt (cruft::view<word_t*> data) XXTEA::decrypt (cruft::view<word_t*> dst, cruft::view<word_t const*> src)
{ {
if (data.size () < 2) if (dst.size () != src.size ())
throw std::invalid_argument ("mismatching encode/decode buffer sizes");
if (src.size () < 2)
throw std::invalid_argument ("minimum blocksize is 64 bits"); throw std::invalid_argument ("minimum blocksize is 64 bits");
auto const count = data.size (); std::copy (src.begin (), src.end (), dst.begin ());
auto const count = src.size ();
uint32_t y, z, sum; uint32_t y, z, sum;
uint32_t rounds; uint32_t rounds;
size_t p; size_t p;
rounds = 6 + 52 / count; rounds = 6 + 52 / count;
sum = rounds * MAGIC; sum = rounds * MAGIC;
y = data[0]; y = dst[0];
do { do {
uint32_t e = (sum >> 2) & 3; uint32_t e = (sum >> 2) & 3;
for (p = count - 1; p > 0; p--) { for (p = count - 1; p > 0; p--) {
z = data[p - 1]; z = dst[p - 1];
y = data[p ] -= ::mix (z, y, sum, e, p, m_key.data ()); y = dst[p ] -= ::mix (z, y, sum, e, p, m_key.data ());
} }
z = data[count - 1]; z = dst[count - 1];
y = data[ 0] -= ::mix (z, y, sum, e, p, m_key.data ()); y = dst[ 0] -= ::mix (z, y, sum, e, p, m_key.data ());
sum -= MAGIC; sum -= MAGIC;
} while (--rounds); } while (--rounds);

23
block/xxtea.hpp
View File

@ -24,13 +24,30 @@ namespace cruft::crypto::block {
public: public:
using key_t = std::array<u32,4>; using key_t = std::array<u32,4>;
using word_t = u32; using word_t = u32;
static constexpr std::size_t block_size = sizeof (word_t) * 2;
explicit XXTEA (key_t); explicit XXTEA (key_t);
void encrypt (cruft::view<word_t*> data); /// Encrypt the contents of `src` into the buffer `dst`.
void decrypt (cruft::view<word_t*> data); ///
/// src and dst are assumed to be equal sizes, multiples of block_size
/// bytes, and suitably aligned for SIMD.
///
/// \param dst The location of the output
/// \param src The location of the input
void encrypt (cruft::view<word_t*> dst, cruft::view<word_t const*> src);
/// Decrypt the contents of `src` into the buffer `dst`.
///
/// src and dst are assumed to be equal sizes, multiples of block_size
/// bytes, and suitably aligned for SIMD.
///
/// \param dst The location of the output
/// \param src The location of the input
void decrypt (cruft::view<word_t*> dst, cruft::view<word_t const*> src);
private: private:
key_t m_key; key_t const m_key;
}; };
} }

8
test/block/tea.cpp
View File

@ -47,11 +47,11 @@ main ()
const auto &t = TESTS[i]; const auto &t = TESTS[i];
TEA gen (t.key); TEA gen (t.key);
std::array<uint32_t,2> enc (t.dec); std::array<uint32_t,2> enc;
gen.encrypt (cruft::view (enc)); gen.encrypt (cruft::view (enc), cruft::view (t.dec));
std::array<uint32_t,2> dec (t.enc); std::array<uint32_t,2> dec;
gen.decrypt (cruft::view (dec)); gen.decrypt (cruft::view (dec), cruft::view (t.enc));
tap.expect (enc == t.enc, "TEA_enc %zu", i); tap.expect (enc == t.enc, "TEA_enc %zu", i);
tap.expect (dec == t.dec, "TEA_dec %zu", i); tap.expect (dec == t.dec, "TEA_dec %zu", i);

12
test/block/xtea.cpp
View File

@ -45,14 +45,14 @@ main ()
const auto &t = TESTS[i]; const auto &t = TESTS[i];
cruft::crypto::block::XTEA gen (t.key); cruft::crypto::block::XTEA gen (t.key);
std::array<uint32_t,2> enc (t.dec); std::array<uint32_t,2> enc_result;
gen.encrypt (cruft::view (enc)); gen.encrypt (cruft::view (enc_result), cruft::view (t.dec));
std::array<uint32_t,2> dec (t.enc); std::array<uint32_t,2> dec_result;
gen.decrypt (cruft::view (dec)); gen.decrypt (cruft::view (dec_result), cruft::view (enc_result));
tap.expect (enc == t.enc, "XTEA_enc %zu", i); tap.expect (enc_result == t.enc, "XTEA_enc %zu", i);
tap.expect (dec == t.dec, "XTEA_dec %zu", i); tap.expect (dec_result == t.dec, "XTEA_dec %zu", i);
} }
return tap.status (); return tap.status ();

12
test/block/xxtea.cpp
View File

@ -103,14 +103,14 @@ main ()
XXTEA gen (t.key); XXTEA gen (t.key);
std::vector<uint32_t> enc (t.dec); std::vector<uint32_t> enc_result (t.dec.size ());
gen.encrypt (cruft::view (enc)); gen.encrypt (cruft::view (enc_result), cruft::view (t.dec));
std::vector<uint32_t> dec (enc); std::vector<uint32_t> dec_result (t.enc.size ());
gen.decrypt (cruft::view (dec)); gen.decrypt (cruft::view (dec_result), cruft::view (t.enc));
tap.expect (enc == t.enc, "XXTEA_enc %zu", i); tap.expect (enc_result == t.enc, "XXTEA_enc %zu", i);
tap.expect (dec == t.dec, "XXTEA_dec %zu", i); tap.expect (dec_result == t.dec, "XXTEA_dec %zu", i);
} }
return tap.status (); return tap.status ();