Encrypt unsigned int value in form of bits stream by AES_CFB mode

Question

I have c++ code that encrypts a string as a plaintext using AES_CFB and generates a same size ciphertext, but the problem is the data type of input and output, So could anyone help me to let it encrypts an unsigned int number and generates unsigned int number ciphertext withe keeping the same length for the plaintext and chipertext (length of bits ).

string ENCRYPTOR(const std::string& PlainText)
{
    byte key[16]= "1234ff";//  byte key[ CryptoPP::AES::DEFAULT_KEYLENGTH ];
    byte iv[16]= "123456";//byte iv[ CryptoPP::AES::BLOCKSIZE ];

    std::string CipherText;

    // Encryptor
    CryptoPP::CFB_Mode< CryptoPP::AES >::Encryption encryptor( key, sizeof(key), iv);

    // Encryption
    CryptoPP::StringSource( PlainText, true,
        new CryptoPP::StreamTransformationFilter( encryptor,
            new CryptoPP::StringSink( CipherText ) ) ); 

    return (CipherText);
}

string DECRYPTOR(const string& CipherText)
{
    byte key[16]= "1234ff";
    byte iv[16]= "123456"; 

    std::string RecoveredText;

    // Decryptor
    CryptoPP::CFB_Mode< CryptoPP::AES >::Decryption decryptor( key, sizeof(key), iv );

    // Decryption
    CryptoPP::StringSource( CipherText, true,
        new CryptoPP::StreamTransformationFilter( decryptor,
            new CryptoPP::StringSink( RecoveredText ) ) ); 

    return (RecoveredText);
}

int main()
{
    string ciphertext;
    string plaintext = "3555";
    ciphertext= ENCRYPTOR(plaintext);
    string retrivdat = DECRYPTOR(ciphertext);

    cout<<"The plaintext data is:  "<<plaintext<<endl;
    cout<<"The ciphertextdata is:  "<<ciphertext<<endl;
    Coot<<"The retrieved data is:  "<<retrivdat<<end;

    return 0;
}

---

The output is

The plaintext data is:  3555
The chepertext data is:  ï¥R_
The retrieved data is:  3555

Answer 1

Encrypt unsigned int value in form of bits stream by AES_CFB mode

Igor and Owlstead raised some valid points about size of integers and endianess. The easiest solution to avoid them is probably encode the integer as a string:

unsigned int n = ...;
ostringstream oss;

oss << n;

string plainText = oss.str();

Later, you can convert it back with:

string recovered = ...;
istringstream iss(recovered);

unsigned int n;
iss >> n;

---

byte key[16]= "1234ff";//  byte key[ CryptoPP::AES::DEFAULT_KEYLENGTH ];
byte iv[16]= "123456";//byte iv[ CryptoPP::AES::BLOCKSIZE ];

Your key and IV are too small. You should be getting compiler warnings because of it. AES::DEFAULT_KEYLENGTH is 16, so you need at least 16 characters for the key. AES::BLOCKSIZE is 16, so you need at least 16 characters for the initialization vector.

If the code above happens to work, then its purely because of luck. You should probably visit CFB Mode on the Crypto++ wiki. It has a working example.

Alternately, use PBKDF to stretch the short key and short IV. You can find an example at Crypto++ pbkdf2 output is different than Rfc2898DeriveBytes (C#) and crypto.pbkdf2 (JavaScript) on Stack Overflow.

---

The chepertext data is: ï¥R_

You can make this printable with:

string encoded;
HexEncoder hexer(new StringSink(encoded));

hexer.Put((byte*)cipherText.data(), cipherText.size());
hexer.MessageEnd();

cout << encoded << endl;

Alternately, you can use the following (with pipelines):

string encoded;

StringSource ss(cipherText, true,
    new HexEncoder(
        new StringSink(encoded)));

cout << encoded << endl;

HexEncoder and HexDecoder are discussed on the Crypto++ wiki, too.

Answer 2

So you can:

1. encode the number into the minimum number of x bytes, for instance using an unsigned big endian number
2. encrypt with CFB, resulting in the same number of x bytes
3. decrypt the number
4. decode the number from the resulting x bytes (using the same encoding scheme of course)

If you want to see the ciphertext as number you'll have to decode the ciphertext as if it was a (signed or unsigned) number.

Note that you will still have to deal with the uniqueness of the IV. If you need to store the IV then there will be significant overhead.