qkd-key-manager-system-application.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_KEY_MANAGER_SYSTEM_APPLICATION_H
#define QKD_KEY_MANAGER_SYSTEM_APPLICATION_H
 
#include "ns3/address.h"
#include "ns3/application.h"
#include "ns3/event-id.h"
#include "ns3/ptr.h"
#include "ns3/data-rate.h"
#include "ns3/traced-callback.h"
#include "ns3/random-variable-stream.h" 
#include "ns3/qkd-buffer.h"
#include "ns3/qkd-connection-register.h"
#include "ns3/qkd-key-association-link-entry.h"
#include "ns3/qkd-application-entry.h"
#include "ns3/qkd-kms-queue-logic.h" 
#include "ns3/random-variable-stream.h"
#include "ns3/http.h" 
#include "ns3/json.h"
#include <unordered_map>
#include "ns3/uuid.h"
 
#include <iostream>
#include <sstream>
#include <unistd.h>
#include <sstream>
#include <string>
#include <regex>
#include <cryptopp/base64.h>
 
 
namespace ns3 {
 
class Address;
class Socket;
 
class QKDKeyManagerSystemApplication : public Application
{
public:
 
  enum RequestType
  {
    
    NONE = 50,
    ETSI_QKD_014_GET_STATUS = 0,              
    ETSI_QKD_014_GET_KEY = 1,                 
    ETSI_QKD_014_GET_KEY_WITH_KEY_IDS = 2,    
    ETSI_QKD_004_OPEN_CONNECT = 3,
    ETSI_QKD_004_GET_KEY = 4,
    ETSI_QKD_004_CLOSE = 5,
    NEW_APP = 6,
    REGISTER = 7,
    FILL = 8,
    STORE_PP_KEYS = 9, //Store postprocessing keys
    TRANSFORM_KEYS = 10, //Transform (merge, split) QKD keys
    ETSI_QKD_004_KMS_CLOSE = 11
  };
 
  static TypeId GetTypeId (void);
 
  QKDKeyManagerSystemApplication ();
 
  virtual ~QKDKeyManagerSystemApplication (); 
 
  Ptr<Socket> GetSocket (void) const;
 
  //void PrepareOutput (std::string key, uint32_t value); @toDo ? not used
 
  void SetSocket (std::string type, Ptr<Socket> socket);
 
  uint32_t GetTotalRx () const;
 
  std::map<Ptr<Socket>, Ptr<Socket> > GetAcceptedSockets (void) const;
  
 
  uint32_t GetMaxKeyPerRequest();
 
  std::string AddNewLink(
    uint32_t srcSaeId,
    uint32_t dstSaeId,  
    Ipv4Address kmsDstAddress,
    Ptr<QKDBuffer> srcBuffer
  );
 
  std::string AddNewLink(
    uint32_t srcSaeId,
    uint32_t dstSaeId,  
    Ipv4Address kmsDstAddress,
    Ptr<QKDBuffer> srcBuffer,
    std::string keyAssociationId
  );
  
  QKDApplicationEntry
  RegisterApplicationEntry(
    UUID  keyAssociationId,
    UUID  applicationEntryId,
    UUID  srcSaeId,
    UUID  dstSaeId, 
    std::string type,     
    Ipv4Address dstKmsAddress,
    uint32_t priority, 
    double expirationTime
  );
 
  QKDApplicationEntry
  RegisterApplicationEntry(
    UUID  srcSaeId,
    UUID  dstSaeId,
    std::string type,
    Ipv4Address dstKmsAddress,
    uint32_t priority, 
    double expirationTime
  );
 
  void SetNode(Ptr<Node> n);
 
  Ptr<Node> GetNode();
 
  uint32_t GetId();
  
  bool AddNewKey(Ptr<QKDKey> key, uint32_t srcNodeId, uint32_t dstNodeId);
 
  void SetAddress(Ipv4Address address) {
    m_local = address;
  }
 
  Ipv4Address GetAddress() {
    return m_local;
  }
 
  void SetPort(uint32_t port) {
    m_port = port;
  };
 
  uint32_t GetPort() {
    return m_port;
  }
 
  void ConnectToSDNController();
 
  void SetSDNControllerAddress(Address sdnAddress){
    m_sdnControllerAddress = sdnAddress;
    m_sdnSupportEnabled = true;
  }
 
  void SendQKDLinkStatusToSDN(UUID linkId, double updatePeriod);
 
  void SaveKeyAssociation(QKDKeyAssociationLinkEntry& rt);
  
protected:
 
  virtual void DoDispose (void);
 
private:
 
  static uint32_t     nKMS;       
 
  uint32_t m_sdnSupportEnabled;   
  Address m_sdnControllerAddress; 
  
  QKDApplicationEntry GetApplicationConnectionDetails(std::string saeId);
 
  QKDKeyAssociationLinkEntry GetKeyAssociationLinkDetailsByApplicationId(std::string appId);
 
  QKDKeyAssociationLinkEntry GetKeyAssociationByNodeIds(uint32_t srcNodeId, uint32_t dstNodeId);
 
  QKDKeyAssociationLinkEntry GetKeyAssociationById(UUID keyAssociationId);
 
  QKDApplicationEntry GetApplicationConnectionDetailsBySaeIDsAndType(
    std::string srcSaeId, 
    std::string dstSaeId,
    QKDApplicationEntry::ConnectionType type
  );
 
  QKDKeyManagerSystemApplication::RequestType FetchRequestType (std::string s );
 
  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 ());
    }
  };
 
  // inherited from Application base class.
  void StartApplication (void);
 
  void StopApplication (void);
 
  void SendToSocketPair (Ptr<Socket> socket, Ptr<Packet> packet);
 
  void SendToSocketPairKMS (Ptr<Socket> socket, Ptr<Packet> packet);
 
  void HandleRead (Ptr<Socket> socket);
 
  void HandleReadKMSs (Ptr<Socket> socket);
 
  void HandleReadSDN (Ptr<Socket> socket);
 
  void HandleAccept (Ptr<Socket> s, const Address& from);
 
  void HandlePeerClose (Ptr<Socket> socket);
  
  void HandlePeerError (Ptr<Socket> socket);
 
  void HandleAcceptKMSs (Ptr<Socket> s, const Address& from);
 
  void HandleAcceptSDN (Ptr<Socket> s, const Address& from);
 
  void HandlePeerCloseKMSs (Ptr<Socket> socket);
  
  void HandlePeerCloseSDN (Ptr<Socket> socket);
  
  void HandlePeerErrorKMSs (Ptr<Socket> socket);
 
  void HandlePeerErrorSDN (Ptr<Socket> socket);
 
  void PacketReceived (const Ptr<Packet> &p, const Address &from, Ptr<Socket> socket);
  
  void PacketReceivedKMSs (const Ptr<Packet> &p, const Address &from, Ptr<Socket> socket);
 
  void PacketReceivedSDN (const Ptr<Packet> &p, const Address &from, Ptr<Socket> socket);
 
 
  void      ProcessRequest(HTTPMessage header, Ptr<Packet> packet, Ptr<Socket> socket);
 
  void      ProcessPacketKMSs(HTTPMessage header, Ptr<Packet> packet, Ptr<Socket> socket);
 
  void      ProcessResponseSDN (HTTPMessage header, Ptr<Packet> packet, Ptr<Socket> socket);
 
  void      ProcessRequestSDN (HTTPMessage header, Ptr<Packet> packet, Ptr<Socket> socket);
 
  void      ProcessRequestKMS (HTTPMessage header, Ptr<Socket> socket);
 
  void      ProcessResponseKMS (HTTPMessage header, Ptr<Packet> packet, Ptr<Socket> socket);
 
  void      ProcessPPRequest (HTTPMessage header, Ptr<Packet> packet, Ptr<Socket> socket);
 
  /*
   * \brief Process the OPEN_CONNECT request - ETSI QKD GS 004.
   * \param header The received HTTP message.
   * \param socket The receiving socket.
   */
  void      ProcessOpenConnectRequest(HTTPMessage header, Ptr<Socket> socket); 
 
  /*
   * \brief Process the GET_KEY request - ETSI QKD GS 004.
   * \param ksid The key stream identifier.
   * \param header The received HTTP message.
   * \param socket The receiving socket.
   */
  void      ProcessGetKey004Request(std::string ksid, HTTPMessage header, Ptr<Socket> socket);
 
  /*
   * \brief Process the CLOSE request - ETSI QKD GS 004.
   * \param ksid The key stream identifier.
   * \param header The received HTTP message.
   * \param socket The receiving socket.
   */
  void      ProcessCloseRequest(std::string ksid, HTTPMessage header, Ptr<Socket> socket);
 
  /*
   * \brief Process the NEW_APP request.
   * \param header The received HTTP message.
   * \param socket The receiving socket.
   *
   * The KMS process the NEW_APP request received from the peer KMS. This request
   * notifies the KMS about a new key stream session.
   */
  void      ProcessNewAppRequest(HTTPMessage header, Ptr<Socket> socket);
  
  void      ProcessNewAppResponse (HTTPMessage header, Ptr<Socket> socket);
 
  void      RegisterRequest (std::string ksid);
 
  void      ProcessRegisterRequest (HTTPMessage header, std::string ksid, Ptr<Socket> socket);
 
  void      ProcessRegisterResponse(HTTPMessage header, Ptr<Socket> socket);
  
  void      PrepareSinkSocket ();
 
  void      ProcessAddKeysRequest (HTTPMessage h, Ptr<Socket> socket, std::string ksid);
 
  void      ProcessAddKeysResponse (HTTPMessage header, Ptr<Socket> socket);
  
  void      TransformKeys (uint32_t keySize, uint32_t keyNumber, UUID slave_SAE_ID);
 
  void      ProcessTransformRequest(HTTPMessage header, Ptr<Socket> socket);
 
  void      ProcessTransformResponse(HTTPMessage header, Ptr<Socket> socket);
 
  void      ProcessKMSCloseRequest (HTTPMessage header, Ptr<Socket> socket, std::string ksid);
 
  void      ProcessKMSCloseResponse(HTTPMessage header, Ptr<Socket> socket);
 
  void      ReleaseAssociation (std::string ksid, std::string surplusKeyId, uint32_t syncIndex);
 
  nlohmann::json Check014GetKeyRequest(nlohmann::json request, QKDKeyAssociationLinkEntry conn);
 
  nlohmann::json CreateKeyContainer (std::vector<Ptr<QKDKey>> keys);
 
  std::string Base64Encode(std::string input);
 
  std::string Base64Decode(std::string input);
 
  std::vector<std::string> ProcessUriParams(std::string s);
 
  void PurgeExpiredAssociations();
 
private:
 
  struct QoS
  {
    uint32_t chunkSize; //Key_chunk_size
    uint32_t maxRate; //Max_bps
    uint32_t minRate; //Min_bps
    uint32_t jitter; //Jitter
    uint32_t priority; //Priority
    uint32_t timeout; //Timeout
    uint32_t TTL; //Time to Live
    //metadata mimetype is left out
  };
 
  struct ChunkKey
  {
    uint32_t index;
    uint32_t chunkSize;
    bool ready;
    std::string key; //key of key_chunk_size
    //std::vector<std::pair<std::string, std::pair<uint32_t, uint32_t> > > keyIds; //"QKDKey"s that form ChunkKey
                        //keyId                  start      end
  };
 
  struct HttpQuery
  {
    RequestType method_type; //For every query!
    
    //Specific to TRANSFORM
    uint32_t transform_key_size;
    uint32_t transform_key_number;
    std::vector<std::string> transform_key_IDs;
    std::vector<std::string> to_transform_key_IDs;
    std::string surplus_key_ID;
    UUID sae_id; //Needed to specify buffer to fetch the key from
 
    //Specific to ETSI 004 (NEW_APP)
    UUID source_sae;
    UUID destination_sae;
    std::string ksid;
 
    //Specific to ETSI 004 (KMS CLOSE)
    uint32_t sync_index;
 
  };
 
  struct Association004 //Holds information of the association and dedicated key store
  {
    UUID ksid;
    UUID srcSaeId; //Source application that requested the KSID
    UUID dstSaeId; //Destination application 
    uint32_t associationDirection; //0-Outbound, 1-Inbound - Important while monitoring the associations!
    QoS qos; //Quality of service
    Ipv4Address dstKmsNode; //Address of the destination KMS. Important!
    bool peerRegistered; //KMS must know the state of connection for association on peer KMS!
    std::map<uint32_t, ChunkKey> buffer; //index & key ; index is KeyId for key of the association
    uint32_t lastIndex;
    std::vector<std::string> tempBuffer; //Buffer for keys in negotiation. It holds only KeyIds, while keys are in QKDBuffer!
  };
 
  std::map<std::string, Association004> m_associations004; 
  Ptr<Socket>     m_sinkSocket;           
  Ptr<Socket>     m_sendSocketToSDN;      
  Ptr<Socket>     m_sinkSocketFromSDN;    
  Ipv4Address     m_local;                
  uint32_t        m_port;                 
  uint32_t        m_totalRx;              
  uint32_t        m_totalRxKMSs;          
  TypeId          m_tid;                  
  uint32_t        m_kms_id;               
  uint32_t        m_kms_key_id;           
  EventId         m_closeSocketEvent;     
  Ptr<UniformRandomVariable> m_random;    
 
  std::map<uint32_t, EventId > m_scheduledChecks; 
  std::map<Ipv4Address, uint32_t> m_flagedIPAdr;  
  uint32_t        m_maliciousBlocking;            
 
  TracedCallback<Ptr<const Packet>, const Address &> m_rxTrace;     
  TracedCallback<Ptr<const Packet> > m_txTrace;                     
  TracedCallback<Ptr<const Packet>, const Address &> m_rxTraceKMSs; 
  TracedCallback<Ptr<const Packet> > m_txTraceKMSs;                 
  TracedCallback<Ptr<const Packet>, const Address &> m_rxTraceSDN;  
  TracedCallback<Ptr<const Packet> > m_txTraceSDN;                  
  TracedCallback<const Ipv4Address&, Ptr<const Packet> > m_dropTrace; 
 
  TracedCallback<const uint32_t&> m_newKeyGeneratedTraceEmir; 
  TracedCallback<const uint32_t&> m_keyServedTraceEmir;       
 
  TracedCallback<const uint32_t& , const uint32_t&> m_newKeyGeneratedTrace; 
 
  TracedCallback<const std::string &, Ptr<QKDKey> > m_keyServedETSI014Trace; 
  TracedCallback<const std::string &, const uint32_t&, const uint32_t& > m_keyServedETSI004Trace; 
 
  TracedCallback<   
    const std::string &, 
    const std::string &, 
    const uint32_t&, 
    const uint32_t&, 
    const uint32_t&, 
    const uint32_t&, 
    const uint32_t&
  > m_providedQoS; 
  
  uint32_t        m_maxKeyPerRequest; 
  uint32_t        m_minKeySize; 
  uint32_t        m_maxKeySize; 
  uint32_t        m_defaultKeySize; 
 
  std::unordered_map<uint64_t, Ptr<Packet>, AddressHash> m_buffer; 
  std::unordered_map<Address, Ptr<Packet>, AddressHash> m_bufferKMS; 
 
  // In the case of TCP, each socket accept returns a new socket, so the
  // listening socket is stored separately from the accepted sockets
  std::map<Ptr<Socket>, Ptr<Socket> > m_socketPairs;  
 
  std::map<Ipv4Address, std::pair<Ptr<Socket>, Ptr<Socket> > > m_socketPairsKMS;  
 
  Ptr<Node> m_node; //<! The node on which the KMS is installed.
  std::map<Ptr<Socket>, Ptr<Packet> > m_packetQueues; 
  std::map<Ptr<Socket>, Ptr<Packet> > m_packetQueuesToSDN; 
 
  Ptr<QKDKMSQueueLogic> m_queueLogic; 
 
  std::map<std::string, uint32_t> m_sessionList; 
  double m_qos_maxrate_threshold; 
 
  void CheckSessionList(std::string ksid);
 
 
  DataRate        m_maxKeyRate; 
  DataRate        m_minKeyRate; 
  uint32_t        m_default_ttl; 
 
  bool connectedToSDN; 
  
  void ConnectionSucceeded (Ptr<Socket> socket);
 
  void ConnectionFailed (Ptr<Socket> socket);
 
  void DataSend (Ptr<Socket>, uint32_t); // for socket's SetSendCallback
 
  void ConnectionSucceededKMSs (Ptr<Socket> socket);
 
  void ConnectionFailedKMSs (Ptr<Socket> socket);
 
  void DataSendKMSs (Ptr<Socket>, uint32_t); // for socket's SetSendCallback
 
  void ConnectionToSDNSucceeded (Ptr<Socket> socket);
 
  void ConnectionToSDNFailed (Ptr<Socket> socket);
 
  void DataToSDNSend (Ptr<Socket>, uint32_t); // for socket's SetSendCallback
 
  bool CheckDoSAttack(HTTPMessage headerIn, Ptr<Socket> socket);
 
  std::map<Ipv4Address, std::vector<HttpQuery> > m_httpRequestsQueryKMS; 
  std::multimap<UUID, Ptr<Socket> > m_http004App; 
  
  void  HttpKMSAddQuery(Ipv4Address dstKms, HttpQuery request);
 
  void  HttpKMSCompleteQuery(Ipv4Address dstKms);
 
  RequestType HttpQueryMethod(Ipv4Address dstKms);
 
  void  Http004AppQuery (UUID saeId, Ptr<Socket> socket);
 
  void  Http004AppQueryComplete (UUID saeId);
 
  Ptr<Socket> GetSocketFromHttp004AppQuery (UUID saeId);
 
  Ipv4Address GetDestinationKmsAddress (Ptr<Socket> socket);
 
  void CheckSocketsKMS (Ipv4Address dstSaeId);
 
  Ptr<Socket> GetSendSocketKMS (Ipv4Address kmsDstAddress);
 
  std::string PacketToString (Ptr<Packet> packet);
 
  void  ReadJsonQos (  
      QKDKeyManagerSystemApplication::QoS &inQos, 
      nlohmann::json jOpenConnectRequest );
  
  void CreateNew004Association (
      std::string srcSaeId, 
      std::string dstSaeId, 
      QKDKeyManagerSystemApplication::QoS &inQos, 
      Ipv4Address dstKms, 
      std::string &ksid,
      std::string appConnectionId
  );
 
  bool ProcessQoSRequest(
    QKDApplicationEntry &appConnection,
    QKDKeyAssociationLinkEntry &keyAssociation,
    QKDKeyManagerSystemApplication::QoS &inQos,
    QKDKeyManagerSystemApplication::QoS &outQos,
    std::string ksid
  );  
 
  void  NewAppRequest (std::string ksid);
 
  std::string GenerateKsid ();
 
  void  MonitorAssociations ();
 
  void  CheckAssociation (std::string ksid);
 
  uint32_t  ScheduleCheckAssociation(Time t, std::string action, std::string ksid);
 
  void  NegotiateKeysForAssociation (std::string ksid, uint32_t keyAmount = 1024, uint32_t priority = 0);
 
  void  AddKeyToAssociationDedicatedStore (std::string ksid, Ptr<QKDKey> key);
 
  std::string GenerateKeyId();
 
 
};
 
} // namespace ns3
 
#endif /* QKD_APPLICATION_H */