qkd-sdn-controller.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_SDN_CONTROLLER_H
#define QKD_SDN_CONTROLLER_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/json.h"
#include <unordered_map>
#include "ns3/http.h"
#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 QKDSDNController : public Application
{
public:
 
  enum RequestType
  {
    NONE = 50,
    GET_ROUTE = 12, 
    REGISTER_SAE_LINK = 13,
    REGISTER_QKD_LINK = 14,
    KEY_ASSOCIATION_STATUS = 15,
    
    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);
 
  QKDSDNController ();
 
  virtual ~QKDSDNController (); 
 
  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();
 
  void AddNewLink(
    uint32_t srcSaeId,
    uint32_t dstSaeId,  
    Ipv4Address kmsDstAddress,
    Ptr<QKDBuffer> srcBuffer
  );
  
  void RegisterSaePair(
    Ptr<Node> srcNode, 
    Ptr<Node> dstNode,
    uint32_t  srcSaeId,
    uint32_t  dstSaeId,
    std::string type
  );
  
  void SetNode(Ptr<Node> n);
 
  Ptr<Node> GetNode();
 
  uint32_t GetId();
   
  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;
  }
  
protected:
 
  virtual void DoDispose (void);
 
private:
  
  QKDSDNController::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);    // Called at time specified by Start
 
  void StopApplication (void);     // Called at time specified by Stop
 
  void SendToSocketPair (Ptr<Socket> socket, Ptr<Packet> packet);
 
  void SendToSocketPairKMS (Ptr<Socket> socket, Ptr<Packet> packet);
 
  void HandleRead (Ptr<Socket> socket);
 
  void HandleAccept (Ptr<Socket> s, const Address& from);
 
  void HandlePeerClose (Ptr<Socket> socket);
  
  void HandlePeerError (Ptr<Socket> socket);
 
  void PacketReceived (const Ptr<Packet> &p, const Address &from, Ptr<Socket> socket);
  
  void      ProcessRequest(HTTPMessage header, Ptr<Packet> packet, Ptr<Socket> socket);
 
  /*
   * \brief Process OPEN_CONNECT request - ETSI QKD GS 004
   * \param header received request
   * \param socket receiving socket
   */
  void      ProcessOpenConnectRequest(HTTPMessage header, Ptr<Socket> socket); 
 
  /*
   * \brief Process GET_KEY request - ETSI QKD GS 004
   * \param ksid Unique identifier of the association
   * \param header received request
   * \param socket receiving socket
   */
  void      ProcessGetKey004Request(std::string ksid, HTTPMessage header, Ptr<Socket> socket);
 
  /*
   * \brief Process CLOSE request - ETSI QKD GS 004
   * \param ksid Unique identifier of the association
   * \param header received request
   * \param socket receiving socket
   */
  void      ProcessCloseRequest(std::string ksid, HTTPMessage header, Ptr<Socket> socket);
 
  /*
   * \brief Process NEW_APP request
   * \param header received request
   * \param socket receiving socket
   */
  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      ReleaseAssociation (std::string ksid, std::string surplusKeyId, uint32_t syncIndex);
 
  //nlohmann::json Check014GetKeyRequest(nlohmann::json request, QKDLocationRegisterEntry conn);
 
  nlohmann::json CreateKeyContainer (std::vector<Ptr<QKDKey>> keys);
 
  std::string Base64Encode(std::string input);
 
  std::string Base64Decode(std::string input);
 
 
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;
    uint32_t sae_id; //Needed to specify buffer to fetch the key from
 
    //Specific to ETSI 004 (NEW_APP)
    uint32_t source_sae;
    uint32_t 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
  {
    uint32_t srcSaeId; //Source application that requested the KSID
    uint32_t 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!
  };
 
  double          m_qkdLinkDefaultUpdateInterval; 
 
  std::map<std::string, Association004> m_associations004; //Associations map
 
  Ptr<Socket>     m_sinkSocket;       // Associated socket
 
  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; //key counter to generate unique keyIDs on KMS
  
  EventId         m_closeSocketEvent;  
 
  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_rxTraceSDNs; 
  TracedCallback<Ptr<const Packet> > m_txTraceSDNs; 
  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 &, const uint32_t&, Ptr<QKDKey> > m_keyServedETSI014Trace;
  TracedCallback<const std::string &, const uint32_t&, const uint32_t&, const uint32_t& > m_keyServedETSI004Trace;
  
  uint32_t        m_maxKeyPerRequest; //Maximal number of keys per request QKDApp can ask for
  uint32_t        m_minKeySize; //Minimal size of key QKDApp can request from KMS
  uint32_t        m_maxKeySize; //Maximal size of key QKDApp can request from KMS
  uint32_t        m_defaultKeySize; //Default size of key KMS delivers to QKDApp
 
  std::unordered_map<Address, 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; //<! node on which KMS is installed 
  std::map<Ptr<Socket>, Ptr<Packet> > m_packetQueues; 
 
  Ptr<QKDKMSQueueLogic> m_queueLogic; 
 
  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
 
 
  std::map<Ipv4Address, std::vector<HttpQuery> > m_httpRequestsQueryKMS;
  std::multimap<uint32_t, Ptr<Socket> > m_http004App; //SAE_ID, receiving socket
 
  void  HttpKMSAddQuery(Ipv4Address dstKms, HttpQuery request);
 
  void  HttpKMSCompleteQuery(Ipv4Address dstKms);
 
  RequestType HttpQueryMethod(Ipv4Address dstKms);
 
  void  Http004AppQuery (uint32_t saeId, Ptr<Socket> socket);
 
  void  Http004AppQueryComplete (uint32_t saeId);
 
  Ptr<Socket> GetSocketFromHttp004AppQuery (uint32_t saeId);
 
  Ipv4Address GetDestinationKmsAddress (Ptr<Socket> socket);
 
  void CheckSocketsKMS (Ipv4Address dstSaeId);
 
  Ptr<Socket> GetSendSocketKMS (Ipv4Address kmsDstAddress);
 
  std::string PacketToString (Ptr<Packet> packet);
 
  void  ReadJsonQos (  
      QKDSDNController::QoS &inQos, 
      nlohmann::json jOpenConnectRequest );
  
  std::string CreateNew004Association (
      uint32_t srcSaeId, uint32_t dstSaeId, 
      QKDSDNController::QoS inQos, 
      Ipv4Address dstKms, std::string ksid );
 
 
};
 
} // namespace ns3
 
#endif /* QKD_APPLICATION_H */