NAC

Task #3192

Updated by Zhiyi Zhang about 10 years ago

Consumer in GEP is mainly the group member that will consume the data produced by the producer. 

 The core process of data consuming is as below: 

 1. get the data packet and validate the packet 
 2. get the encrypted C-KEY packet and validate the packet 
 3. get the encrypted D-KEY packet and validate the packet 
 4. decrypt the D-KEY with the private key of consumer 
 5. decrypt the C-KEY with the D-KEY 
 6. decrypt the data with C-KEY 

 Here is the abstraction of consumer: 

     /** 
      * @brief Consumer in group-based encryption protocol 
      */ 
     class Consumer 
     { 
     public: 
       class Error : public std::runtime_error 
       { 
       public: 
         explicit 
         Error(const std::string& what) 
           : std::runtime_error(what) 
         { 
         } 
       }; 

     public: 
       Consumer(Face& face, const Consumer(const algo::RsaPrivateKey& decryptKey); 

       
    
       /** 
        * @brief Get the data buffer published by producer 
        */ 
       Buffer 
       consume(const Name& dataName); 

     PUBLIC_WITH_TESTS_ELSE_PRIVATE: 
    
     private: 
       /** 
        * @brief authenticate the Data packet 
        */ 
       bool 
       authenticateData(const Data& Data); 

       /** 
        * @brief authenticate the C-KEY data 
        */ 
       bool 
       authenticateCKey(const Data& cKeyData); 

       /** 
        * @brief authenticate the D-KEY data 
        */ 
       bool 
       authenticateDKey(const Data& dKeyData); 

       /** 
        * @brief Get the data packet by sending interest 
        */ 
       Data 
       sendInterest(const Name& dataName); 

       
    
       /** 
        * @brief decrypt buffer by rsa decrypt key authenticate the data 
        */ 
       Buffer bool 
       decryptGroupDKey(const authenticate(const Data& DKeyData, algo::RsaPrivateKey decryptKey) const; 

       data); 
    
       /** 
        * @brief Decrypt decrypt buffer by aes rsa decrypt key 
        */ 
       Buffer 
       decryptGroupCKey(const Data& CKeyData, decryptBuffer(const uint8_t* cipherBuffer, const algo::RsaPrivateKey decryptKey) const; 

       
    
       /** 
        * @brief Decrypt decrypt buffer by aes decrypt key 
        */ 
       Buffer 
       decryptGroupData(const Data& Data, decryptBuffer(const uint8_t* cipherBuffer, const algo::AesDecryptKey decryptKey) const; 

       /** 
        * @brief Fetch the data packet replying @p interest 
        */ 
       void 
       getResultFromInterest(const Interest& interest); 

       /** 
        * @brief Callback method when there is a packet @p data replying @p interest 
        */ 
       void 
       onData(const Interest& interest, const Data& data); 

       /** 
        * @brief Callback method when there is no packet @p data replying @p interest within timeout 
        */ 
       void 
       onTimeout(const Interest& interest); 

     
    
     private: 
       enum ResultSign { 
         RESULT_DATA = 0, 
         RESULT_TIMEOUT = 1, 
         RESULT_DEFAULT = 255 
       }; 

     private: 
       ResultSign m_sign; 
       Data m_result; 

       ValidatorConfig m_validator; 
       Face& Face m_face; 
       algo::RsaPrivateKey m_decryptKey; 
     }; 

Back