qkd-app-004.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 QKD_SEND_H004
#define QKD_SEND_H004
 
#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 QKDApp004 : public Application 
{ 
public:
    static TypeId GetTypeId (void);
    
    QKDApp004 ();
 
    virtual     ~QKDApp004();
 
    void SetKsidEncryption(UUID val){
        m_ksid_enc = val;
    }
 
    void SetKsidAuthentication(UUID val){
        m_ksid_auth = val;
    }
    
    enum QKDAppState {
        NOT_STARTED,
        INITIALIZED,
        ESTABLISHING_ASSOCIATIONS,
        ASSOCIATIONS_ESTABLISHED,
        ESTABLISHING_KEY_QUEUES,
        KEY_QUEUES_ESTABLISHED, 
        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
    );
 
    struct      KMSPacket
    {
        Ptr<Packet> packet = 0;
        uint32_t methodType = 0;
        uint32_t keyType = 0;
        std::string ksid = "";
        std::string uri = "";
    };
 
    uint32_t    ScheduleAction(Time t, std::string action);
 
 
    void        CancelScheduledAction(uint32_t eventId);
 
    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        HandlePeerCloseToKMS (Ptr<Socket> socket);
 
    void        HandlePeerErrorFromKMS (Ptr<Socket> socket);
    
    void        HandlePeerErrorToKMS (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);
 
    void        RegisterAckTime (Time oldRtt, Time newRtt);
 
    bool        ConnectionRequestedFromKMS (Ptr<Socket> socket, const Address &address);
 
    void        PrepareSinkSocketFromKMS();
 
    void        PrepareSendSocketToKMS();
 
    void        PrepareSinkSocketFromApp();
 
    void        PrepareSendSocketToApp();
    
    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        ProcessSignalingPacketFromApp(HTTPMessage& header, Ptr<Socket> socket);
 
    void        ProcessDataPacketFromApp(QKDAppHeader header, Ptr<Packet> packet, Ptr<Socket> socket);
 
    void        OpenConnect (std::string ksid, uint32_t keyType = 0);
 
    void        GetKeyFromKMS (std::string ksid, uint32_t index = 0);
 
    void        Close (std::string ksid);
 
    void        ProcessOpenConnectResponse (HTTPMessage& header);
 
    void        ProcessGetKeyResponse (HTTPMessage& header);
 
    void        ProcessCloseResponse (HTTPMessage& header);
 
    void    SendKsidRequest (std::string ksid, uint32_t input);
    
    void    SendKsidResponse (HTTPMessage::HttpStatus httpStatus, std::string msg = "");
 
    void    ProcessSendKsidResponse (HTTPMessage& header, std::string ksid);
 
    /*
     * \brief Create a key stream session entry.
     */
    void    CreateKeyStreamAssociations ();
 
    void        SetEncryptionAndAuthenticationSettings(
      uint32_t encryptionType, 
      uint32_t authenticationType,
      uint32_t authenticationTagLengthInBits
    );
 
    uint32_t    GetEncryptionKeySize();
 
    uint32_t    GetAuthenticationKeySize ();
 
    uint64_t    GetMaxEncryptionKeyRate();
 
    uint64_t    GetMaxAuthenticationKeyRate();
  
    QKDAppState GetAppState () const;
 
    std::string GetAppStateString () const;
 
    static std::string GetAppStateString (QKDAppState state);
 
    void SwitchAppState (QKDAppState state);
 
    UUID GetId (void) {
        return m_id;
    }
 
    std::string GetPacketContent(uint32_t msgLength = 0);
 
    TracedCallback<Ptr<const Packet>, std::string > m_txTrace; //<! A trace for transmitted data packets.
    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; 
 
    Ptr<Socket> GetSendSocketToKMS() {
        return m_sendSocketToKMS;
    }
 
    Ptr<Socket> GetSinkSocketFromKMS() {
        return m_sinkSocketFromKMS;
    }
 
private:
 
    UUID            m_ksid_enc; 
    UUID            m_ksid_auth; 
    
    struct QKDAppKey
    {
        uint32_t index;
        std::string key;
        uint32_t lifetime; //Lifetime in bytes!
    };
 
    struct Association004
    {
        std::string ksid;
        bool verified;
        uint32_t queueSize;
        uint32_t keyActive;
        std::map<uint32_t, QKDAppKey> buffer; //queue
    };
 
    std::pair<Association004, Association004> m_associations; 
 
    bool m_primaryQueueEstablished; 
    bool m_replicaQueueEstablished; 
 
    Ptr<UniformRandomVariable> m_random; 
 
    void                InitializeAssociations ();
 
    void                CheckAssociationsState ();
 
    void                CreateKeyQueues ();
 
    void                CheckQueues ();
 
    void                CreateKeyQueuesResponse ();
 
    void                ClearAssociation (std::string ksid);
 
    void                ProcessCreateQueuesResponse ();
 
    QKDAppKey           GetEncKey ();
 
    QKDAppKey           GetAuthKey ();
 
    void                Http004KMSQuery (std::string uri, std::string ksid, uint32_t keyType);
 
    void                Http004AppQuery (uint32_t methodType, std::string ksid);
 
    void                Http004KMSQueryComplete (std::string uri);
 
    void                Http004AppQueryComplete (void);
 
    uint32_t            GetMethodFromHttp004KMSQuery (std::string uri);
 
    std::string         GetKsidFromHttp004KMSQuery (std::string uri);
 
    uint32_t            GetKeyTypeFromHttp004KMSQuery (std::string uri);
 
    uint32_t            GetMethodFromHttp004AppQuery (void);
 
    std::string         GetKsidFromHttp004AppQuery (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);
 
    std::string         PacketToString (Ptr<Packet> packet);
 
    void SendPacket (void);
 
    void SendMaliciousRequestToKMS ();
 
    void ProcessPacketsToKMSFromQueue();
 
    void CloseSocketToKms();
     
    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;  
    double          m_delay; 
 
    DataRate        m_dataRate; 
    DataRate        m_minDataRate;  
    
    EventId         m_sendEvent; 
    EventId         m_closeSocketEvent;  
    Time            m_holdTime; 
 
    uint32_t        m_packetsSent; 
    uint32_t        m_dataSent; 
    TypeId          m_tid; 
    uint32_t        m_master; 
    uint32_t        m_malicious; 
 
    Ptr<Packet>     m_maliciousPacket; 
    Time            m_dosAttackIntensity; 
 
 
    uint32_t        m_priority; 
    uint32_t        m_ttl; 
 
    //HTTP mapping responses to requests!
    std::vector<std::pair<uint32_t, std::string> > m_httpRequestsApp; 
    std::map<std::string, std::pair<std::string, uint32_t> > m_httpRequestsKMS; 
    
    UUID            m_id; 
    UUID            m_dstSaeId; 
    
    static uint32_t m_applicationCounts; 
 
    //Crypto params
    uint32_t    m_useCrypto; 
    uint32_t    m_encryptionTypeInt; 
    uint32_t    m_authenticationTypeInt; 
    uint32_t    m_authenticationTagLengthInBits; 
    uint32_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; 
    
    TracedCallback<const uint32_t&> m_obtainedKeyMaterialTrace; 
    QKDEncryptor::EncryptionType m_encryptionType; 
    QKDEncryptor::AuthenticationType m_authenticationType; 
    Ptr<QKDEncryptor> m_encryptor; 
    uint32_t    m_keyBufferLengthEncryption; 
    uint32_t    m_keyBufferLengthAuthentication; 
 
    QKDAppState m_appState; 
 
    std::vector<KMSPacket > m_queue_kms; 
 
    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_qkdapp; 
 
    std::map<uint32_t, EventId > m_scheduledEvents;  
    std::multimap<std::string, std::string> m_transitionMatrix; 
 
};
 
 
} // namespace ns3
 
#endif /* QKD_SINK_H004 */