One Time Pad Algorithm In C++

This C++ program applies the one-time pad encryption method to secure messages. The input is not case-sensitive and supports all types of characters. When decrypting the message, spaces are introduced as random characters instead of being ignored.

Example:

The source code of the C++ program that implements the one-time pad encryption algorithm can be accessed here. The C++ application has been compiled and run without any issues on a Linux operating system. Below is the output generated by the program.

#include<iostream>
#include<vector>
#include<stdlib.h>
using namespace std;
void to_upper_case(vector<char>& text, int len)
{
for (int i = 0; i < len; i++)
{
if (text[i] >= 97 && text[i] <= 122)
text[i] -= 32;
}
}
void print_string(vector<char> text, int len)
{
for (int i = 0; i < len; i++)
{
cout << (char) (text[i] + 65);
}
cout << endl;
return;
}
size_t get_input(vector<char>& msg)
{
char a;
while (1)
{
a = getchar();
if (a == '\n')
break;
msg.push_back(a);
}
return msg.size();
}
int main()
{
vector<char> msg;
vector<char> enc_msg;
vector<char> dec_msg;
int *p;
int i;
size_t len;
cout << "Enter Message to Encrypt:";
len = get_input(msg);
to_upper_case(msg, len);
p = (int*) malloc(msg.size() * sizeof(int));
for (i = 0; i < len; i++)
{
p[i] = rand() % 26;
if (msg[i] >= 65 && msg[i] <= 90)
enc_msg.push_back((char) ((msg[i] - 65 + p[i]) % 26));
else if (msg[i] >= 97 && msg[i] <= 122)
enc_msg.push_back((char) ((msg[i] - 97 + p[i]) % 26));
else
enc_msg.push_back((char) msg[i]);
}
cout << "\nEncoded Message:";
print_string(enc_msg, len);
cout << "\nKey for decryption:\n";
for (i = 0; i < len; i++)
{
cout << (char) (p[i] + 65);
}
cout << endl;
cout << "\nDecrypted Message:";
for (i = 0; i < len; i++)
{
if ((enc_msg[i] - p[i]) < 0)
dec_msg.push_back((char) (enc_msg[i] - p[i] + 26));
else if ((enc_msg[i] - p[i]) >= 0)
dec_msg.push_back((char) (enc_msg[i] - p[i]));
else
dec_msg.push_back((char) enc_msg[i]);
}
print_string(dec_msg, len);
return 0;
}

Output:

Note: The key is printed on stdout since it is necessary for decryption. Nonetheless, disclosing the key to the public is not safe.

Benefits of One time pad algorithm in C++:

1. Unrivaled Confidentiality: The One-Time Pad (OTP) algorithm ensures unparalleled secrecy when implemented correctly, making it a highly secure encryption method for certain scenarios.

OTP provides absolute confidentiality, rendering it theoretically impervious if implemented correctly. The encrypted message serves as an effective choice for securing data as it completely obscures any details of the original message.

1. Random and Unpredictable:

The one-time pad (OTP) employs an extremely random key that matches the length of the plaintext. Decrypting the ciphertext is nearly impossible for an attacker as long as the key remains confidential and is not reused.

1. Key and plaintext independence:

The security of OTP relies on the confidentiality and randomness of the key, making it a secure method irrespective of the specific technique used. This unique characteristic ensures OTP's resilience against different cryptographic attacks such as frequency analysis and brute force attempts.

1. Immune to Cryptanalysis:

Unlike other encryption methods, OTP is resistant to cryptographic attacks like differential or linear cryptanalysis. It also stands strong against Quantum Attacks:

Due to its fundamental principles, OTP is considered secure even when confronted with quantum computers.

Drawbacks of One time pad algorithm in C++:

OTP presents various practical limitations and challenges. Below are some of the issues encountered:

1. Key Distribution:

It may pose a challenge to securely share a key that is in plain text. The security of the entire system is at risk if the key is compromised.

1. Managing Keys:

Authentic unpredictability and ensuring unique keys are essential. From a logistical standpoint, the process of handling and securely storing lengthy, random keys can be time-consuming and labor-intensive.

1. Synchronization of Keys:

The coordination of keys between the sender and receiver is essential for secure communication. Simplification of encryption and decryption processes is achieved when the keys used by each party differ.

1. Restricted Applicability:

One-time passwords (OTPs) can effectively address the primary challenges in distributing sensitive information and are well-suited for scenarios demanding utmost confidentiality. Due to the significant management and distribution complexities involved, OTPs may not be feasible for routine communication purposes.

Conclusion:

In summary, the One-Time Pad method offers unparalleled security and complete confidentiality, yet it comes with various practical limitations, primarily concerning the handling and sharing of encryption keys. While it proves efficient in specific scenarios with solutions to these challenges, there are generally more practical alternatives for typical encryption needs.