nerdcruft/libcruft-util
1
0
Fork 0
Code Issues Releases Activity

Add MD2 implementation

Browse Source
This commit is contained in:
Danny Robson 2013-03-11 20:42:49 +11:00
parent 990d5ab806
commit 8df03fae81
6 changed files with 285 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile.am
View File

@ -42,6 +42,8 @@ UTIL_FILES = \
guid.hpp \ guid.hpp \
hash.cpp \ hash.cpp \
hash.hpp \ hash.hpp \
hash/md2.cpp \
hash/md2.hpp \
image.cpp \ image.cpp \
image.hpp \ image.hpp \
io.cpp \ io.cpp \

164
hash/md2.cpp Normal file
View File

@ -0,0 +1,164 @@
/*
* This file is part of libgim.
*
* libgim is free software: you can redistribute it and/or modify it under the
* terms of the GNU General Public License as published by the Free Software
* Foundation, either version 3 of the License, or (at your option) any later
* version.
*
* libgim 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 General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License
* along with libgim. If not, see <http://www.gnu.org/licenses/>.
*
* Copyright 2013 Danny Robson <danny@nerdcruft.net>
*/
#include "md2.hpp"
#include "types.hpp"
#include <array>
#include <algorithm>
#include <cstring>
using util::hash::MD2;
using std::array;
using std::begin;
using std::end;
using std::fill;
static array<uint8_t,256> S = { {
41, 46, 67, 201, 162, 216, 124, 1, 61, 54, 84, 161, 236, 240, 6, 19,
98, 167, 5, 243, 192, 199, 115, 140, 152, 147, 43, 217, 188, 76, 130, 202,
30, 155, 87, 60, 253, 212, 224, 22, 103, 66, 111, 24, 138, 23, 229, 18,
190, 78, 196, 214, 218, 158, 222, 73, 160, 251, 245, 142, 187, 47, 238, 122,
169, 104, 121, 145, 21, 178, 7, 63, 148, 194, 16, 137, 11, 34, 95, 33,
128, 127, 93, 154, 90, 144, 50, 39, 53, 62, 204, 231, 191, 247, 151, 3,
255, 25, 48, 179, 72, 165, 181, 209, 215, 94, 146, 42, 172, 86, 170, 198,
79, 184, 56, 210, 150, 164, 125, 182, 118, 252, 107, 226, 156, 116, 4, 241,
69, 157, 112, 89, 100, 113, 135, 32, 134, 91, 207, 101, 230, 45, 168, 2,
27, 96, 37, 173, 174, 176, 185, 246, 28, 70, 97, 105, 52, 64, 126, 15,
85, 71, 163, 35, 221, 81, 175, 58, 195, 92, 249, 206, 186, 197, 234, 38,
44, 83, 13, 110, 133, 40, 132, 9, 211, 223, 205, 244, 65, 129, 77, 82,
106, 220, 55, 200, 108, 193, 171, 250, 36, 225, 123, 8, 12, 189, 177, 74,
120, 136, 149, 139, 227, 99, 232, 109, 233, 203, 213, 254, 59, 0, 29, 57,
242, 239, 183, 14, 102, 88, 208, 228, 166, 119, 114, 248, 235, 117, 75, 10,
49, 68, 80, 180, 143, 237, 31, 26, 219, 153, 141, 51, 159, 17, 131, 20,
} };
MD2::MD2 ()
{
reset ();
}
void
MD2::reset (void) {
m_total = 0;
fill (begin (C), end (C), 0);
fill (begin (X), end (X), 0);
}
void
MD2::update (const void *data, size_t size)
{ update (static_cast<const uint8_t*> (data), size); }
static const size_t M_OFFSET = 16;
static const size_t M_LENGTH = 16;
void
MD2::update (const uint8_t *data, size_t size) {
uint8_t *M = X + M_OFFSET;
size_t offset = m_total % M_LENGTH;
size_t remain = M_LENGTH - offset;
if (size > remain) {
memcpy (M + offset, data, remain);
transform ();
m_total += remain;
size -= remain;
data += remain;
while (size >= M_LENGTH) {
memcpy (M, data, M_LENGTH);
transform ();
m_total += M_LENGTH;
size -= M_LENGTH;
data += M_LENGTH;
}
offset = 0;
}
memcpy (M + offset, data, size);
m_total += size;
}
MD2::digest_t
MD2::digest (void) {
finish ();
digest_t d;
memcpy (d.data (), X, sizeof (d));
return d;
}
void
MD2::transform (void) {
uint8_t *M = X + M_OFFSET;
// Update the checksum.
// XXX: I can't see why we need the xor-assign from the spec, but it's the
// only change keeping us from conforming to the test-cases. Pulled from a
// review of the reference implementation.
uint8_t L = C[15];
for (size_t i = 0; i < elems (C); ++i)
L = C[i] ^= S[M[i] ^ L];
uint8_t t = 0;
// Setup the blocks
for (size_t i = 0; i < 16; ++i)
X[32 + i] = X[16 + i] ^ X[i];
// Perform the processing rounds
for (size_t i = 0; i < 18; ++i) {
for (size_t j = 0; j < 48; ++j)
t = X[j] = X[j] ^ S[t];
t = (t + i) % 256;
}
}
void
MD2::finish (void) {
uint8_t *M = X + M_OFFSET;
// Append the padding bytes
size_t offset = m_total % M_LENGTH;
size_t remain = M_LENGTH - offset;
for (size_t i = 0; i < remain; ++i)
M[offset + i] = remain;
transform ();
// Append the checksum
memcpy (M, C, sizeof (C));
transform ();
}

55
hash/md2.hpp Normal file
View File

@ -0,0 +1,55 @@
/*
* This file is part of libgim.
*
* libgim is free software: you can redistribute it and/or modify it under the
* terms of the GNU General Public License as published by the Free Software
* Foundation, either version 3 of the License, or (at your option) any later
* version.
*
* libgim 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 General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License
* along with libgim. If not, see <http://www.gnu.org/licenses/>.
*
* Copyright 2013 Danny Robson <danny@nerdcruft.net>
*/
#ifndef __UTIL_HASH_MD2_HPP
#define __UTIL_HASH_MD2_HPP
#include <array>
#include <cstdint>
namespace util {
namespace hash {
class MD2 {
public:
typedef std::array<uint8_t,16> digest_t;
public:
MD2 ();
void update (const uint8_t *data, size_t len);
void update (const void *data, size_t len);
digest_t digest (void);
void reset (void);
private:
void transform (void);
void finish (void);
uint64_t m_total;
uint8_t C[16];
uint8_t X[48];
};
}
}
#endif

1
test/.gitignore vendored
View File

@ -10,6 +10,7 @@
/*.log /*.log
/maths* /maths*
/matrix* /matrix*
/md2*
/option /option
/pool* /pool*
/range* /range*

4
test/Makefile.am
View File

@ -17,6 +17,7 @@ TEST_BIN = \
json \ json \
maths \ maths \
matrix \ matrix \
md2 \
option \ option \
pool \ pool \
range \ range \
@ -56,6 +57,9 @@ maths_SOURCES = maths.cpp
matrix_LDADD = $(builddir)/../libutil.la matrix_LDADD = $(builddir)/../libutil.la
matrix_SOURCES = matrix.cpp matrix_SOURCES = matrix.cpp
md2_LDADD = $(builddir)/../libutil.la
md2_SOURCES = md2.cpp
option_LDADD = $(builddir)/../libutil.la option_LDADD = $(builddir)/../libutil.la
option_SOURCES = options/success.cpp option_SOURCES = options/success.cpp

59
test/md2.cpp Normal file
View File

@ -0,0 +1,59 @@
#include "../hash/md2.hpp"
using util::hash::MD2;
#include <cstring>
#include <iostream>
int
main (int, char **) {
static const struct {
const char *input;
MD2::digest_t output;
} TESTS[] = {
{ "",
{ { 0x83, 0x50, 0xe5, 0xa3, 0xe2, 0x4c, 0x15, 0x3d,
0xf2, 0x27, 0x5c, 0x9f, 0x80, 0x69, 0x27, 0x73 } }
},
{ "a",
{ { 0x32, 0xec, 0x01, 0xec, 0x4a, 0x6d, 0xac, 0x72,
0xc0, 0xab, 0x96, 0xfb, 0x34, 0xc0, 0xb5, 0xd1 } }
},
{ "abc",
{ { 0xda, 0x85, 0x3b, 0x0d, 0x3f, 0x88, 0xd9, 0x9b,
0x30, 0x28, 0x3a, 0x69, 0xe6, 0xde, 0xd6, 0xbb } }
},
{ "message digest",
{ { 0xab, 0x4f, 0x49, 0x6b, 0xfb, 0x2a, 0x53, 0x0b,
0x21, 0x9f, 0xf3, 0x30, 0x31, 0xfe, 0x06, 0xb0 } }
},
{ "abcdefghijklmnopqrstuvwxyz",
{ { 0x4e, 0x8d, 0xdf, 0xf3, 0x65, 0x02, 0x92, 0xab,
0x5a, 0x41, 0x08, 0xc3, 0xaa, 0x47, 0x94, 0x0b } }
},
{ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
{ { 0xda, 0x33, 0xde, 0xf2, 0xa4, 0x2d, 0xf1, 0x39,
0x75, 0x35, 0x28, 0x46, 0xc3, 0x03, 0x38, 0xcd } }
},
{ "12345678901234567890123456789012345678901234567890123456789012345678901234567890",
{ { 0xd5, 0x97, 0x6f, 0x79, 0xd8, 0x3d, 0x3a, 0x0d,
0xc9, 0x80, 0x6c, 0x3c, 0x66, 0xf3, 0xef, 0xd8 } }
}
};
bool success = true;
for (const auto &i: TESTS) {
MD2 h;
h.update (i.input, strlen (i.input));
auto out = h.digest ();
if (out != i.output) {
std::cerr << "Failed on " << i.input << "\n";
success = false;
}
}
return success ? 0 : 1;
}