Add hash160 md algo
This commit is contained in:
John Jones
parent
a87a99bbeb
commit
94f77ffc85
3 changed files with 275 additions and 0 deletions
|
|
@ -247,6 +247,7 @@ set( fc_sources
|
|||
src/crypto/hex.cpp
|
||||
src/crypto/sha1.cpp
|
||||
src/crypto/ripemd160.cpp
|
||||
src/crypto/hash160.cpp
|
||||
src/crypto/sha256.cpp
|
||||
src/crypto/sha224.cpp
|
||||
src/crypto/sha512.cpp
|
||||
|
|
|
|||
134
include/fc/crypto/hash160.hpp
Normal file
134
include/fc/crypto/hash160.hpp
Normal file
|
|
@ -0,0 +1,134 @@
|
|||
/*
|
||||
* Copyright (c) 2018 jmjatlanta and contributors.
|
||||
*
|
||||
* The MIT License
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
#pragma once
|
||||
#include <boost/endian/buffers.hpp>
|
||||
#include <fc/fwd.hpp>
|
||||
#include <fc/io/raw_fwd.hpp>
|
||||
#include <fc/reflect/typename.hpp>
|
||||
|
||||
namespace fc{
|
||||
class sha512;
|
||||
class sha256;
|
||||
class ripemd160;
|
||||
|
||||
class hash160
|
||||
{
|
||||
public:
|
||||
hash160();
|
||||
explicit hash160( const string& hex_str );
|
||||
|
||||
string str()const;
|
||||
explicit operator string()const;
|
||||
|
||||
char* data() const;
|
||||
size_t data_size() const { return 160/8; }
|
||||
|
||||
static hash160 hash( const char* d, uint32_t dlen );
|
||||
static hash160 hash( const string& );
|
||||
|
||||
template<typename T>
|
||||
static hash160 hash( const T& t )
|
||||
{
|
||||
hash160::encoder e;
|
||||
fc::raw::pack(e,t);
|
||||
return e.result();
|
||||
}
|
||||
|
||||
class encoder
|
||||
{
|
||||
public:
|
||||
encoder();
|
||||
~encoder();
|
||||
|
||||
void write( const char* d, uint32_t dlen );
|
||||
void put( char c ) { write( &c, 1 ); }
|
||||
void reset();
|
||||
hash160 result();
|
||||
|
||||
private:
|
||||
class impl;
|
||||
fc::fwd<impl,96> my;
|
||||
std::vector<uint8_t> bytes;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
inline friend T& operator<<( T& ds, const hash160& ep ) {
|
||||
ds.write( ep.data(), sizeof(ep) );
|
||||
return ds;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline friend T& operator>>( T& ds, hash160& ep ) {
|
||||
ds.read( ep.data(), sizeof(ep) );
|
||||
return ds;
|
||||
}
|
||||
friend hash160 operator << ( const hash160& h1, uint32_t i );
|
||||
friend bool operator == ( const hash160& h1, const hash160& h2 );
|
||||
friend bool operator != ( const hash160& h1, const hash160& h2 );
|
||||
friend hash160 operator ^ ( const hash160& h1, const hash160& h2 );
|
||||
friend bool operator >= ( const hash160& h1, const hash160& h2 );
|
||||
friend bool operator > ( const hash160& h1, const hash160& h2 );
|
||||
friend bool operator < ( const hash160& h1, const hash160& h2 );
|
||||
|
||||
boost::endian::little_uint32_buf_t _hash[5];
|
||||
};
|
||||
|
||||
namespace raw {
|
||||
|
||||
template<typename T>
|
||||
inline void pack( T& ds, const hash160& ep, uint32_t _max_depth ) {
|
||||
ds << ep;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline void unpack( T& ds, hash160& ep, uint32_t _max_depth ) {
|
||||
ds >> ep;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
class variant;
|
||||
void to_variant( const hash160& bi, variant& v, uint32_t max_depth );
|
||||
void from_variant( const variant& v, hash160& bi, uint32_t max_depth );
|
||||
|
||||
/*
|
||||
typedef hash160 uint160_t;
|
||||
typedef hash160 uint160;
|
||||
|
||||
template<> struct get_typename<uint160_t> { static const char* name() { return "uint160_t"; } };
|
||||
*/
|
||||
template<> struct get_typename<hash160> { static const char* name() { return "hash160"; } };
|
||||
} // namespace fc
|
||||
|
||||
namespace std
|
||||
{
|
||||
template<>
|
||||
struct hash<fc::hash160>
|
||||
{
|
||||
size_t operator()( const fc::hash160& s )const
|
||||
{
|
||||
return *((size_t*)&s);
|
||||
}
|
||||
};
|
||||
}
|
||||
140
src/crypto/hash160.cpp
Normal file
140
src/crypto/hash160.cpp
Normal file
|
|
@ -0,0 +1,140 @@
|
|||
/*
|
||||
* Copyright (c) 2018 jmjatlanta and contributors.
|
||||
*
|
||||
* The MIT License
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#include <fc/crypto/hex.hpp>
|
||||
#include <fc/fwd_impl.hpp>
|
||||
#include <openssl/sha.h>
|
||||
#include <openssl/ripemd.h>
|
||||
#include <string.h>
|
||||
#include <fc/crypto/hash160.hpp>
|
||||
#include <fc/crypto/ripemd160.hpp>
|
||||
#include <fc/crypto/sha512.hpp>
|
||||
#include <fc/crypto/sha256.hpp>
|
||||
#include <fc/variant.hpp>
|
||||
#include <vector>
|
||||
#include "_digest_common.hpp"
|
||||
|
||||
namespace fc
|
||||
{
|
||||
|
||||
hash160::hash160() { memset( _hash, 0, sizeof(_hash) ); }
|
||||
|
||||
hash160::hash160( const string& hex_str ) {
|
||||
fc::from_hex( hex_str, (char*)_hash, sizeof(_hash) );
|
||||
}
|
||||
|
||||
string hash160::str()const {
|
||||
return fc::to_hex( (char*)_hash, sizeof(_hash) );
|
||||
}
|
||||
|
||||
hash160::operator string()const { return str(); }
|
||||
|
||||
char* hash160::data()const { return (char*)&_hash[0]; }
|
||||
|
||||
|
||||
class hash160::encoder::impl {
|
||||
public:
|
||||
impl()
|
||||
{
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
hash160::encoder::~encoder() {}
|
||||
hash160::encoder::encoder() {}
|
||||
|
||||
hash160 hash160::hash( const char* d, uint32_t dlen ) {
|
||||
encoder e;
|
||||
e.write(d,dlen);
|
||||
return e.result();
|
||||
}
|
||||
hash160 hash160::hash( const string& s ) {
|
||||
return hash( s.c_str(), s.size() );
|
||||
}
|
||||
|
||||
void hash160::encoder::write( const char* d, uint32_t dlen )
|
||||
{
|
||||
for(uint32_t i = 0; i < dlen; ++i)
|
||||
bytes.push_back(d[i]);
|
||||
}
|
||||
|
||||
hash160 hash160::encoder::result() {
|
||||
// perform the first hashing function
|
||||
SHA256_CTX sha_ctx;
|
||||
SHA256_Init(&sha_ctx);
|
||||
SHA256_Update( &sha_ctx, bytes.data(), bytes.size());
|
||||
unsigned char sha_hash[SHA256_DIGEST_LENGTH];
|
||||
SHA256_Final( sha_hash, &sha_ctx );
|
||||
// perform the second hashing function
|
||||
RIPEMD160_CTX ripe_ctx;
|
||||
RIPEMD160_Init(&ripe_ctx);
|
||||
RIPEMD160_Update( &ripe_ctx, sha_hash, SHA256_DIGEST_LENGTH );
|
||||
hash160 h;
|
||||
RIPEMD160_Final( (uint8_t *)h.data(), &ripe_ctx );
|
||||
return h;
|
||||
}
|
||||
|
||||
hash160 operator << ( const hash160& h1, uint32_t i ) {
|
||||
hash160 result;
|
||||
fc::detail::shift_l( h1.data(), result.data(), result.data_size(), i );
|
||||
return result;
|
||||
}
|
||||
hash160 operator ^ ( const hash160& h1, const hash160& h2 ) {
|
||||
hash160 result;
|
||||
result._hash[0] = h1._hash[0].value() ^ h2._hash[0].value();
|
||||
result._hash[1] = h1._hash[1].value() ^ h2._hash[1].value();
|
||||
result._hash[2] = h1._hash[2].value() ^ h2._hash[2].value();
|
||||
result._hash[3] = h1._hash[3].value() ^ h2._hash[3].value();
|
||||
result._hash[4] = h1._hash[4].value() ^ h2._hash[4].value();
|
||||
return result;
|
||||
}
|
||||
bool operator >= ( const hash160& h1, const hash160& h2 ) {
|
||||
return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) >= 0;
|
||||
}
|
||||
bool operator > ( const hash160& h1, const hash160& h2 ) {
|
||||
return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) > 0;
|
||||
}
|
||||
bool operator < ( const hash160& h1, const hash160& h2 ) {
|
||||
return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) < 0;
|
||||
}
|
||||
bool operator != ( const hash160& h1, const hash160& h2 ) {
|
||||
return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) != 0;
|
||||
}
|
||||
bool operator == ( const hash160& h1, const hash160& h2 ) {
|
||||
return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) == 0;
|
||||
}
|
||||
|
||||
void to_variant( const hash160& bi, variant& v, uint32_t max_depth )
|
||||
{
|
||||
to_variant( std::vector<char>( (const char*)&bi, ((const char*)&bi) + sizeof(bi) ), v, max_depth );
|
||||
}
|
||||
void from_variant( const variant& v, hash160& bi, uint32_t max_depth )
|
||||
{
|
||||
std::vector<char> ve = v.as< std::vector<char> >( max_depth );
|
||||
memset( &bi, char(0), sizeof(bi) );
|
||||
if( ve.size() )
|
||||
memcpy( &bi, ve.data(), std::min<size_t>(ve.size(),sizeof(bi)) );
|
||||
}
|
||||
|
||||
} // fc
|
||||
Loading…
Reference in a new issue