From 3b1fcbe825c90dcb5e358ad7632b45d4cd512f54 Mon Sep 17 00:00:00 2001 From: Vincent Richard Date: Tue, 6 Sep 2005 20:08:39 +0000 Subject: New namespace for message digest algorithms. --- src/exception.cpp | 12 + src/net/authHelper.cpp | 30 ++- src/net/pop3/POP3Store.cpp | 11 +- src/security/digest/md5/md5MessageDigest.cpp | 342 +++++++++++++++++++++++++ src/security/digest/messageDigest.cpp | 53 ++++ src/security/digest/messageDigestFactory.cpp | 80 ++++++ src/security/digest/sha1/sha1MessageDigest.cpp | 262 +++++++++++++++++++ src/utility/md5.cpp | 331 ------------------------ 8 files changed, 775 insertions(+), 346 deletions(-) create mode 100644 src/security/digest/md5/md5MessageDigest.cpp create mode 100644 src/security/digest/messageDigest.cpp create mode 100644 src/security/digest/messageDigestFactory.cpp create mode 100644 src/security/digest/sha1/sha1MessageDigest.cpp delete mode 100644 src/utility/md5.cpp (limited to 'src') diff --git a/src/exception.cpp b/src/exception.cpp index a8479b82..7482482a 100644 --- a/src/exception.cpp +++ b/src/exception.cpp @@ -120,6 +120,18 @@ exception* no_encoder_available::clone() const { return new no_encoder_available const char* no_encoder_available::name() const throw() { return "no_encoder_available"; } +// +// no_digest_algorithm_available +// + +no_digest_algorithm_available::~no_digest_algorithm_available() throw() {} +no_digest_algorithm_available::no_digest_algorithm_available(const string& name, const exception& other) + : exception("No algorithm available: '" + name + "'.", other) {} + +exception* no_digest_algorithm_available::clone() const { return new no_digest_algorithm_available(*this); } +const char* no_digest_algorithm_available::name() const throw() { return "no_digest_algorithm_available"; } + + // // no_such_parameter // diff --git a/src/net/authHelper.cpp b/src/net/authHelper.cpp index e10b47ee..a946e6f1 100644 --- a/src/net/authHelper.cpp +++ b/src/net/authHelper.cpp @@ -20,7 +20,7 @@ #include "vmime/net/authHelper.hpp" #include "vmime/config.hpp" -#include "vmime/utility/md5.hpp" +#include "vmime/security/digest/messageDigestFactory.hpp" namespace vmime { @@ -42,13 +42,17 @@ void hmac_md5(const string& text, const string& key, string& hexDigest) unsigned char tkey[16]; int tkeyLen; + ref md5 = + security::digest::messageDigestFactory::getInstance()->create("md5"); + // If key is longer than 64 bytes reset it to key = MD5(key) if (key.length() > 64) { - utility::md5 keyMD5; - keyMD5.update(reinterpret_cast (key.data()), key.length()); + md5->reset(); + md5->update(reinterpret_cast (key.data()), key.length()); + md5->finalize(); - std::copy(keyMD5.hash(), keyMD5.hash() + 16, tkey); + std::copy(md5->getDigest(), md5->getDigest() + 16, tkey); tkeyLen = 16; } else @@ -84,20 +88,22 @@ void hmac_md5(const string& text, const string& key, string& hexDigest) } // Perform inner MD5 - utility::md5 innerMD5; - innerMD5.update(ipad, 64); - innerMD5.update(text); + md5->reset(); + md5->update(ipad, 64); + md5->update(text); + md5->finalize(); - std::copy(innerMD5.hash(), innerMD5.hash() + 16, digest); + std::copy(md5->getDigest(), md5->getDigest() + 16, digest); // Perform outer MD5 - utility::md5 outerMD5; - outerMD5.update(opad, 64); - outerMD5.update(digest, 16); + md5->reset(); + md5->update(opad, 64); + md5->update(digest, 16); + md5->finalize(); //std::copy(outerMD5.hash(), outerMD5.hash() + 16, digest); - hexDigest = outerMD5.hex(); + hexDigest = md5->getHexDigest(); } diff --git a/src/net/pop3/POP3Store.cpp b/src/net/pop3/POP3Store.cpp index 9ccfa7b7..5041d2d3 100644 --- a/src/net/pop3/POP3Store.cpp +++ b/src/net/pop3/POP3Store.cpp @@ -23,7 +23,7 @@ #include "vmime/exception.hpp" #include "vmime/platformDependant.hpp" #include "vmime/messageId.hpp" -#include "vmime/utility/md5.hpp" +#include "vmime/security/digest/messageDigestFactory.hpp" #include "vmime/utility/filteredStream.hpp" #include @@ -145,8 +145,13 @@ void POP3Store::connect() if (mid.getLeft().length() && mid.getRight().length()) { // is the result of MD5 applied to "password" - sendRequest("APOP " + auth.getUsername() + " " - + utility::md5(mid.generate() + auth.getPassword()).hex()); + ref md5 = + security::digest::messageDigestFactory::getInstance()->create("md5"); + + md5->update(mid.generate() + auth.getPassword()); + md5->finalize(); + + sendRequest("APOP " + auth.getUsername() + " " + md5->getHexDigest()); readResponse(response, false); if (isSuccessResponse(response)) diff --git a/src/security/digest/md5/md5MessageDigest.cpp b/src/security/digest/md5/md5MessageDigest.cpp new file mode 100644 index 00000000..d5fa036c --- /dev/null +++ b/src/security/digest/md5/md5MessageDigest.cpp @@ -0,0 +1,342 @@ +// +// VMime library (http://www.vmime.org) +// Copyright (C) 2002-2005 Vincent Richard +// +// This program 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 2 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 +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +// +// +// Derived from cryptoapi implementation, originally based on the +// public domain implementation written by Colin Plumb in 1993. +// +// Copyright (C) Cryptoapi developers. +// +// Algorithm Copyright: +// +// Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All +// rights reserved. +// +// License to copy and use this software is granted provided that it +// is identified as the "RSA Data Security, Inc. MD5 Message-Digest +// Algorithm" in all material mentioning or referencing this software +// or this function. +// +// License is also granted to make and use derivative works provided +// that such works are identified as "derived from the RSA Data +// Security, Inc. MD5 Message-Digest Algorithm" in all material +// mentioning or referencing the derived work. +// +// RSA Data Security, Inc. makes no representations concerning either +// the merchantability of this software or the suitability of this +// software forany particular purpose. It is provided "as is" +// without express or implied warranty of any kind. +// These notices must be retained in any copies of any part of this +// documentation and/or software. + +#include "vmime/security/digest/md5/md5MessageDigest.hpp" + + +namespace vmime { +namespace security { +namespace digest { +namespace md5 { + + +md5MessageDigest::md5MessageDigest() +{ + init(); +} + + +void md5MessageDigest::reset() +{ + init(); +} + + +void md5MessageDigest::init() +{ + m_hash[0] = 0x67452301; + m_hash[1] = 0xefcdab89; + m_hash[2] = 0x98badcfe; + m_hash[3] = 0x10325476; + + m_byteCount = 0; + m_finalized = false; +} + + +static void copyUint8Array(vmime_uint8* dest, const vmime_uint8* src, unsigned long count) +{ + for ( ; count >= 4 ; count -= 4, dest += 4, src += 4) + { + dest[0] = src[0]; + dest[1] = src[1]; + dest[2] = src[2]; + dest[3] = src[3]; + } + + for ( ; count ; --count, ++dest, ++src) + dest[0] = src[0]; +} + + +static inline vmime_uint32 swapUint32(const vmime_uint32 D) +{ + return ((D << 24) | ((D << 8) & 0x00FF0000) | ((D >> 8) & 0x0000FF00) | (D >> 24)); +} + + +static inline void swapUint32Array(vmime_uint32* buf, unsigned long words) +{ + for ( ; words >= 4 ; words -= 4, buf += 4) + { + buf[0] = swapUint32(buf[0]); + buf[1] = swapUint32(buf[1]); + buf[2] = swapUint32(buf[2]); + buf[3] = swapUint32(buf[3]); + } + + for ( ; words ; --words, ++buf) + buf[0] = swapUint32(buf[0]); +} + + +void md5MessageDigest::update(const byte b) +{ + update(&b, 1); +} + + +void md5MessageDigest::update(const string& s) +{ + update(reinterpret_cast (s.data()), s.length()); +} + + +void md5MessageDigest::update(const byte* data, const unsigned long offset, + const unsigned long len) +{ + update(data + offset, len); +} + + +void md5MessageDigest::update(const byte* data, const unsigned long length) +{ + const unsigned long avail = 64 - (m_byteCount & 0x3f); + unsigned long len = length; + + m_byteCount += len; + + if (avail > len) + { + copyUint8Array(m_block + (64 - avail), data, len); + return; + } + + copyUint8Array(m_block + (64 - avail), data, avail); + transformHelper(); + + data += avail; + len -= avail; + + while (len >= 64) + { + copyUint8Array(m_block, data, 64); + transformHelper(); + + data += 64; + len -= 64; + } + + copyUint8Array(m_block, data, len); +} + + +void md5MessageDigest::finalize(const string& s) +{ + update(s); + finalize(); +} + + +void md5MessageDigest::finalize(const byte* buffer, const unsigned long len) +{ + update(buffer, len); + finalize(); +} + + +void md5MessageDigest::finalize(const byte* buffer, + const unsigned long offset, const unsigned long len) +{ + update(buffer, offset, len); + finalize(); +} + + +void md5MessageDigest::finalize() +{ + const long offset = m_byteCount & 0x3f; + + vmime_uint8* p = m_block + offset; + long padding = 56 - (offset + 1); + + *p++ = 0x80; + + if (padding < 0) + { + memset(p, 0x00, padding + 8); + transformHelper(); + p = m_block; + padding = 56; + } + + memset(p, 0, padding); + + reinterpret_cast (m_block)[14] = (m_byteCount << 3); + reinterpret_cast (m_block)[15] = (m_byteCount >> 29); + +#if VMIME_BYTE_ORDER_BIG_ENDIAN + swapUint32Array((vmime_uint32*) m_block, (64 - 8) / 4); +#endif + + transform(); + +#if VMIME_BYTE_ORDER_BIG_ENDIAN + swapUint32Array((vmime_uint32*) m_hash, 4); +#endif + + m_finalized = true; +} + + +void md5MessageDigest::transformHelper() +{ +#if VMIME_BYTE_ORDER_BIG_ENDIAN + swapUint32Array((vmime_uint32*) m_block, 64 / 4); +#endif + transform(); +} + + +void md5MessageDigest::transform() +{ + const vmime_uint32* const in = reinterpret_cast (m_block); + + vmime_uint32 a = m_hash[0]; + vmime_uint32 b = m_hash[1]; + vmime_uint32 c = m_hash[2]; + vmime_uint32 d = m_hash[3]; + +#define F1(x, y, z) (z ^ (x & (y ^ z))) +#define F2(x, y, z) F1(z, x, y) +#define F3(x, y, z) (x ^ y ^ z) +#define F4(x, y, z) (y ^ (x | ~z)) + +#define MD5STEP(f, w, x, y, z, in, s) \ + (w += f(x, y, z) + in, w = (w<>(32-s)) + x) + + MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7); + MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12); + MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17); + MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22); + MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7); + MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12); + MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17); + MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22); + MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7); + MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12); + MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17); + MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22); + MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7); + MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12); + MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17); + MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22); + + MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5); + MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9); + MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14); + MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20); + MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5); + MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9); + MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14); + MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20); + MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5); + MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9); + MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14); + MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20); + MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5); + MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9); + MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14); + MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20); + + MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4); + MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11); + MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16); + MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23); + MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4); + MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11); + MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16); + MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23); + MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4); + MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11); + MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16); + MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23); + MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4); + MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11); + MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16); + MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23); + + MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6); + MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10); + MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15); + MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21); + MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6); + MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10); + MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15); + MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21); + MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6); + MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10); + MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15); + MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21); + MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6); + MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10); + MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15); + MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21); + + m_hash[0] += a; + m_hash[1] += b; + m_hash[2] += c; + m_hash[3] += d; +} + + +const int md5MessageDigest::getDigestLength() const +{ + return 16; +} + + +const byte* md5MessageDigest::getDigest() const +{ + return reinterpret_cast (m_hash); +} + + +} // md5 +} // digest +} // security +} // vmime + diff --git a/src/security/digest/messageDigest.cpp b/src/security/digest/messageDigest.cpp new file mode 100644 index 00000000..8fb56543 --- /dev/null +++ b/src/security/digest/messageDigest.cpp @@ -0,0 +1,53 @@ +// +// VMime library (http://www.vmime.org) +// Copyright (C) 2002-2005 Vincent Richard +// +// This program 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 2 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 +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +// + +#include "vmime/security/digest/messageDigest.hpp" + +#include + + +namespace vmime { +namespace security { +namespace digest { + + +const string messageDigest::getHexDigest() const +{ + const byte* hash = getDigest(); + const int len = getDigestLength(); + + static const unsigned char hex[] = "0123456789abcdef"; + + std::ostringstream oss; + + for (int i = 0 ; i < len ; ++i) + { + oss << hex[(hash[i] & 0xf0) >> 4]; + oss << hex[(hash[i] & 0x0f)]; + } + + return oss.str(); + +} + + +} // digest +} // security +} // vmime + diff --git a/src/security/digest/messageDigestFactory.cpp b/src/security/digest/messageDigestFactory.cpp new file mode 100644 index 00000000..eccc545c --- /dev/null +++ b/src/security/digest/messageDigestFactory.cpp @@ -0,0 +1,80 @@ +// +// VMime library (http://www.vmime.org) +// Copyright (C) 2002-2005 Vincent Richard +// +// This program 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 2 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 +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +// + +#include "vmime/security/digest/messageDigestFactory.hpp" +#include "vmime/exception.hpp" + +#include "vmime/security/digest/md5/md5MessageDigest.hpp" +#include "vmime/security/digest/sha1/sha1MessageDigest.hpp" + + +namespace vmime { +namespace security { +namespace digest { + + +messageDigestFactory::messageDigestFactory() +{ + registerAlgorithm ("md5"); + registerAlgorithm ("sha1"); +} + + +messageDigestFactory::~messageDigestFactory() +{ +} + + +messageDigestFactory* messageDigestFactory::getInstance() +{ + static messageDigestFactory instance; + return (&instance); +} + + +ref messageDigestFactory::create(const string& name) +{ + const MapType::const_iterator it = m_algos.find + (utility::stringUtils::toLower(name)); + + if (it != m_algos.end()) + return (*it).second->create(); + + throw exceptions::no_digest_algorithm_available(name); +} + + +const std::vector messageDigestFactory::getSupportedAlgorithms() const +{ + std::vector res; + + for (MapType::const_iterator it = m_algos.begin() ; + it != m_algos.end() ; ++it) + { + res.push_back((*it).first); + } + + return res; +} + + +} // digest +} // security +} // vmime + diff --git a/src/security/digest/sha1/sha1MessageDigest.cpp b/src/security/digest/sha1/sha1MessageDigest.cpp new file mode 100644 index 00000000..de3f6948 --- /dev/null +++ b/src/security/digest/sha1/sha1MessageDigest.cpp @@ -0,0 +1,262 @@ +// +// VMime library (http://www.vmime.org) +// Copyright (C) 2002-2005 Vincent Richard +// +// This program 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 2 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 +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +// +// +// This is an implementation by Steve Reid +// 100% public domain. + +#include "vmime/security/digest/sha1/sha1MessageDigest.hpp" + + +namespace vmime { +namespace security { +namespace digest { +namespace sha1 { + + +#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) + +// blk0() and blk() perform the initial expand. +// I got the idea of expanding during the round function from SSLeay +#if VMIME_BYTE_ORDER_LITTLE_ENDIAN + #define blk0(i) (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) \ + | (rol(block->l[i], 8) & 0x00FF00FF)) +#else + #define blk0(i) block->l[i] +#endif + +#define blk(i) (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] \ + ^ block->l[(i + 2) & 15] ^ block->l[i & 15], 1)) + +// (R0+R1), R2, R3, R4 are the different operations used in SHA1 +#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30); +#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30); +#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30); +#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30); +#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30); + + +sha1MessageDigest::sha1MessageDigest() +{ + init(); +} + + +void sha1MessageDigest::reset() +{ + init(); +} + + +void sha1MessageDigest::init() +{ + m_state[0] = 0x67452301; + m_state[1] = 0xefcdab89; + m_state[2] = 0x98badcfe; + m_state[3] = 0x10325476; + m_state[4] = 0xc3d2e1f0; + + m_count[0] = 0; + m_count[1] = 0; +} + + +void sha1MessageDigest::update(const byte b) +{ + update(&b, 1); +} + + +void sha1MessageDigest::update(const string& s) +{ + update(reinterpret_cast (s.data()), s.length()); +} + + +void sha1MessageDigest::update(const byte* buffer, const unsigned long offset, + const unsigned long len) +{ + update(buffer + offset, len); +} + + +void sha1MessageDigest::update(const byte* buffer, const unsigned long len) +{ + unsigned int i, j; + + j = (m_count[0] >> 3) & 63; + + if ((m_count[0] += len << 3) < (len << 3)) + m_count[1]++; + + m_count[1] += (len >> 29); + + if ((j + len) > 63) + { + memcpy(&m_buffer[j], buffer, (i = 64 - j)); + + transform(m_state, m_buffer); + + for ( ; i + 63 < len ; i += 64) + transform(m_state, &buffer[i]); + + j = 0; + } + else + { + i = 0; + } + + memcpy(&m_buffer[j], &buffer[i], len - i); +} + + +void sha1MessageDigest::finalize() +{ + unsigned long i, j; + unsigned char finalcount[8]; + + for (i = 0 ; i < 8 ; i++) + { + finalcount[i] = static_cast + ((m_count[(i >= 4 ? 0 : 1)] + >> ((3-(i & 3)) * 8) ) & 255); // Endian independent + } + + update(reinterpret_cast ("\200"), 1); + + while ((m_count[0] & 504) != 448) + update(reinterpret_cast ("\0"), 1); + + update(finalcount, 8); // Should cause a transform() + + for (i = 0 ; i < 20 ; i++) + { + m_digest[i] = static_cast + ((m_state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255); + } + + // Wipe variables + i = j = 0; + + memset(m_buffer, 0, 64); + memset(m_state, 0, 20); + memset(m_count, 0, 8); + memset(&finalcount, 0, 8); +} + + +void sha1MessageDigest::finalize(const string& s) +{ + finalize(reinterpret_cast (s.data()), s.length()); +} + + +void sha1MessageDigest::finalize(const byte* buffer, const unsigned long len) +{ + update(buffer, len); + finalize(); +} + + +void sha1MessageDigest::finalize(const byte* buffer, + const unsigned long offset, const unsigned long len) +{ + finalize(buffer + offset, len); +} + + +/** Hash a single 512-bit block. + * This is the core of the algorithm. + */ +void sha1MessageDigest::transform + (unsigned long state[5], const unsigned char buffer[64]) +{ + unsigned long a, b, c, d, e; + + typedef union + { + unsigned char c[64]; + unsigned long l[16]; + } CHAR64LONG16; + + CHAR64LONG16* block; + static unsigned char workspace[64]; + + block = reinterpret_cast (workspace); + memcpy(block, buffer, 64); + + // Copy context->state[] to working vars + a = state[0]; + b = state[1]; + c = state[2]; + d = state[3]; + e = state[4]; + + // 4 rounds of 20 operations each. Loop unrolled. + R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3); + R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7); + R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11); + R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15); + R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19); + R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23); + R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27); + R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31); + R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35); + R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39); + R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43); + R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47); + R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51); + R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55); + R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59); + R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63); + R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67); + R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71); + R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75); + R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79); + + // Add the working vars back into context.state[] + state[0] += a; + state[1] += b; + state[2] += c; + state[3] += d; + state[4] += e; + + // Wipe variables + a = b = c = d = e = 0; +} + + +const int sha1MessageDigest::getDigestLength() const +{ + return 20; +} + + +const byte* sha1MessageDigest::getDigest() const +{ + return m_digest; +} + + +} // sha1 +} // digest +} // security +} // vmime + + diff --git a/src/utility/md5.cpp b/src/utility/md5.cpp deleted file mode 100644 index b5899e36..00000000 --- a/src/utility/md5.cpp +++ /dev/null @@ -1,331 +0,0 @@ -// -// VMime library (http://www.vmime.org) -// Copyright (C) 2002-2005 Vincent Richard -// -// This program 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 2 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 -// General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with this program; if not, write to the Free Software -// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. -// -// -// Derived from cryptoapi implementation, originally based on the -// public domain implementation written by Colin Plumb in 1993. -// -// Copyright (C) Cryptoapi developers. -// -// Algorithm Copyright: -// -// Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All -// rights reserved. -// -// License to copy and use this software is granted provided that it -// is identified as the "RSA Data Security, Inc. MD5 Message-Digest -// Algorithm" in all material mentioning or referencing this software -// or this function. -// -// License is also granted to make and use derivative works provided -// that such works are identified as "derived from the RSA Data -// Security, Inc. MD5 Message-Digest Algorithm" in all material -// mentioning or referencing the derived work. -// -// RSA Data Security, Inc. makes no representations concerning either -// the merchantability of this software or the suitability of this -// software forany particular purpose. It is provided "as is" -// without express or implied warranty of any kind. -// These notices must be retained in any copies of any part of this -// documentation and/or software. - -#include "vmime/utility/md5.hpp" - - -namespace vmime { -namespace utility { - - -md5::md5() - : m_finalized(false) -{ - init(); -} - - -md5::md5(const vmime_uint8* const in, const unsigned long length) - : m_finalized(false) -{ - init(); - update(in, length); -} - - -md5::md5(const string& in) - : m_finalized(false) -{ - init(); - update(reinterpret_cast (in.c_str()), in.length()); -} - - -void md5::init() -{ - m_hash[0] = 0x67452301; - m_hash[1] = 0xefcdab89; - m_hash[2] = 0x98badcfe; - m_hash[3] = 0x10325476; - - m_byteCount = 0; -} - - -static void copyUint8Array(vmime_uint8* dest, const vmime_uint8* src, unsigned long count) -{ - for ( ; count >= 4 ; count -= 4, dest += 4, src += 4) - { - dest[0] = src[0]; - dest[1] = src[1]; - dest[2] = src[2]; - dest[3] = src[3]; - } - - for ( ; count ; --count, ++dest, ++src) - dest[0] = src[0]; -} - - -static inline vmime_uint32 swapUint32(const vmime_uint32 D) -{ - return ((D << 24) | ((D << 8) & 0x00FF0000) | ((D >> 8) & 0x0000FF00) | (D >> 24)); -} - - -static inline void swapUint32Array(vmime_uint32* buf, unsigned long words) -{ - for ( ; words >= 4 ; words -= 4, buf += 4) - { - buf[0] = swapUint32(buf[0]); - buf[1] = swapUint32(buf[1]); - buf[2] = swapUint32(buf[2]); - buf[3] = swapUint32(buf[3]); - } - - for ( ; words ; --words, ++buf) - buf[0] = swapUint32(buf[0]); -} - - -void md5::update(const string& in) -{ - update(reinterpret_cast (in.c_str()), in.length()); -} - - -void md5::update(const vmime_uint8* data, unsigned long len) -{ - if (m_finalized) - return; - - const unsigned long avail = 64 - (m_byteCount & 0x3f); - - m_byteCount += len; - - if (avail > len) - { - copyUint8Array(m_block + (64 - avail), data, len); - return; - } - - copyUint8Array(m_block + (64 - avail), data, avail); - transformHelper(); - - data += avail; - len -= avail; - - while (len >= 64) - { - copyUint8Array(m_block, data, 64); - transformHelper(); - - data += 64; - len -= 64; - } - - copyUint8Array(m_block, data, len); -} - - -void md5::finalize() -{ - const long offset = m_byteCount & 0x3f; - - vmime_uint8* p = m_block + offset; - long padding = 56 - (offset + 1); - - *p++ = 0x80; - - if (padding < 0) - { - memset(p, 0x00, padding + 8); - transformHelper(); - p = m_block; - padding = 56; - } - - memset(p, 0, padding); - - reinterpret_cast (m_block)[14] = (m_byteCount << 3); - reinterpret_cast (m_block)[15] = (m_byteCount >> 29); - -#if VMIME_BYTE_ORDER_BIG_ENDIAN - swapUint32Array((vmime_uint32*) m_block, (64 - 8) / 4); -#endif - - transform(); - -#if VMIME_BYTE_ORDER_BIG_ENDIAN - swapUint32Array((vmime_uint32*) m_hash, 4); -#endif - - m_finalized = true; -} - - -void md5::transformHelper() -{ -#if VMIME_BYTE_ORDER_BIG_ENDIAN - swapUint32Array((vmime_uint32*) m_block, 64 / 4); -#endif - transform(); -} - - -void md5::transform() -{ - const vmime_uint32* const in = reinterpret_cast (m_block); - - vmime_uint32 a = m_hash[0]; - vmime_uint32 b = m_hash[1]; - vmime_uint32 c = m_hash[2]; - vmime_uint32 d = m_hash[3]; - -#define F1(x, y, z) (z ^ (x & (y ^ z))) -#define F2(x, y, z) F1(z, x, y) -#define F3(x, y, z) (x ^ y ^ z) -#define F4(x, y, z) (y ^ (x | ~z)) - -#define MD5STEP(f, w, x, y, z, in, s) \ - (w += f(x, y, z) + in, w = (w<>(32-s)) + x) - - MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7); - MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12); - MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17); - MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22); - MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7); - MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12); - MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17); - MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22); - MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7); - MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12); - MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17); - MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22); - MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7); - MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12); - MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17); - MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22); - - MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5); - MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9); - MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14); - MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20); - MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5); - MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9); - MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14); - MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20); - MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5); - MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9); - MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14); - MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20); - MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5); - MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9); - MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14); - MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20); - - MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4); - MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11); - MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16); - MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23); - MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4); - MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11); - MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16); - MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23); - MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4); - MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11); - MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16); - MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23); - MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4); - MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11); - MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16); - MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23); - - MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6); - MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10); - MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15); - MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21); - MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6); - MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10); - MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15); - MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21); - MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6); - MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10); - MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15); - MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21); - MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6); - MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10); - MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15); - MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21); - - m_hash[0] += a; - m_hash[1] += b; - m_hash[2] += c; - m_hash[3] += d; -} - - -const string md5::hex() -{ - if (!m_finalized) - finalize(); - - static const unsigned char hex[] = "0123456789abcdef"; - - std::ostringstream oss; - const vmime_uint8* const digest = reinterpret_cast (m_hash); - - for (int i = 0 ; i < 16 ; ++i) - { - oss << hex[(digest[i] & 0xf0) >> 4]; - oss << hex[(digest[i] & 0x0f)]; - } - - return (oss.str()); -} - - -const vmime_uint8* md5::hash() -{ - if (!m_finalized) - finalize(); - - return (reinterpret_cast (m_hash)); -} - - -} // utility -} // vmime -- cgit