How to Implement Certificateless Cryptography in NS2

To implement the Certificateless Cryptography is a different of the public key cryptography, which removes the need for the digital certificates, although preventing the key escrow problem of identity-based cryptography (IBC). In certificateless cryptography, a Key Generation Center (KGC) makes a partial private keys for the users rely on its identities, however users also generate its own secret values and public/private key pairs. It delivers a balance among the security and simplicity, without the need for the certificates or depend on solely on the KGC for security. In the simulation environment NS2, we can be replicated the certificateless cryptography by signifying the key generation, encryption, and decryption processes using a KGC, sender, and receiver nodes. Below is a stepwise process on how to replicate the Certificateless Cryptography in NS2:

Step-by-Step Implementation:

  1. Set Up NS2

Make certain that NS2 is installed on the computer. If not, we can install it using the below command:

sudo apt-get install ns2

  1. Define the Network Topology

Make a simple basic network topology with a Key Generation Center (KGC), sender, and receiver nodes. The KGC will create the partial private keys for both the sender and receiver rely on their identities.

set ns [new Simulator]

set tracefile [open certificateless_crypto.tr w]

$ns trace-all $tracefile

# Create sender, receiver, and KGC nodes

set sender [$ns node]

set receiver [$ns node]

set kgc [$ns node]  ;# Key Generation Center (KGC) node

# Create links between the sender, receiver, and KGC

$ns duplex-link $sender $kgc 1Mb 10ms DropTail

$ns duplex-link $kgc $receiver 1Mb 10ms DropTail

  1. Simulate Key Generation by the KGC

In certificateless cryptography, the KGC makes a partial private keys for users rely on their identities. Every user will then generate their own public or private key pairs and combine them with the partial private key delivered by the KGC.

(A) Generate Partial Private Key from KGC

Mimic a key generation by the KGC that a partial private key is generated according to the user’s identity.

# Simulate identities for sender and receiver

set sender_identity “sender@example.com”

set receiver_identity “receiver@example.com”

# Function to simulate partial private key generation by the KGC

proc generate_partial_private_key {identity} {

puts “KGC generating partial private key for identity: $identity”

return “partial_priv_key_$identity”  ;# Return a simulated partial private key

}

# Generate partial private keys for sender and receiver

set sender_partial_key [generate_partial_private_key $sender_identity]

set receiver_partial_key [generate_partial_private_key $receiver_identity]

  1. Simulate User-Generated Key Pairs

After receiving the partial private key from the KGC, every user will generate its own public or private key pairs and aggregate them with the partial private key for full key generation.

(A) Generate Public/Private Key Pairs for Each Node

Every node will generate their own public or private key pair independently then replicating the certificateless cryptography process.

# Simulate public/private key pair generation by the sender and receiver

proc generate_user_key_pair {identity} {

puts “Generating public/private key pair for $identity”

set public_key “public_key_$identity”

set private_key “private_key_$identity”

return [list $public_key $private_key]  ;# Return both keys

}

# Generate key pairs for sender and receiver

set sender_key_pair [generate_user_key_pair $sender_identity]

set sender_public_key [lindex $sender_key_pair 0]

set sender_private_key [lindex $sender_key_pair 1]

set receiver_key_pair [generate_user_key_pair $receiver_identity]

set receiver_public_key [lindex $receiver_key_pair 0]

set receiver_private_key [lindex $receiver_key_pair 1]

  1. Combine Partial and User-Generated Keys

In certificateless cryptography, the last private key is a combination of the partial private key from the KGC then the user-generated private key. It make sure that no single entity (KGC or user) has full control across the private key.

(A) Combine Partial Private Key with User-Generated Private Key

Aggregate the keys to replicate full private key generation.

# Function to combine the partial private key with the user’s private key

proc combine_keys {partial_key user_private_key} {

puts “Combining partial key: $partial_key with user key: $user_private_key”

return “combined_key_$partial_key_$user_private_key”  ;# Return the combined key

}

# Combine the keys for sender and receiver

set sender_final_private_key [combine_keys $sender_partial_key $sender_private_key]

set receiver_final_private_key [combine_keys $receiver_partial_key $receiver_private_key]

  1. Encrypt and Decrypt Messages Using Certificateless Cryptography

When the keys are configure then the sender can encrypt messages using the receiver’s public key. The receiver will be decrypted the message using its final private key.

(A) Encrypt Message Using Receiver’s Public Key

Replicate an encryption using the receiver’s public key.

# Simulate message encryption using the receiver’s public key

proc encrypt_message {message receiver_public_key} {

puts “Encrypting message: ‘$message’ using receiver’s public key: $receiver_public_key”

return “encrypted_$message_with_$receiver_public_key”  ;# Simulate encrypted message

}

# Encrypt a message at 1 second using receiver’s public key

$ns at 1.0 “set encrypted_message [encrypt_message ‘Hello Receiver!’ $receiver_public_key]”

(B) Decrypt Message Using Receiver’s Final Private Key

Mimic decryption using the receiver’s final private key (combined key from KGC and user-generated key).

# Simulate message decryption using the receiver’s final private key

proc decrypt_message {encrypted_message final_private_key} {

puts “Decrypting message: ‘$encrypted_message’ using final private key: $final_private_key”

return “decrypted_message”  ;# Simulate decrypted message

}

# Decrypt the message at the receiver node

$ns at 1.5 “set decrypted_message [decrypt_message $encrypted_message $receiver_final_private_key]”

  1. Simulate Secure Data Transmission between Sender and Receiver

Here, replicate the real data transmission using CBR (Constant Bit Rate) traffic generator within NS2. The message will encrypt using the receiver’s public key also decrypted using the receiver’s final private key.

# Set up UDP agents for sender and receiver

set udp_sender [new Agent/UDP]

set udp_receiver [new Agent/Null]

$ns attach-agent $sender $udp_sender

$ns attach-agent $receiver $udp_receiver

$ns connect $udp_sender $udp_receiver

# Create a CBR traffic generator to simulate message transmission

set cbr_sender [new Application/Traffic/CBR]

$cbr_sender set packetSize_ 512

$cbr_sender set rate_ 1Mb

$cbr_sender attach-agent $udp_sender

# Encrypt message and send it at 2.0 seconds

$ns at 2.0 “set encrypted_message [encrypt_message ‘Secure Message’ $receiver_public_key]”

$ns at 2.0 “$cbr_sender start”

# Decrypt message at the receiver

$ns at 2.5 “set decrypted_message [decrypt_message $encrypted_message $receiver_final_private_key]”

  1. Log the Encryption and Decryption Process

Log the encryption and decryption process to make sure that the message was securely transferred and received.

# Log the encryption and decryption process

proc log_encryption {message encrypted_message} {

puts “Original message: ‘$message’ was encrypted as: ‘$encrypted_message'”

}

proc log_decryption {encrypted_message decrypted_message} {

puts “Encrypted message: ‘$encrypted_message’ was decrypted as: ‘$decrypted_message'”

}

# Log the encryption and decryption process

$ns at 2.0 “log_encryption ‘Secure Message’ $encrypted_message”

$ns at 2.5 “log_decryption $encrypted_message $decrypted_message”

  1. Run the Simulation

When the script is ready then we can run the simulation using NS2:

ns your_script.tcl

  1. Analyze the Results

After running the simulation then verify the trace file (certificateless_crypto.tr) and console results to check:

  • Partial private keys were generated appropriately by the KGC.
  • Public/private key pairs were generated freely by the users.
  • Messages are encrypted using the receiver’s public key and decrypted using the combined final private key.

Also we can be used the NAM (Network Animator) to envision how the encrypted message is forwarded securely among the nodes.

  1. Extend the Simulation

We can extend this execution by:

  • Simulating key revocation: Append the functionality for the KGC to revoke partial private keys in case of compromise.
  • Adding more nodes: Replicate a larger network in which numerous multiple users communicate securely using certificateless cryptography.
  • Introducing attacks: Mimic network attacks (e.g., eavesdropping, man-in-the-middle) to analyse the robustness of the certificateless cryptographic system.
  • Simulating key updates: Permit the nodes to periodically update its keys to improve security.

Here, we had shown the well-ordered procedure to replicate and implement the Certificateless Cryptography within the virtual environment NS2. As well, we will be shared further details regarding this topic in another manual.

Our developers are focused on certificateless cryptography, which involves defining the key generation, encryption, and decryption processes through a Key Generation Center (KGC), along with sender and receiver nodes. If you need assistance with implementation, feel free to reach out to our team for personalized support.