Ns3 Projects for B.E/B.Tech M.E/M.Tech PhD Scholars.  Phone-Number:9790238391   E-mail: ns3simulation@gmail.com

How to Implement network Hybrid Signature in ns3

To implement the network hybrid signature in ns3 requires us to simulate to network in which the nodes can be able to use cryptographic techniques like combining RSA and ECDSA to sign and certify the messages. This can enhance security by leveraging the strengths of various cryptographic algorithms.

Here’s a step-by-step process to help you implement a network hybrid signature in ns3:

Step-by-Step Implementation:

Step 1: Set Up ns3 Environment

  1. Install ns3: Make sure that you have installed the ns3 on your computer.
  2. Familiarize Yourself with ns3: Read through the ns3 tutorial to understand the basic concepts and its simulation structure.

Step 2: Set Up Cryptographic Libraries

  1. Install Cryptographic Libraries: Cryptographic operations are executed with the help of OpenSSL libraries. Make certain OpenSSL is installed.
  2. Install the Library: To use OpenSSL, follow the below instructions. For instance:

sudo apt-get install libssl-dev

Step 3: Define the Network Topology

  1. Create a Simple Network: Using ns3, to define a basic network topology which includes creating nodes, setting up channels, and configuring IP addresses. We’ll use a point-to-point topology for simplicity.

#include “ns3/core-module.h”

#include “ns3/network-module.h”

#include “ns3/internet-module.h”

#include “ns3/point-to-point-module.h”

#include “ns3/applications-module.h”

#include <openssl/rsa.h>

#include <openssl/ec.h>

#include <openssl/pem.h>

#include <openssl/err.h>

#include <iostream>

#include <sstream>

using namespace ns3;

// Helper function to generate RSA key pair

void GenerateRSAKeys(std::string &publicKey, std::string &privateKey) {

RSA *rsa = RSA_new();

BIGNUM *bne = BN_new();

BN_set_word(bne, RSA_F4);

RSA_generate_key_ex(rsa, 2048, bne, NULL);

BIO *pub = BIO_new(BIO_s_mem());

PEM_write_bio_RSAPublicKey(pub, rsa);

size_t pub_len = BIO_pending(pub);

char *pub_key = (char *)malloc(pub_len + 1);

BIO_read(pub, pub_key, pub_len);

pub_key[pub_len] = ‘\0’;

publicKey = std::string(pub_key);

BIO *pri = BIO_new(BIO_s_mem());

PEM_write_bio_RSAPrivateKey(pri, rsa, NULL, NULL, 0, NULL, NULL);

size_t pri_len = BIO_pending(pri);

char *pri_key = (char *)malloc(pri_len + 1);

BIO_read(pri, pri_key, pri_len);

pri_key[pri_len] = ‘\0’;

privateKey = std::string(pri_key);

BIO_free_all(pub);

BIO_free_all(pri);

RSA_free(rsa);

BN_free(bne);

free(pub_key);

free(pri_key);

}

// Helper function to generate ECDSA key pair

void GenerateECDSAKeys(std::string &publicKey, std::string &privateKey) {

EC_KEY *ec_key = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);

EC_KEY_generate_key(ec_key);

BIO *pub = BIO_new(BIO_s_mem());

PEM_write_bio_EC_PUBKEY(pub, ec_key);

size_t pub_len = BIO_pending(pub);

char *pub_key = (char *)malloc(pub_len + 1);

BIO_read(pub, pub_key, pub_len);

pub_key[pub_len] = ‘\0’;

publicKey = std::string(pub_key);

BIO *pri = BIO_new(BIO_s_mem());

PEM_write_bio_ECPrivateKey(pri, ec_key, NULL, NULL, 0, NULL, NULL);

size_t pri_len = BIO_pending(pri);

char *pri_key = (char *)malloc(pri_len + 1);

BIO_read(pri, pri_key, pri_len);

pri_key[pri_len] = ‘\0’;

privateKey = std::string(pri_key);

BIO_free_all(pub);

BIO_free_all(pri);

EC_KEY_free(ec_key);

free(pub_key);

free(pri_key);

}

// Helper function to sign data using RSA

std::string SignWithRSA(const std::string &data, const std::string &privateKey) {

RSA *rsa = RSA_new();

BIO *keybio = BIO_new_mem_buf((void *)privateKey.c_str(), -1);

PEM_read_bio_RSAPrivateKey(keybio, &rsa, NULL, NULL);

unsigned char hash[SHA256_DIGEST_LENGTH];

SHA256_CTX sha256;

SHA256_Init(&sha256);

SHA256_Update(&sha256, data.c_str(), data.size());

SHA256_Final(hash, &sha256);

unsigned char *signature = (unsigned char *)malloc(RSA_size(rsa));

unsigned int sig_len;

RSA_sign(NID_sha256, hash, SHA256_DIGEST_LENGTH, signature, &sig_len, rsa);

BIO_free_all(keybio);

RSA_free(rsa);

std::string signatureStr((char *)signature, sig_len);

free(signature);

return signatureStr;

}

// Helper function to verify data using RSA

bool VerifyWithRSA(const std::string &data, const std::string &signature, const std::string &publicKey) {

RSA *rsa = RSA_new();

BIO *keybio = BIO_new_mem_buf((void *)publicKey.c_str(), -1);

PEM_read_bio_RSAPublicKey(keybio, &rsa, NULL, NULL);

unsigned char hash[SHA256_DIGEST_LENGTH];

SHA256_CTX sha256;

SHA256_Init(&sha256);

SHA256_Update(&sha256, data.c_str(), data.size());

SHA256_Final(hash, &sha256);

bool result = RSA_verify(NID_sha256, hash, SHA256_DIGEST_LENGTH, (unsigned char *)signature.c_str(), signature.size(), rsa);

BIO_free_all(keybio);

RSA_free(rsa);

return result;

}

// Helper function to sign data using ECDSA

std::string SignWithECDSA(const std::string &data, const std::string &privateKey) {

EC_KEY *ec_key = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);

BIO *keybio = BIO_new_mem_buf((void *)privateKey.c_str(), -1);

PEM_read_bio_ECPrivateKey(keybio, &ec_key, NULL, NULL);

unsigned char hash[SHA256_DIGEST_LENGTH];

SHA256_CTX sha256;

SHA256_Init(&sha256);

SHA256_Update(&sha256, data.c_str(), data.size());

SHA256_Final(hash, &sha256);

ECDSA_SIG *sig = ECDSA_do_sign(hash, SHA256_DIGEST_LENGTH, ec_key);

const BIGNUM *r;

const BIGNUM *s;

ECDSA_SIG_get0(sig, &r, &s);

char *rHex = BN_bn2hex(r);

char *sHex = BN_bn2hex(s);

std::string signatureStr = std::string(rHex) + std::string(sHex);

BIO_free_all(keybio);

EC_KEY_free(ec_key);

ECDSA_SIG_free(sig);

OPENSSL_free(rHex);

OPENSSL_free(sHex);

return signatureStr;

}

// Helper function to verify data using ECDSA

bool VerifyWithECDSA(const std::string &data, const std::string &signature, const std::string &publicKey) {

EC_KEY *ec_key = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);

BIO *keybio = BIO_new_mem_buf((void *)publicKey.c_str(), -1);

PEM_read_bio_EC_PUBKEY(keybio, &ec_key, NULL, NULL);

unsigned char hash[SHA256_DIGEST_LENGTH];

SHA256_CTX sha256;

SHA256_Init(&sha256);

SHA256_Update(&sha256, data.c_str(), data.size());

SHA256_Final(hash, &sha256);

std::string rHex = signature.substr(0, signature.size() / 2);

std::string sHex = signature.substr(signature.size() / 2);

BIGNUM *r = NULL;

BIGNUM *s = NULL;

BN_hex2bn(&r, rHex.c_str());

BN_hex2bn(&s, sHex.c_str());

ECDSA_SIG *sig = ECDSA_SIG_new();

ECDSA_SIG_set0(sig, r, s);

bool result = ECDSA_do_verify(hash, SHA256_DIGEST_LENGTH, sig, ec_key) == 1;

BIO_free_all(keybio);

EC_KEY_free(ec_key);

ECDSA_SIG_free(sig);

return result;

}

class HybridSignatureApp : public Application {

public:

HybridSignatureApp() {}

virtual ~HybridSignatureApp() {}

void Setup(Address address, uint16_t port) {

m_peerAddress = address;

m_peerPort = port;

GenerateRSAKeys(m_rsaPublicKey, m_rsaPrivateKey);

GenerateECDSAKeys(m_ecdsaPublicKey, m_ecdsaPrivateKey);

}

private:

virtual void StartApplication() {

m_socket = Socket::CreateSocket(GetNode(), TypeId::LookupByName(“ns3::UdpSocketFactory”));

m_socket->Bind();

m_socket->Connect(InetSocketAddress(m_peerAddress, m_peerPort));

// Schedule the first packet transmission

Simulator::Schedule(Seconds(1.0), &HybridSignatureApp::SendPacket, this);

// Set up the receive callback

m_socket->SetRecvCallback(MakeCallback(&HybridSignatureApp::ReceivePacket, this));

}

virtual void StopApplication() {

if (m_socket) {

m_socket->Close();

m_socket = 0;

}

}

void SendPacket() {

std::string message = “Hello, this is a secure message!”;

std::string rsaSignature = SignWithRSA(message, m_rsaPrivateKey);

std::string ecdsaSignature = SignWithECDSA(message, m_ecdsaPrivateKey);

std::string packetData = message + “:” + rsaSignature + “:” + ecdsaSignature;

Ptr<Packet> packet = Create<Packet>((uint8_t *)packetData.c_str(), packetData.size());

m_socket->Send(packet);

// Schedule the next packet transmission

Simulator::Schedule(Seconds(1.0), &HybridSignatureApp::SendPacket, this);

}

void ReceivePacket(Ptr<Socket> socket) {

Ptr<Packet> packet = socket->Recv();

uint8_t buffer[1024];

packet->CopyData(buffer, packet->GetSize());

std::string packetData((char *)buffer, packet->GetSize());

size_t pos1 = packetData.find(‘:’);

size_t pos2 = packetData.find(‘:’, pos1 + 1);

 

std::string message = packetData.substr(0, pos1);

std::string rsaSignature = packetData.substr(pos1 + 1, pos2 – pos1 – 1);

std::string ecdsaSignature = packetData.substr(pos2 + 1);

bool rsaVerified = VerifyWithRSA(message, rsaSignature, m_rsaPublicKey);

bool ecdsaVerified = VerifyWithECDSA(message, ecdsaSignature, m_ecdsaPublicKey);

if (rsaVerified && ecdsaVerified) {

std::cout << “Message verified: ” << message << std::endl;

} else {

std::cout << “Message verification failed!” << std::endl;

}

}

Ptr<Socket> m_socket;

Address m_peerAddress;

uint16_t m_peerPort;

std::string m_rsaPublicKey;

std::string m_rsaPrivateKey;

std::string m_ecdsaPublicKey;

std::string m_ecdsaPrivateKey;

};

int main(int argc, char *argv[]) {

NodeContainer nodes;

nodes.Create(2); // Example: 2 nodes (1 client, 1 server)

PointToPointHelper pointToPoint;

pointToPoint.SetDeviceAttribute(“DataRate”, StringValue(“1Gbps”));

pointToPoint.SetChannelAttribute(“Delay”, StringValue(“2ms”));

NetDeviceContainer devices;

devices = pointToPoint.Install(nodes);

InternetStackHelper stack;

stack.Install(nodes);

Ipv4AddressHelper address;

address.SetBase(“10.1.1.0”, “255.255.255.0”);

Ipv4InterfaceContainer interfaces = address.Assign(devices);

uint16_t port = 9;

Ptr<HybridSignatureApp> clientApp = CreateObject<HybridSignatureApp>();

clientApp->Setup(InetSocketAddress(interfaces.GetAddress(1), port), port);

nodes.Get(0)->AddApplication(clientApp);

clientApp->SetStartTime(Seconds(2.0));

clientApp->SetStopTime(Seconds(10.0));

Ptr<HybridSignatureApp> serverApp = CreateObject<HybridSignatureApp>();

serverApp->Setup(InetSocketAddress(Ipv4Address::GetAny(), port), port);

nodes.Get(1)->AddApplication(serverApp);

serverApp->SetStartTime(Seconds(1.0));

serverApp->SetStopTime(Seconds(10.0));

Simulator::Run();

Simulator::Destroy();

return 0;

}

Explanation:

  1. Cryptographic Keys:
    • GenerateRSAKeys generates an RSA key pair.
    • GenerateECDSAKeys generates an ECDSA key pair.
  2. Signing and Verification:
    • SignWithRSA and VerifyWithRSA handle RSA signing and verification.
    • SignWithECDSA and VerifyWithECDSA handle ECDSA signing and verification.
  3. HybridSignatureApp Class:
    • This custom application class handles sending, receiving, signing, and verifying messages using both RSA and ECDSA.
    • Setup method initializes the application with the peer address, port, and generates cryptographic keys.
    • StartApplication method sets up the socket connection, schedules the first packet transmission, and sets up the receive callback.
    • SendPacket method signs a message with both RSA and ECDSA, combines the signatures, and sends the message.
    • Receive, Extract the messages and then verifies the signatures by using ReceivePacket method.
  4. Main Function:
    • Creates a simple point-to-point network with 2 nodes (client and server).
    • Initializes the HybridSignatureApp applications on both client and server nodes.
    • The client sends signed messages to the server, and then the signatures are verified by the server.

Compile and Run:

  1. Compile the Code: Make sure that OpenSSL is installed. Then, compile the code using the following command:

g++ -std=c++11 -o ns3-hybrid-signature main.cc -lssl -lcrypto `pkg-config –cflags –libs ns3-dev`

  1. Run the Simulation: Execute the compiled program:

./ns3-hybrid-signature

This setup demonstrates a simple implementation of a network hybrid signature in ns3. You can expand it further to include more sophisticated cryptographic algorithms, additional nodes, and more complex network topologies as needed.

Now, we have learned how to implement the network hybrid signature in the ns3 tool from this set up and how the cryptography used in this script with an example. If any requirement you have about the hybrid signatures, we can offer you.

We handle all kinds of project execution and implement Hybrid Signature networks using the ns3 program, so feel free to reach out to us for excellent guidance.