circuit.h

Go to the documentation of this file.

#ifndef CIRCUIT_H_
#define CIRCUIT_H_

#include "abycircuit.h"

class share;
class boolshare;
class arithshare;

class Circuit {

public:
    Circuit(ABYCircuit* aby, e_sharing context, e_role myrole, uint32_t bitlen, e_circuit circ) :
            m_cCircuit(aby), m_eContext(context), m_eMyRole(myrole), m_nShareBitLen(bitlen), m_eCirctype(circ) {
        Init();
    }
    ;
    virtual ~Circuit() {
    }
    ;

    void Init();

    void Cleanup();

    void Reset();

    /* organizational routines */

    uint32_t GetShareBitLen() {
        return m_nShareBitLen;
    }
    ;

    uint32_t GetMaxDepth() {
        return m_nMaxDepth;
    }
    ;
    deque<uint32_t> GetLocalQueueOnLvl(uint32_t lvl) {

        if (lvl < m_vLocalQueueOnLvl.size())
            return m_vLocalQueueOnLvl[lvl];
        else
            return EMPTYQUEUE;
    }
    ;

    deque<uint32_t> GetInteractiveQueueOnLvl(uint32_t lvl) {
        if (lvl < m_vInteractiveQueueOnLvl.size())
            return m_vInteractiveQueueOnLvl[lvl];
        else
            return EMPTYQUEUE;
    }
    ;

    uint32_t GetNumLocalLayers() {
        return m_vLocalQueueOnLvl.size();
    }

    uint32_t GetNumInteractiveLayers() {
        return m_vInteractiveQueueOnLvl.size();
    }

    uint32_t GetNumInputBitsForParty(e_role party) {
        return m_vInputBits[party];
    }
    ;
    uint32_t GetNumOutputBitsForParty(e_role party) {
        return m_vOutputBits[party];
    }
    ;
    deque<uint32_t> GetInputGatesForParty(e_role party) {
        return m_vInputGates[party];
    }
    ;
    deque<uint32_t> GetOutputGatesForParty(e_role party) {
        return m_vOutputGates[party];
    }
    ;

    e_sharing GetContext() {
        return m_eContext;
    }
    ;
    uint32_t GetNumGates() {
        return m_nGates;
    }
    ;

    UGATE_T* GetOutputGateValue(uint32_t gateid);
    uint32_t GetOutputGateValue(uint32_t gateid, UGATE_T*& outval);
    template<class T> void GetOutputGateValue(uint32_t gateid, T& val);
    uint32_t GetNumVals(uint32_t gateid) {
        assert(gateid < m_cCircuit->GetGateHead());
        return m_pGates[gateid].nvals;
    }
    ;

    /* Common gate-building routines */
    virtual share* PutCONSGate(uint32_t nvals, UGATE_T val, uint32_t bitlen) = 0;
    virtual share* PutCONSGate(uint32_t nvals, uint32_t* val, uint32_t bitlen) = 0;
    virtual share* PutCONSGate(uint32_t nvals, uint8_t* val, uint32_t bitlen) = 0;
    virtual uint32_t PutConstantGate(UGATE_T val, uint32_t nvals = 1) = 0;

    //virtual int   PutINGate(int nvals, ROLE src) = 0;
    virtual share* PutINGate(uint32_t nvals, uint64_t val, uint32_t bitlen, e_role role) = 0;
    virtual share* PutINGate(uint32_t nvals, uint32_t* val, uint32_t bitlen, e_role role) = 0;
    virtual share* PutINGate(uint32_t nvals, uint8_t* val, uint32_t bitlen, e_role role) = 0;

    virtual share* PutADDGate(share* ina, share* inb) = 0;
    virtual share* PutSUBGate(share* ina, share* inb) = 0;
    virtual share* PutANDGate(share* ina, share* inb) = 0;
    virtual share* PutXORGate(share* ina, share* inb) = 0;
    virtual share* PutMULGate(share* ina, share* inb) = 0;
    virtual share* PutGEGate(share* ina, share* inb) = 0;
    virtual share* PutEQGate(share* ina, share* inb) = 0;
    virtual share* PutMUXGate(share* ina, share* inb, share* sel) = 0;
    virtual share* PutY2BGate(share* ina) = 0;
    virtual share* PutB2AGate(share* ina) = 0;
    virtual share* PutB2YGate(share* ina) = 0;
    virtual share* PutA2YGate(share* ina) = 0;
    virtual share* PutANDVecGate(share* ina, share* inb) = 0;
    virtual share* PutCallbackGate(share* in, uint32_t rounds, void (*callback)(GATE*, void*), void* infos, uint32_t nvals) = 0;
    share* PutCombinerGate(share* ina);
    share* PutSplitterGate(share* ina);
    share* PutRepeaterGate(uint32_t nvals, share* ina);

    //Templates may not be virtual, hence use dummy functions
    template<class T> uint32_t PutINGate(uint32_t nvals, T val) {
        cout << "IN gate not implemented in super-class, stopping!" << endl;
        return -1;
    }
    ;
    template<class T> uint32_t PutINGate(uint32_t nvals, T val, e_role role) {
        cout << "IN gate not implemented in super-class, stopping!" << endl;
        return -1;
    }
    ;
    //virtual int   PutOUTGate(int parent, ROLE dst) = 0;
    virtual share* PutOUTGate(share* parent, e_role dst) =0;
    // TODO FIXME PutOUTGate seems to work only for role ALL. SERVER causes the client to segfault at src/abycore/circuit/circuit.cpp:71: UGATE_T* Circuit::GetOutputGateValue(uint32_t): Assertion `m_pGates[gateid].instantiated' failed.


    virtual uint32_t PutINVGate(uint32_t parentid) = 0;
    e_circuit GetCircuitType() {
        return m_eCirctype;
    }
    ;

protected:
    virtual void UpdateInteractiveQueue(uint32_t gateid) = 0;
    virtual void UpdateLocalQueue(uint32_t gateid) = 0;

    void UpdateInteractiveQueue(share* gateid);
    void UpdateLocalQueue(share* gateid);

    ABYCircuit* m_cCircuit; 
    GATE* m_pGates;         
    e_sharing m_eContext;
    e_circuit m_eCirctype;
    e_role m_eMyRole;
    uint32_t m_nShareBitLen;
    uint32_t m_nMaxDepth;

    vector<deque<uint32_t> > m_vLocalQueueOnLvl; //for locally evaluatable gates, first dimension is the level of the gates, second dimension presents the queue on which the gateids are put
    vector<deque<uint32_t> > m_vInteractiveQueueOnLvl; //for gates that need interaction, first dimension is the level of the gates, second dimension presents the queue on which the gateids are put
    vector<deque<uint32_t> > m_vInputGates;             //input gates for the parties
    vector<deque<uint32_t> > m_vOutputGates;                //input gates for the parties
    vector<uint32_t> m_vInputBits;              //number of input bits for the parties
    vector<uint32_t> m_vOutputBits;             //number of output bits for the parties

    uint32_t m_nMULs;                   //number of AND gates in the circuit
    uint32_t m_nCONVGates;              //number of Boolean to arithmetic conversion gates

    uint32_t m_nGates;
    uint32_t m_nRoundsAND;
    uint32_t m_nRoundsXOR;
    vector<uint32_t> m_nRoundsIN;
    vector<uint32_t> m_nRoundsOUT;

    const deque<uint32_t> EMPTYQUEUE;
};

class share {
public:
    share(uint32_t sharelen, Circuit* circ);
    share(vector<uint32_t> gates, Circuit* circ);
    void init(Circuit* circ, uint32_t maxbitlen = 32);

    ~share() {
    }
    ;

    vector<uint32_t>& get_gates() {
        return m_ngateids;
    }
    ;
    uint32_t get_gate(uint32_t shareid);
    void set_gate(uint32_t shareid, uint32_t gateid);
    void resize(uint32_t sharelen) {
        m_ngateids.resize(sharelen);
    }
    ;
    void set_gates(vector<uint32_t> shares) {
        m_ngateids = shares;
    }
    ;
    uint32_t size() {
        return m_ngateids.size();
    }
    ;
    uint32_t max_size() {
        return m_nmaxbitlen;
    }
    ;
    uint32_t set_max_size(uint32_t maxsize) {
        assert(maxsize >= m_ngateids.size());
        m_nmaxbitlen = maxsize;
    }
    ;
    e_circuit get_circuit_type() {
        return m_ccirc->GetCircuitType();
    }
    ;
    e_sharing get_share_type() {
        return m_ccirc->GetContext();
    }
    ;

    template<class T> T get_clear_value() {
        assert(sizeof(T) * 8 >= m_ngateids.size());
        T val = 0;
        for (uint32_t i = 0; i < m_ngateids.size(); i++) {
            val += (*m_ccirc->GetOutputGateValue(m_ngateids[i]) << i);
        }

        return val;
    }

    virtual uint8_t* get_clear_value() = 0;
    virtual void get_clear_value_vec(uint32_t** vec, uint32_t *bitlen, uint32_t *nvals) = 0;

protected:
    vector<uint32_t> m_ngateids;
    Circuit* m_ccirc;
    uint32_t m_nmaxbitlen;
};

class boolshare: public share {
public:
    boolshare(uint32_t sharelen, Circuit* circ) :
            share(sharelen, circ) {
    }
    ;
    boolshare(vector<uint32_t> gates, Circuit* circ) :
            share(gates, circ) {
    }
    ;
    ~boolshare() {
    }
    ;               // : share() {};

    uint8_t* get_clear_value();
    void get_clear_value_vec(uint32_t** vec, uint32_t *bitlen, uint32_t *nvals);
};

class arithshare: public share {
public:
    arithshare(Circuit* circ) :
            share(1, circ) {
    }
    ;
    arithshare(vector<uint32_t> gates, Circuit* circ) :
            share(gates, circ) {
    }
    ;

    ~arithshare() {
    }
    ;               // : share() {};

    uint8_t* get_clear_value();
    void get_clear_value_vec(uint32_t** vec, uint32_t* bitlen, uint32_t* nvals);

};

static share* create_new_share(uint32_t size, Circuit* circ, e_circuit circtype);
static share* create_new_share(vector<uint32_t> vals, Circuit* circ, e_circuit circtype);

#endif /* CIRCUIT_H_ */