Salsa20 using Crypto++ - c++

Question

I am trying to use the salsa20 code in the crypto++ Library. ( http://www.cryptopp.com/) to communicate between two programs.
Both programs use the same code which follows
std::string salsaDo(std::string key, std::string msg, byte iv[STREAM_IV_LENGTH]) {
//Set up byte arrays for proccess
byte *plaintextBytes = (byte *)msg.c_str();
byte *ciphertextBytes = new byte[msg.length()];
byte *reversetextBytes = new byte[msg.length()];
//Set up key array
byte* keyBytes = (byte *)key.substr(0, STREAM_KEY_LENGTH).c_str();
//Peform encryption method
Salsa20::Encryption salsa;
salsa.SetKeyWithIV(keyBytes, STREAM_KEY_LENGTH, iv);
salsa.ProcessData(ciphertextBytes, plaintextBytes, msg.length());
salsa.SetKeyWithIV(keyBytes, STREAM_KEY_LENGTH, iv);
salsa.ProcessData(reversetextBytes, ciphertextBytes, msg.length());
std::string ivStr((char*)iv, STREAM_IV_LENGTH);
std::cout << "____\nK:" << key.c_str();
std::cout << "\nI:" << ivStr.c_str();
std::cout << "\nM:" << msg.c_str();
std::cout << "\nE:" << std::string((const char *)ciphertextBytes, msg.length()).c_str();
std::cout << "\nR:" << std::string((const char *)reversetextBytes, msg.length()).c_str();
std::cout << "\n____\n";
//return msg;
//return string
return std::string((const char *)ciphertextBytes, msg.length());
}
An image from the programs is at http://s21.postimg.org/wgfmkjcn9/encrypt.png
Explanation:
Step1 : plain text is encrypted (server-M to server-E)
Step2 : encrypted text is decrypted (Server-E to server-R and client-M to client-E.) These two should give the same result but don't
Step3 : client-E is run through again to check that it equals the msg the server sent.

Answer 1

There are a few problems with this code.
This line technically invokes Undefined Behavior:
byte* keyBytes = (byte *)key.substr(0, STREAM_KEY_LENGTH).c_str();
In this case, the substr() call returns a temporary std::string object containing the substring. The lifetime of this temporary std::string extends through the evaluation of the entire line (the full expression). The lifetime of the C string returned by std::string::c_str() is the same as the std::string, except that it is invalidated by a mutating operation. Thus, in this full expression, keyBytes is likely an invalid pointer once the line has executed.
You can fix the problem by overwriting key to the desired substring. In this case, assigning to key ensures that the lifetime is extended through where it is used:
key = key.substr(0, STREAM_KEY_LENGTH);
const byte* keyBytes = static_cast<const byte*>(key.c_str());
This salsaDo() function leaks memory. The byte arrays created by:
byte *ciphertextBytes = new byte[msg.length()];
byte *reversetextBytes = new byte[msg.length()];
.. are not freed. Consider using a std::unique_ptr<byte[]>:
std::unique_ptr<byte[]> ciphertextBytes(new byte[msg.length()]);
std::unique_ptr<byte[]> reversetextBytes(new byte[msg.length()]);
C++ does not technically support passing arrays to functions. The parameter byte iv[STREAM_IV_LENGTH] is actually treated as if you had written byte* iv instead.
You could pass a reference to the array. Also, for const-correctness, you should mark the initialization vector bytes const:
std::string salsaDo(std::string key, std::string msg, const byte (&iv)[STREAM_IV_LENGTH])
{
//...
}
I wouldn't use a std::string to store the key, or really any array of bytes such as the returned encrypted bytes. Consider using a std::unique_ptr<byte[]> or std::shared_ptr<byte[]>, or passing a reference to a const array, or passing a pointer and length (e.g. const byte* key and size_t keyLength).