ripemd160.h

Go to the documentation of this file.

/*
-------------------------------------------------------------------------------
                            PLEBBLE
-------------------------------------------------------------------------------
 Copyright (C) 2019-2020 KATLAS Technology. (http://katlastechnology.com)
 Copyright (C) 2017-2020 Marcos Mayorga. (mm@mm-studios.com)
 
 This file is part of our Plebble(R) Platform.
 
 The code below cannot be copied, used for any purpose other than the one
 agreed and/or distributed without the express permission of
 KATLAS Technology.
-------------------------------------------------------------------------------
 
 
*/
#ifndef USGOV_5a3346e45d07feaf4864a3e08a47717c8da7429ee7accc342f7bc496c9fdb846
#define USGOV_5a3346e45d07feaf4864a3e08a47717c8da7429ee7accc342f7bc496c9fdb846
 
#include <stdint.h>
#include <stdlib.h>
#include <string>
#include <cassert>
#include <cstring>
#include <array>
#include <iostream>
#include <vector>
#include <us/gov/config.h>
 
namespace us { namespace gov {
namespace crypto {
using namespace std;
 
    class ripemd160 {
    public:
        static constexpr size_t output_size = 20;
 
        struct value_type:array<unsigned char,output_size> {
            typedef array<unsigned char,output_size> b;
            typedef ripemd160 hasher_t; 
            value_type();
            value_type(const value_type&);
            value_type(unsigned int i);
            value_type(const string& b58);
 
            bool operator == (const value_type& other) const;
            bool operator != (const value_type& other) const;
            bool operator < (const value_type& other) const;
            void set(unsigned int i);
            value_type& operator = (const string& b58);
            value_type& operator = (unsigned int i);
            bool is_zero() const;
            bool is_not_zero() const;
            void zero();
            string to_b58() const;
            string to_hex() const;
            static value_type from_b58(const string&);
            static value_type from_hex(const string&);
            bool set_b58(const string&);
            bool set_hex(const string&);
            uint32_t uint32() const;
 
            template<typename T>
            static value_type compute(const T& o) {
                ripemd160 hasher;
                hasher.write(o);
                value_type r;
                hasher.finalize(r);
                return move(r);
            }
 
            template<typename T1, typename T2>
            static value_type compute(const T1& o1, const T2& o2) {
                ripemd160 hasher;
                hasher.write(o1);
                hasher.write(o2);
                value_type r;
                hasher.finalize(r);
                return move(r);
            }
        };
 
        ripemd160();
 
        void write(const vector<unsigned char>&);
        void write(const unsigned char* data, size_t len);
        void write(const value_type&);
        void write(const string&);
        void write(const uint64_t&);
        void write(const int64_t&);
        void write(const uint32_t&);
        void write(const int32_t&);
        void write(bool);
        void write(const double&);
        void finalize(unsigned char hash[output_size]);
        void finalize(value_type&);
        void reset();
        static pair<ko, value_type> digest_file(const string& file);
        static value_type digest(const vector<unsigned char>& buf);
 
 
    private:
        uint32_t s[5];
        unsigned char buf[64];
        uint64_t bytes;
        static const unsigned char pad[64];
 
    };
 
 
    inline ostream& operator << (ostream& os, const us::gov::crypto::ripemd160::value_type& v) {
        os << v.to_b58();
        return os;
    }
 
    template<typename T>
    inline us::gov::crypto::ripemd160& operator << (us::gov::crypto::ripemd160& h, const T& v) {
        h.write(v);
        return h;
    }
 
    inline istream& operator >> (istream& is, us::gov::crypto::ripemd160::value_type& v) {
        string s;
        is >> s;
        if (!v.set_b58(s)) is.setstate(ios_base::failbit);
        return is;
      }
 
}
}}
 
namespace std {
 
  template <>
  struct hash<us::gov::crypto::ripemd160::value_type> {
    size_t operator()(const us::gov::crypto::ripemd160::value_type& k) const {
        return *reinterpret_cast<const size_t*>(&k[0]);
 
    }
  };
 
}
 
#endif