qkd-app-014.h

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2020 DOTFEESA www.tk.etf.unsa.ba
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author:  Emir Dervisevic <emir.dervisevic@etf.unsa.ba>
 *          Miralem Mehic <miralem.mehic@ieee.org>
 */
#ifndef QKD014_SEND_H
#define QKD014_SEND_H
 
#include "ns3/application.h"
#include "ns3/event-id.h"
#include "ns3/ptr.h"
#include "ns3/traced-callback.h"
#include "ns3/address.h"
#include "ns3/core-module.h"
#include "ns3/applications-module.h"
#include "ns3/random-variable-stream.h"
#include "ns3/core-module.h" 
#include "ns3/http.h"
#include "qkd-app-header.h"
#include "ns3/qkd-encryptor.h"
#include <unordered_map> 
#include <string> 
#include "ns3/uuid.h"
 
#include <iostream>
#include <sstream>
#include <unistd.h>
 
namespace ns3 {
 
class Address;
class Socket;
class Packet;
 
class QKDApp014 : public Application 
{ 
public:
    static TypeId GetTypeId (void);
 
    QKDApp014 ();
 
    virtual     ~QKDApp014();
 
    void SetKsidEncryption(UUID val){
        m_ksid_enc = val;
    }
 
    void SetKsidAuthentication(UUID val){
        m_ksid_auth = val;
    }
    
    struct      QKDApp014Key
    {
        std::string key;
        std::string keyId;
        uint32_t keyType; //0-enc key, 1-auth key
        uint64_t lifetime; //Value of lifetime used with ciphers such as AES! Value is exspresed in seconds!
                                            //Lifetime is counted from the first use!
    };
 
    struct      QKDApp014KeyBuffer
    {
        std::map<std::string, QKDApp014Key> outboundEncKeyStore; //Store for enc keys used for outbound traffic!
        std::map<std::string, QKDApp014Key> outboundAuthKeyStore; //Store for auth keys used for outbound traffic!
        std::map<std::string, QKDApp014Key> inboundKeyStore; //Store for enc/auth keys used for inbound traffic!        
        std::map<std::string, QKDApp014Key> temporaryKeyStoreMaster; //Temporary memory for keys to be negotiated with peer QKDApp014!
 
    };
 
    enum QKDApp014State {
        NOT_STARTED,
        INITIALIZED,
        READY,
        WAIT,
        SEND_DATA,
        DECRYPT_DATA,
        STOPPED
    };
 
    void        Setup (
        std::string socketType,
        Address src,  
        Address dst,  
        Address kms,  
        UUID    dstSaeId,
        std::string type
    );
 
    void        Setup (
        std::string socketType,
        Address src,
        Address dst, 
        Address kms,
        UUID    dstSaeId,
        uint32_t packetSize,
        uint32_t nPackets,
        DataRate dataRate,
        std::string type
    );
 
 
    void        InitializeAppKeyBuffer();
 
    void        RemoveKeysFromTemporaryKeyStore (std::vector<std::string> keyIds);
 
 
    void        AddKeyInInboundKeyStore (QKDApp014::QKDApp014Key& key);
 
    void        AddEncKeyInKeyStore (QKDApp014::QKDApp014Key& key);
 
    void        AddAuthKeyInKeyStore (QKDApp014::QKDApp014Key& key);
 
    void        PrintTemporaryKeyStoreContent ();
 
    void        PrintAppBufferStatusInformation ();
 
    void        CheckAppBufferState ();
 
    void        CheckAppState ();
 
    void        GetStatusFromKMS (uint32_t keyType);
 
    void        GetKeysFromKMS (uint32_t keyType);
 
    void        GetKeyWithKeyIDs();
 
    void        ConnectionToKMSFailed (Ptr<Socket> socket);
 
    void        ConnectionToKMSSucceeded (Ptr<Socket> socket);
 
    void        ConnectionToAppFailed (Ptr<Socket> socket);
 
    void        ConnectionToAppSucceeded (Ptr<Socket> socket);
 
    void        ConnectionSignalingToAppFailed (Ptr<Socket> socket);
 
    void        ConnectionSignalingToAppSucceeded (Ptr<Socket> socket);
 
    void        DataToKMSSend (Ptr<Socket>, uint32_t);
 
    void        HandleReadFromKMS (Ptr<Socket> socket);
 
    void        HandlePeerCloseFromKMS (Ptr<Socket> socket);
 
    void        HandlePeerErrorFromKMS (Ptr<Socket> socket);
    
    void        HandleAcceptFromKMS (Ptr<Socket> s, const Address& from);
 
    void        HandleReadFromApp (Ptr<Socket> socket);
 
    void        HandlePeerCloseFromApp (Ptr<Socket> socket);
 
    void        HandlePeerErrorFromApp (Ptr<Socket> socket);
    
    void        HandleAcceptFromApp (Ptr<Socket> s, const Address& from);
 
    void        HandleReadSignalingFromApp (Ptr<Socket> socket);
 
    void        HandlePeerCloseSignalingFromApp (Ptr<Socket> socket);
 
    void        HandlePeerErrorSignalingFromApp (Ptr<Socket> socket);
    
    void        HandleAcceptSignalingFromApp (Ptr<Socket> s, const Address& from);
 
    bool        ConnectionRequestedFromKMS (Ptr<Socket> socket, const Address &address);
    
    void        PacketReceivedFromKMS (const Ptr<Packet> &p, const Address &from, Ptr<Socket> socket);
 
    void        SignalingPacketReceivedFromApp (const Ptr<Packet> &p, const Address &from, Ptr<Socket> socket);
 
    void        DataPacketReceivedFromApp (const Ptr<Packet> &p, const Address &from, Ptr<Socket> socket);
 
    void        ProcessResponseFromKMS(HTTPMessage& header, Ptr<Packet> packet, Ptr<Socket> socket);
 
    void        ProcessStatusResponse (HTTPMessage& header, nlohmann::json jstatusResponse);
 
    void        ProcessGetKeyResponse (HTTPMessage& header, nlohmann::json jGetKeyResponse);
 
    void        ProcessGetKeyWithKeyIDsResponse(HTTPMessage& header, nlohmann::json jGetKeyWithKeyIDsResponse);
 
    void        ProcessSignalingPacketFromApp(HTTPMessage& header, Ptr<Packet> packet, Ptr<Socket> socket);
 
    void        ProcessDataPacketFromApp(QKDAppHeader header, Ptr<Packet> packet, Ptr<Socket> socket);
 
    void        PrepareSinkSocketFromKMS();
 
    void        PrepareSendSocketToKMS();
 
    void        PrepareSinkSocketFromApp();
 
    void        PrepareSendSocketToApp();
 
    uint32_t    ScheduleAction(Time t, std::string action);
 
    void        CancelScheduledAction(uint32_t eventId);
 
    void        SetEncryptionAndAuthenticationSettings(
      uint32_t encryptionType, 
      uint32_t authenticationType,
      uint32_t authenticationTagLengthInBits
    );
 
    uint32_t    GetEncryptionKeySize();
 
    uint32_t    GetAuthenticationKeySize ();
 
    QKDApp014::QKDApp014Key   GetKeyFromAppKeyBuffer (uint32_t keyType);
 
    QKDApp014::QKDApp014Key   GetKeyFromAppKeyBuffer (std::string keyId, std::string keyType);
  
    QKDApp014State GetAppState () const;
 
    std::string GetAppStateString () const;
 
    static std::string GetAppStateString (QKDApp014State state);
 
    UUID GetId (void) {
        return m_id;
    }
    
    void SwitchAppState (QKDApp014State state);
 
 
    std::string GetPacketContent(uint32_t msgLength = 0);
 
    TracedCallback<Ptr<const Packet>, std::string > m_txTrace; 
    TracedCallback<Ptr<const Packet> > m_txSigTrace; 
    TracedCallback<Ptr<const Packet> > m_txKmsTrace; 
    TracedCallback<Ptr<const Packet>, std::string > m_rxTrace; 
    TracedCallback<Ptr<const Packet> > m_rxSigTrace; 
    TracedCallback<Ptr<const Packet> > m_rxKmsTrace; 
    ns3::TracedCallback<const std::string &, const std::string &> m_stateTransitionTrace; 
    TracedCallback<Ptr<const Packet>, std::string > m_mxTrace; 
 
private:
 
 
    void MemoriesRequestKMS (uint32_t methodType, uint32_t keyType = 0);
 
    std::string CreateKeyIdField(std::string keyId);
 
    std::string ReadKeyIdField(std::string keyId);
 
    void MemoriesRequestApp (std::vector<std::string> keyIds);
 
    void RequestProcessedKMS (void);
 
    void RequestProcessedApp (void);
 
    uint32_t GetETSIMethod (void);
 
    uint32_t GetKeyType (void);
 
    struct AddressHash
    {
    size_t operator() (const Address &x) const
    {
      NS_ABORT_IF (!InetSocketAddress::IsMatchingType (x));
      InetSocketAddress a = InetSocketAddress::ConvertFrom (x);
      return std::hash<uint32_t>()(a.GetIpv4 ().Get ());
    }
    };
 
    virtual void StartApplication (void);
    virtual void StopApplication (void);
 
    void ScheduleTx (void);
 
    void AppTransitionTree (void);
 
    void ExchangeInfoMessages(
        std::string ksid, 
        std::vector<std::string> keyIds, 
        HTTPMessage::HttpStatus statusCode = HTTPMessage::Ok
    );
    
    void SendPacket (void);
 
    Ptr<Socket>     m_sendSignalingSocketApp;  
    Ptr<Socket>     m_sinkSignalingSocketApp;  
    Ptr<Socket>     m_sendDataSocketApp; 
    Ptr<Socket>     m_sinkDataSocketApp; 
    
    Ptr<Socket>     m_sendSocketToKMS;      
    Ptr<Socket>     m_sinkSocketFromKMS;    
 
    Address         m_peer;             
    Address         m_peerSignaling;    
 
    Address         m_local;            
    Address         m_localSignaling;   
 
    Address         m_kms;              
 
    std::string     m_socketType;       
    
    uint32_t        m_packetSize;       
    DataRate        m_dataRate;         
    EventId         m_sendEvent;        
    uint32_t        m_packetsSent;      
    uint32_t        m_dataSent;         
    TypeId          m_tid;              
    uint32_t        m_master;           
 
    Time            m_waitInsufficient; 
    Time            m_waitTransform;    
 
    Ptr<UniformRandomVariable> m_random;
 
    QKDApp014KeyBuffer m_appKeyBuffer;  
    nlohmann::json  m_keyIDs;           
 
    //HTTP mapping responses to requests!
    std::vector<std::pair<uint32_t, uint32_t> > m_httpRequestsKMS;  
    std::vector<std::vector<std::string> > m_httpRequestsApp;       
 
    UUID            m_id;               
    UUID            m_dstSaeId;         
 
    UUID            m_ksid_enc;         
    UUID            m_ksid_auth;        
 
    static uint32_t m_applicationCounts; 
 
    //LKMS PARAMS
    uint32_t        m_numberOfKeysKMS; 
 
    //Crypto params
    uint32_t    m_useCrypto;                                
    uint32_t    m_encryptionTypeInt;                        
    uint32_t    m_authenticationTypeInt;                    
    uint32_t    m_authenticationTagLengthInBits;            
    uint64_t    m_aesLifetime;                              
    TracedCallback<Ptr<Packet> > m_encryptionTrace; 
    TracedCallback<Ptr<Packet> > m_decryptionTrace; 
    TracedCallback<Ptr<Packet>, std::string > m_authenticationTrace; 
    TracedCallback<Ptr<Packet>, std::string > m_deauthenticationTrace; 
    QKDEncryptor::EncryptionType m_encryptionType; 
    QKDEncryptor::AuthenticationType m_authenticationType; 
    Ptr<QKDEncryptor> m_encryptor; 
 
    TracedCallback<const uint32_t&> m_obtainedKeyMaterialTrace; 
 
    QKDApp014State m_appState; 
 
    std::unordered_map<Address, Ptr<Packet>, AddressHash> m_buffer_kms; 
    std::unordered_map<Address, Ptr<Packet>, AddressHash> m_buffer_sig; 
    std::unordered_map<Address, Ptr<Packet>, AddressHash> m_buffer_QKDApp014; 
 
    bool m_internalAppWait; 
    std::map<uint32_t, EventId > m_scheduledEvents;  
    std::multimap<std::string, std::string> m_transitionMatrix; 
 
};
 
 
} // namespace ns3
 
#endif /* QKD_SINK_H */