ec.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_075dfff39e95d4a4a7a088fe2ea0fc252d6fa47e6b62b043b4babd2e2b511780
#define USGOV_075dfff39e95d4a4a7a088fe2ea0fc252d6fa47e6b62b043b4babd2e2b511780
 
#include <secp256k1.h>
#include <iostream>
#include <vector>
#include <array>
#include "double_sha256.h"
#include "ripemd160.h"
#include <us/gov/likely.h>
#include "sha256.h"
#include <us/gov/config.h>
 
namespace us { namespace gov {
namespace crypto {
using namespace std;
 
struct ec {
    typedef secp256k1_ecdsa_signature signature;
    typedef sha256 sigmsg_hasher_t;
 
    ec();
    ec(const ec&)=delete;
    ec& operator = (const ec&)=delete;
    ~ec();
 
    struct keys {
        struct pub_t:secp256k1_pubkey {
            typedef crypto::ripemd160 hasher_t;
            typedef hasher_t::value_type hash_t;
            static constexpr uint32_t ser_size = 33;
 
            pub_t();
            pub_t(const pub_t& other);
            pub_t(const string& b58);
            pub_t(const vector<unsigned char>& ser);
            const hash_t& hash() const;
            pub_t& operator =(const string&);
            hash_t compute_hash() const;
            string to_b58() const;
            bool to_vector(vector<unsigned char>& out) const;
            
            bool set_b58(const string&);
            static pub_t from_b58(const string&);
            static pub_t from_hex(const string&);
            void read_b58(const string&);
            void read_ser(const vector<unsigned char>&);
 
            bool operator == (const pub_t& other) const;
            bool operator != (const pub_t& other) const;
            bool operator == (const string& b58) const;
            bool operator != (const string& b58) const;
            pub_t& operator = (const pub_t& other);
            inline void zero() { valid=false; }
            bool valid{false};
        private:
            mutable bool h{false};
            mutable hash_t hash_cached;
        };
 
        struct priv_t: array<unsigned char,32> {
            priv_t();
            priv_t(const string& b58);
            priv_t(const char* b58);
            string to_b58() const;
            static priv_t from_b58(const string&);
            bool set_b58(const string&);
            inline void zero() { memset(this,0,32); }
            bool is_zero() const;
        };
 
        keys() {}
        keys(const priv_t&);
        keys(const keys& other);
        keys(keys&& other);
        void reset(const priv_t&);
        int reset_if_distinct(const priv_t&); // 0 OK/KO equal; 1 OK distinct-valid; -1 KO distinct invalid input
        static keys generate();
        static bool verify(const priv_t& privkey);
        static pub_t get_pubkey(const priv_t& privkey);
 
        priv_t priv;
        pub_t pub;
    };
 
    #if CFG_COUNTERS==1
        struct counters_t {
            uint32_t unable_serialize_pubkey{0};
            uint32_t invalid_b58_pubkey{0};
            uint32_t invalid_ser_pubkey{0};
            uint32_t error_signing{0};
            uint32_t error_serializing_signature{0};
            uint32_t signatures_created{0};
            uint32_t error_creating_shared_secret{0};
            //uint32_t signature_verification_b58_decode_error{0};
            uint32_t signature_verification_der_parse_error{0};
            uint32_t signature_verification_pass{0};
            uint32_t signature_verification_fail{0};
            uint32_t privkey_verification_pass{0};
            uint32_t privkey_verification_fail{0};
            uint32_t error_priv_2_pub{0};
            void dump(ostream&os) const;
        };
        static counters_t counters;
    #endif
 
    static constexpr uint32_t bit_size() { return 256; }
//    static string to_b58(const vector<unsigned char>& data);
    typedef vector<unsigned char> sig_t;
    static vector<unsigned char> from_b58(const string& hex);
    ko sign(const keys::priv_t& pk, const string& text, sig_t& signature) const;
    ko sign(const keys::priv_t& pk, const vector<unsigned char>& msg, sig_t& signature) const;
    ko sign(const keys::priv_t& pk, const sigmsg_hasher_t::value_type&, sig_t& signature) const;
    //vector<unsigned char> sign(const keys::priv_t& pk, const ripemd160::value_type&) const;
//    string sign_encode(const keys::priv_t& pk, const string& text) const;
//    string sign_encode(const keys::priv_t& pk, const vector<unsigned char>& msg) const;
//    string sign_encode(const keys::priv_t& pk, const sigmsg_hasher_t::value_type&) const;
    bool verify(const keys::pub_t& pk, const string& text, const sig_t& signature_der) const;
    bool verify(const keys::pub_t& pk, const vector<unsigned char>& msg, const sig_t& signature_der) const;
    bool verify(const keys::pub_t& pk, const sigmsg_hasher_t::value_type& msgh, const sig_t& signature_der) const;
    bool verify(const keys::pub_t& pk, const sigmsg_hasher_t::value_type& msgh, const sig_t& signature_der, ostream& err) const;
    bool verify_not_normalized(const keys::pub_t& pk, const string& text, const sig_t& signature_der) const;
    bool verify_not_normalized(const keys::pub_t& pk, const vector<unsigned char>& msg, const sig_t& signature_der) const;
    bool verify_not_normalized(const keys::pub_t& pk, const sigmsg_hasher_t::value_type&, const sig_t& signature_der) const;
    ko generate_shared_key(unsigned char *, size_t, const keys::priv_t&, const keys::pub_t&);
 
    static ec instance; 
    secp256k1_context *ctx;
};
 
inline ostream& operator << (ostream& os, const ec::keys::pub_t& k) {
    os << k.to_b58();
    return os;
}
 
inline istream& operator >> (istream& is, ec::keys::pub_t& k) {
    string s;
    is >> s;
    if (!k.set_b58(s)) {
        is.setstate(ios_base::failbit);
        k.zero();
    }
    return is;
}
 
inline ostream& operator << (ostream& os, const ec::keys::priv_t& k) {
    os << k.to_b58();
    return os;
}
 
inline istream& operator >> (istream& is, ec::keys::priv_t& k) {
    string s;
    is >> s;
    if (!k.set_b58(s)) {
        is.setstate(ios_base::failbit);
        k.zero();
        }
    return is;
}
 
}
}}
 
namespace std {
    template <>
    struct hash<us::gov::crypto::ec::keys::pub_t> {
        size_t operator()(const us::gov::crypto::ec::keys::pub_t&) const;
    };
}
 
#endif