auth_app.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_1889feb46c109de0a04e33395e575f90dccd36322bcf52a8e6c93042928b612a
#define USGOV_1889feb46c109de0a04e33395e575f90dccd36322bcf52a8e6c93042928b612a
 
#include "app.h"
#include "peer_t.h"
#include "policies.h"
#include <string>
#include <us/gov/peer/daemon.h>
#include <us/gov/engine/app.h>
#include <map>
#include <set>
#include <tuple>
#include <mutex>
#include <chrono>
#include <unordered_set>
#include <unordered_map>
#include <list>
#include "evidence.h"
#include <us/gov/config.h>
#include <us/gov/crypto/hash.h>
#include <us/gov/crypto/ec.h>
 
namespace test {
    struct auth_app;
}
 
namespace us { namespace gov {
namespace engine {
 
struct daemon;
struct acl_tx;
 
namespace auth {
    using namespace std;
    using socket::datagram;
    typedef peer::daemon::keys keys;
    typedef peer::daemon::pub_t pub_t;
    typedef pub_t::hash_t hash_t;
    typedef peer::daemon::nodes_t nodes_t;
 
    struct app:engine::app {
        typedef engine::app b;
        friend struct test::auth_app;
 
        static const char* KO_78101;
        static const char* KO_73291;
 
        #ifdef CFG_PERMISSIONED_NETWORK
            static pub_t node_master_pubkey;
        #endif
 
        typedef peer::daemon::account_t account_t;
 
        struct local_delta final: engine::app::local_delta {
            ~local_delta() override;
            local_delta();
            local_delta(const local_delta&);
            int app_id() const override;
            bool operator == (const local_delta& other) =delete;
            void to_stream(ostream& os) const override;
            void from_stream(istream& is) override;
            void from_stream_prev(istream& is) override;
            void hash_data_to_sign(crypto::ec::sigmsg_hasher_t&) const override;
            void hash_data(crypto::ripemd160&) const override;
            void dump(ostream&os) const;
 
            nodes_t nodes;
            nodes_t hall;
        };
 
        struct delta final:engine::app::delta {
            typedef engine::app::delta b;
 
            delta() {}
            ~delta() override {}
            delta(const delta&)=delete;
            delta& operator = (const delta&)=delete;
            uint64_t merge(engine::app::local_delta* other0) override;
            void end_merge() override;
            void to_stream(ostream& os) const override;
            static delta* from_stream(istream& is);
            static delta* from_stream_prev(istream& is);
            struct merger:map<hash_t,engine::majority_merger<account_t>> {
                void merge(const nodes_t&);
                void end_merge(nodes_t&, uint16_t seen);
            };
            nodes_t nodes;
            nodes_t hall;
 
            merger nodes_merger;
            merger hall_merger;
        };
 
        struct collusion_control_t final:unordered_map<uint32_t,unsigned char> {
            static unsigned char max_nodes_per_ip;
            bool allow(uint32_t ip_addr);
            void rm(uint32_t ip_addr);
            void update(const nodes_t&);
            void dump(ostream&) const;
        };
 
        struct db_t final {
            db_t(nodes_t& n,mutex& mn,nodes_t& h,mutex& mh):nodes(n), mx_nodes(mn), hall(h), mx_hall(mh) {}
            peer_t::stage_t get_stage(const hash_t&) const;
            void hash(hasher_t&) const;
            void to_stream(ostream& os) const;
            void from_stream(istream& os);
            void from_stream_prev(istream& os);
            void dump(ostream& os) const;
            void clear();
            void dump_as_seeds(ostream&) const;
            void collect_as_wallet_endpoints(vector<tuple<hash_t,uint32_t,uint16_t>>&) const;
 
            mutex& mx_nodes;
            nodes_t& nodes;
            mutex& mx_hall;
            nodes_t& hall;
        };
 
        #if CFG_COUNTERS==1
            struct counters_t final {
                uint32_t basic_auth_completed{0};
                uint32_t not_authorized{0};
                uint32_t invalid_net_address{0};
                uint32_t sysop_connections{0};
                uint32_t node_connections{0};
                uint32_t out_connections{0};
                uint32_t hall_connections{0};
 
                void dump(ostream&os) const;
            };
            static counters_t counters;
        #endif
 
        struct node_address final:engine::evidence {
            typedef engine::evidence b;
            node_address(peer_t::stage_t stage, const hash_t& pkh, uint32_t net_addr, uint16_t pport);
            hash_t compute_hash() const override;
            void to_streamx(ostream&) const;
            void write_pretty(ostream&os) const override;
            string name() const override { return "auth::app::node_address"; }
 
            void dump(const string& prefix, ostream&) const;
 
            engine::peer_t::stage_t stage;
            hash_t pkh;
            uint32_t net_addr;
            uint16_t pport;
        };
 
        constexpr static const char* name={"auth"};
        static constexpr int id() { return 20; }
 
        app(pub_t&, engine::daemon&);
        app(const app&)=delete;
        app& operator = (const app&)=delete;
        ~app() override;
 
        string get_name() const override { return name; }
        int get_id() const override { return id(); }
        bool shell_command(istream&, ostream&) override;
        void save_db(ostream&) const override;
        bool load_db(istream& is) override;
        bool load_db_prev(istream& is) override;
        void import(const nodes_t& src, nodes_t& dst);
        void import(const engine::app::delta&, const engine::pow_t&) override;
        engine::app::local_delta* create_local_delta() override;
        static evidence* evidence_from_stream(uint8_t evid, istream&);
        bool process(const evidence&) override;
        void process(const node_address&);
//        void remote_port(const crypto::ec::keys::pub_t& pubk, uint16_t rport);
        void clear() override;
        void basic_auth_completed(peer_t* p, uint16_t rpport);
        peer_t::stage_t my_stage() const;
        inline bool is_node() const { return my_stage()==peer_t::node; }
        const keys& get_keys() const;
        bool account_state(const hash_t& pubkeyh, uint32_t& netaddr, uint16_t& port, peer_t::stage_t& stage) const;
        bool account_state(const nodes_t&, const hash_t& pubkeyh, uint32_t& netaddr, uint16_t& port) const;
        bool account_state(const local_delta&, const hash_t& pubkeyh, uint32_t& netaddr, uint16_t& port, peer_t::stage_t& stage) const;
 
        #ifdef CFG_PERMISSIONLESS_NETWORK
            void add_growth_transactions(unsigned int seed);
            void layoff(nodes_t& n, uint16_t cut);
            void layoff();
        #endif
        #ifdef CFG_PERMISSIONED_NETWORK
            bool process(const acl_tx&);
        #endif
 
        bool process_query(peer_t *, datagram*) override;
        bool send_response__gov_engine_nodes(peer_t* c, socket::datagram* d);
        bool send_response__gov_engine_lookup_node(peer_t* c, socket::datagram* d);
 
        double growth{0.01};
        int min_growth{1};
        uint16_t layoff_days{LAYOFF_DAYS};
        collusion_control_t collusion_control;
        const pub_t& node_pubkey;
        db_t db;
 
        local_delta* pool{0};
        mutex mx_pool;
        mutable peer_t::stage_t cache_my_stage{peer_t::unknown};
 
    };
 
}
}}
 
}
 
namespace std {
    template <>
    struct hash<us::gov::engine::auth::app::account_t> {
        size_t operator()(const us::gov::engine::auth::app::account_t&) const noexcept;
    };
}
 
#endif