Cryptosystem

[gg101]

I need some help asap because my assignment is due tomorrow. Please help me out.

Write a text‐based program that can encrypt or decrypt a text file
using the “unbreakable” One‐Time Pad cryptosystem. The program should read
a text file that contains only English characters (upper and lower case) and blank
spaces, and generate an encrypted or decrypted file following these rules:
(1) For encryption: For each character p in the unencrypted file, generate a
random number r between 1 and 53. The encrypted character C will be
computed by the formula C = p + r. To do this you will need to enccrypt
characters and blank spaces following exactly this mapping:
‘a’ ‘b’ …   ‘z’ ‘A’ ‘B’ …   ‘Z’ [blank space]
1   2 … 26 27 28 … 52          53
Example: if your random number r is equal to 7, the unencrypted
character ‘z’ will be encrypted to character C = ‘z’ + 7 =  33 = ‘H’. Note
that this formula should wrap around; for example, for r = 6 and p = ‘Y’, C
= ‘Y’ + 6 = 51 + 6 = 4 = ‘d’.  
The generated sequence of random numbers r should be stored in a
separate file which is the secret key to decrypt the encrypted file.
Also, of course, you need to generate an encrypted file containing the
encrypted characters.
To run the program the user should type otp -e <unencrypted_file>
<output_file> <secret_file>, where unencrypted_file is the name of the file
you want to encrypt, output_file is the name of the file you want to give to
the encrypted file, and secret_file is the name of the file that will contain the
generated random numbers which are the key to decrypt output_file at a
later time.
(2) For decryption: For each character C in the encrypted file, read the
corresponding number r from the secret key file generated during
encryption, and compute the unencrypted character p using the formula       
p = C – r.  
Example: if your secret key number for a particular character C is r = 7,
the unencrypted character ‘H’ will be computed using the formula p = 33
– 7 = 26 = ‘z’. Note again that this formula should wrap around; for
example, for r = 6 and C = ‘d’, p = ‘d’ ‐ 6 = 4 ‐ 6 = 51 = ‘Y’.
To run the program the user should type otp -d <encrypted_file>
<output_file> <secret_file>, where encrypted_file is the name of the file
you want to decrypt, output_file is the name of the file you want to give to
the unencrypted file, and secret_file is the name of the file that contains the
generated random numbers which are the key to decrypt the output_file. 

#include<iostream>
#include<vector>
#include<stdlib.h>
#include <stdexcept>
#include <fstream>
#include <string>
#include <algorithm>
#include <stddef.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();
}
char encrypt(char c, int r)
{
const char chmap[] =
"abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
" ";
// find the position of the char in the char map
char *p = std::find(chmap, chmap + sizeof(chmap), p);
if (p == chmap + sizeof(chmap))
throw std::domain_error("Input character out of range");

// find the index of the char
ptrdiff_t idx = p - chmap;

// add on the random offset
idx += r;
idx = idx % sizeof(chmap);

return chmap + idx;
}
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;
}