One time pad algorithm in C++

This C++ application uses the one-time pad cipher technique to encrypt any message. The input is case-insensitive and compatible with all characters. In the decrypted message, white spaces are generated as random characters rather than being disregarded.

Example:

The C++ program's source code for implementing the one-time pad algorithm is available here. On a Linux system, the C++ software is successfully compiled and executed. Shown below is the program output as well.

#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++:

When applied appropriately, the One-Time Pad (OTP) algorithm provides a number of advantages that make it a secure encryption technique for specific use cases. The following are some of the OTP algorithm's main advantages:

1. Perfect Secrecy:

OTP offers perfect secrecy, which makes it theoretically indestructible if done correctly. The ciphertext is a good option for encryption since it conceals all information about the plaintext.

2. Random and Unpredictable:

OTP uses a really random key with the same length as the plaintext. An attacker's ability to decrypt the ciphertext is nearly impossible as long as the key is kept secret and is never used again.

3. Independence of Key and Plaintext:

The confidentiality and randomness of the key make OTP secure rather than the technique employed. Because of this characteristic, OTP is resistant to various cryptographic attacks, including frequency analysis and brute force assaults.

4. No Vulnerability to Cryptanalysis:

Unlike other encryption techniques, OTP is impervious to cryptographic assaults such as differential or linear cryptanalysis.

5. Robust against Quantum Attacks:

Because of its underlying ideas, OTP is regarded as secure even in the face of quantum computers.

Drawbacks of One time pad algorithm in C++:

OTP has several real-world drawbacks and difficulties. Some of them are as follows:

1. Key Distribution:

It can be difficult to distribute a key securely when it contains plaintext. The system's overall security is jeopardized if the key is stolen.

2. Key management:

Genuine randomness and never reusing keys are required. Logistically, managing and safely storing long, random keys can take time and effort.

3. Key Synchronization:

The use of keys by the sender and the recipient must be coordinated. The encryption and decryption procedures become easier if they diverge.

4. Limited Applicability:

OTP can solve the main distribution difficulties and is appropriate for specific use cases where perfect secrecy is required. With the important management and distribution concerns, it is not practical for daily communication.

Conclusion:

In conclusion, the One-Time Pad technique provides unmatched security and absolute secrecy, but it also has several real-world drawbacks, most relating to key management and distribution. It works effectively in certain situations where these difficulties can be overcome, but there are more sensible options for most regular encryption requirements.

Next TopicPrint All Permutations in Sorted (Lexicographic) Order in C++

← prev next →