Fixed issues with auto-deletion of messages
Added key serialization/deserialization functions Added experimental "soft-close" feature Added ability to chain AsyncKeys (unstable?)
This commit is contained in:
Gabriel Tofvesson
parent
88928ba722
commit
21372a9eb3
@ -163,6 +163,13 @@ namespace Crypto {
|
||||
}
|
||||
|
||||
namespace RSA {
|
||||
|
||||
KeyData::KeyData(CryptoPP::RSA::PrivateKey *priv, CryptoPP::RSA::PublicKey *pub) : privKey(priv), publKey(pub) { }
|
||||
KeyData::~KeyData() {
|
||||
delete privKey;
|
||||
delete publKey;
|
||||
}
|
||||
|
||||
// -------- RSA START --------
|
||||
KeyData* rsa_gen_keys() {
|
||||
|
||||
@ -174,7 +181,7 @@ namespace Crypto {
|
||||
|
||||
params.GenerateRandomWithKeySize(rng, 3072);
|
||||
|
||||
KeyData* k = new KeyData{ new CryptoPP::RSA::PrivateKey(params), new CryptoPP::RSA::PublicKey(params) };
|
||||
KeyData *k = new KeyData(new CryptoPP::RSA::PrivateKey(params), new CryptoPP::RSA::PublicKey(params));
|
||||
return k;
|
||||
}
|
||||
|
||||
@ -198,6 +205,44 @@ namespace Crypto {
|
||||
return (char*)shortened;
|
||||
}
|
||||
|
||||
char* serializePrivKey(CryptoPP::RSA::PrivateKey& func, ulong_64b* rSize) {
|
||||
CryptoPP::ByteQueue queue;
|
||||
func.Save(queue);
|
||||
//func.DEREncodePublicKey(queue);
|
||||
|
||||
|
||||
byte* shortened = (byte*)new byte[*rSize = queue.TotalBytesRetrievable()];
|
||||
memset(shortened, 0, *rSize);
|
||||
|
||||
std::vector<byte> spk;
|
||||
spk.resize(queue.TotalBytesRetrievable());
|
||||
|
||||
CryptoPP::ArraySink snk(&spk[0], spk.size());
|
||||
queue.CopyTo(snk);
|
||||
|
||||
for (ulong_64b t = 0; t < spk.size(); ++t) shortened[t] = spk.at(t);
|
||||
|
||||
return (char*)shortened;
|
||||
}
|
||||
|
||||
CryptoPP::RSA::PublicKey* deserializePublicKey(char* c, ulong_64b size) {
|
||||
CryptoPP::RSA::PublicKey *pK = new CryptoPP::RSA::PublicKey();
|
||||
|
||||
CryptoPP::StringSource src((const byte*)c, size, true);
|
||||
pK->Load(src);
|
||||
|
||||
return pK;
|
||||
}
|
||||
|
||||
CryptoPP::RSA::PrivateKey* deserializePrivateKey(char* c, ulong_64b size) {
|
||||
CryptoPP::RSA::PrivateKey *pK = new CryptoPP::RSA::PrivateKey();
|
||||
|
||||
CryptoPP::StringSource src((const byte*)c, size, true);
|
||||
pK->Load(src);
|
||||
|
||||
return pK;
|
||||
}
|
||||
|
||||
char* rsa_encrypt(void* msg, ulong_64b size, CryptoPP::RSA::PublicKey& pubKey, ulong_64b* resultingSize) {
|
||||
char* message = (char*)msg;
|
||||
CryptoPP::RandomPool rng;
|
||||
|
||||
@ -50,11 +50,16 @@ namespace Crypto {
|
||||
|
||||
namespace RSA {
|
||||
struct KeyData {
|
||||
CryptoPP::RSA::PrivateKey *privKey;
|
||||
CryptoPP::RSA::PublicKey *publKey;
|
||||
const CryptoPP::RSA::PrivateKey *privKey;
|
||||
const CryptoPP::RSA::PublicKey *publKey;
|
||||
KeyData(CryptoPP::RSA::PrivateKey*, CryptoPP::RSA::PublicKey*);
|
||||
~KeyData();
|
||||
};
|
||||
|
||||
char* serializeKey(CryptoPP::RSA::PublicKey&, ulong_64b* rSize);
|
||||
char* serializePrivKey(CryptoPP::RSA::PrivateKey&, ulong_64b* rSize);
|
||||
CryptoPP::RSA::PublicKey* deserializePublicKey(char* c, ulong_64b size);
|
||||
CryptoPP::RSA::PrivateKey* deserializePrivateKey(char* c, ulong_64b size);
|
||||
|
||||
KeyData* rsa_gen_keys();
|
||||
char* rsa_encrypt(void* message, ulong_64b size, CryptoPP::RSA::PublicKey& pubKey, ulong_64b* resultingSize);
|
||||
|
||||
@ -19,19 +19,22 @@ namespace IO {
|
||||
return data;
|
||||
});
|
||||
done = suppressDelete = false;
|
||||
chain = false;
|
||||
}
|
||||
AsyncKeys::AsyncKeys(Crypto::RSA::KeyData* predef) {
|
||||
done = suppressDelete = true;
|
||||
keys = predef;
|
||||
chain = false;
|
||||
}
|
||||
AsyncKeys::AsyncKeys(AsyncKeys* chainKeys) {
|
||||
this->chainKeys = chainKeys;
|
||||
chain = true;
|
||||
}
|
||||
AsyncKeys::~AsyncKeys() {
|
||||
if (!suppressDelete) {
|
||||
delete keys->privKey;
|
||||
delete keys->publKey;
|
||||
delete keys;
|
||||
}
|
||||
if (!chain && !suppressDelete) delete keys;
|
||||
}
|
||||
Crypto::RSA::KeyData* AsyncKeys::get() {
|
||||
if (chain) return chainKeys->get();
|
||||
if (!done) {
|
||||
keys = gen.get();
|
||||
}
|
||||
@ -138,12 +141,12 @@ namespace IO {
|
||||
|
||||
NetClient::NetClient(char* ipAddr, char* port, AsyncKeys *keyData, CryptoLevel level) : NetClient(ipAddr, port, level, false) { this->keyData = keyData; }
|
||||
|
||||
NetClient::NetClient(SOCKET wrap, bool noThread, AsyncKeys &keyData, CryptoLevel preferEncrypted, bool startNegotiate) :
|
||||
NetClient::NetClient(SOCKET wrap, bool noThread, AsyncKeys *keyData, CryptoLevel preferEncrypted, bool startNegotiate) :
|
||||
preferEncrypted(preferEncrypted), startNegotiate(startNegotiate)
|
||||
{
|
||||
_socket = wrap;
|
||||
this->noThread = noThread;
|
||||
this->keyData = new AsyncKeys(keyData.get());
|
||||
this->keyData = new AsyncKeys(keyData);
|
||||
sharedSetup(false);
|
||||
}
|
||||
|
||||
@ -163,6 +166,10 @@ namespace IO {
|
||||
if (isOpen()) close();
|
||||
}
|
||||
bool NetClient::close() {
|
||||
if (getBOPCount()) {
|
||||
scheduleTerminate = true;
|
||||
return true;
|
||||
}
|
||||
bool result = !_open;
|
||||
_open = false;
|
||||
result &= (SOCKET_ERROR == shutdown(_socket, SD_BOTH));
|
||||
@ -231,8 +238,9 @@ namespace IO {
|
||||
++size;
|
||||
char* msg = encrypted ? Crypto::full_auto_encrypt(bMsg, size, pK, &size) : (char*)bMsg;
|
||||
_write(msg, size);
|
||||
if (encrypted) delete[] msg;
|
||||
if (!autoDelete && encrypted) delete[] msg;
|
||||
delete[] bMsg;
|
||||
if (autoDelete) delete[] message;
|
||||
return true;
|
||||
}
|
||||
bool NetClient::write(char* message) { return write(message, strlen(message)+1); } // Send together with the null-terminator
|
||||
@ -284,7 +292,7 @@ namespace IO {
|
||||
delete[] size;
|
||||
|
||||
p.message = readSparse(sparse, p.size);
|
||||
if (encrypted) p.message = Crypto::full_auto_decrypt(p.message, *keyData->get()->privKey, &p.size);
|
||||
if (encrypted) p.message = Crypto::full_auto_decrypt(p.message, (CryptoPP::RSA::PrivateKey&)*keyData->get()->privKey, &p.size);
|
||||
|
||||
p.packetUID = p.message[0];
|
||||
if (p.packetUID != expectedNextPUID) continue; // Detect packet replay/mismatch
|
||||
@ -317,9 +325,9 @@ namespace IO {
|
||||
}
|
||||
else {
|
||||
ulong_64b size;
|
||||
char* c = Crypto::RSA::serializeKey(*keyData->get()->publKey, &size);
|
||||
char* c = Crypto::RSA::serializeKey((CryptoPP::RSA::PublicKey&)*keyData->get()->publKey, &size);
|
||||
_write(c, size); // This shouldn't be encrypted
|
||||
delete[] c;
|
||||
if(!autoDelete) delete[] c;
|
||||
}
|
||||
}
|
||||
else throw new std::exception(); // Incompatible cryptographic requirements!
|
||||
@ -348,6 +356,7 @@ namespace IO {
|
||||
close();
|
||||
}
|
||||
if (autoPing && ((time(nullptr) - commTime) > 1)) if (!ping()) { _open = false; close(); }
|
||||
if (scheduleTerminate && !getBOPCount()) close();
|
||||
}
|
||||
bool NetClient::isOpen() { return _open; }
|
||||
|
||||
@ -466,6 +475,8 @@ namespace IO {
|
||||
t.tv_sec = 0;
|
||||
t.tv_usec = 5000;
|
||||
do {
|
||||
Next:
|
||||
if (!_open) break;
|
||||
fd_set connecting;
|
||||
connecting.fd_count = 1;
|
||||
connecting.fd_array[0] = _server;
|
||||
@ -478,7 +489,7 @@ namespace IO {
|
||||
if (_open) throw new std::exception();
|
||||
else break;
|
||||
}
|
||||
NetClient* cli = new NetClient(client, true, *keyData, this->pref, false);
|
||||
NetClient* cli = new NetClient(client, true, keyData, this->pref, false);
|
||||
clients->push_back(cli);
|
||||
for (ulong_64b t = 0; t < handlers->size(); ++t)
|
||||
if (handlers->at(t)(cli))
|
||||
@ -486,6 +497,12 @@ namespace IO {
|
||||
|
||||
}
|
||||
updateClients();
|
||||
if (scheduleTerminate) {
|
||||
for (NetClient* cli : *clients)
|
||||
if (cli->getBOPCount() > 0)
|
||||
goto Next;
|
||||
break;
|
||||
}
|
||||
} while (_open);
|
||||
closesocket(_server);
|
||||
close();
|
||||
@ -493,6 +510,12 @@ namespace IO {
|
||||
}
|
||||
|
||||
bool NetServer::close() {
|
||||
for (NetClient* cli : *clients) {
|
||||
if (cli->getBOPCount() > 0) {
|
||||
scheduleTerminate = true;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
if (!_open) return false;
|
||||
_open = false;
|
||||
for (ulong_64b t = clients->size(); t > 0; --t) {
|
||||
@ -552,6 +575,10 @@ namespace IO {
|
||||
|
||||
void NetServer::setAutoPing(bool b) { for (NetClient* cli : *clients) cli->autoPing = b; }
|
||||
|
||||
ulong_64b NetServer::getClientCount() { return clients->size(); }
|
||||
|
||||
NetClient* NetServer::at(ulong_64b idx) { return clients->at(idx); }
|
||||
|
||||
|
||||
|
||||
void writeState(NetClient& cli, const char* stateName, char state) {
|
||||
|
||||
@ -35,11 +35,14 @@ namespace IO {
|
||||
private:
|
||||
std::future<Crypto::RSA::KeyData*> gen;
|
||||
Crypto::RSA::KeyData* keys;
|
||||
AsyncKeys* chainKeys;
|
||||
volatile bool done;
|
||||
bool suppressDelete;
|
||||
bool chain;
|
||||
public:
|
||||
AsyncKeys();
|
||||
AsyncKeys(Crypto::RSA::KeyData* predef);
|
||||
AsyncKeys(AsyncKeys*);
|
||||
~AsyncKeys();
|
||||
Crypto::RSA::KeyData* get();
|
||||
};
|
||||
@ -65,6 +68,7 @@ namespace IO {
|
||||
volatile bool _open; // Whether or not connection is open
|
||||
bool canWrite; // Whether or not writing to peer is possible
|
||||
bool noThread; // Whether or not reading incoming data should be / is being done in a separate thread
|
||||
bool scheduleTerminate = false;
|
||||
std::vector<char> rBuf;
|
||||
CryptoLevel preferEncrypted = CryptoLevel::None;// Whether or not the socket should attempt to request an encrypted channel
|
||||
bool encrypted = false; // Whether or not negotiation determined the use of an encrypted channel
|
||||
@ -82,7 +86,7 @@ namespace IO {
|
||||
|
||||
NetClient(char*, char*, CryptoLevel, bool); // Underlying setup for regular constructors
|
||||
NetClient(SOCKET, bool, CryptoLevel, bool);// Special setup constructor
|
||||
NetClient(SOCKET, bool, AsyncKeys&, CryptoLevel = CryptoLevel::None, bool = false);// Create wrapper for existing socket
|
||||
NetClient(SOCKET, bool, AsyncKeys*, CryptoLevel = CryptoLevel::None, bool = false);// Create wrapper for existing socket
|
||||
void sharedSetup(bool); // Setup function for all constructor
|
||||
bool _write(char*, ulong_64b); // Internal write function. Doesn't do any of the fancy auto encryption: just raw write...
|
||||
bool writeBufferedPackets(); // Flushes and deletes buffer
|
||||
@ -130,6 +134,7 @@ namespace IO {
|
||||
AsyncKeys *keyData; // Server's keysets (if using encryption)
|
||||
std::function<void()> onDestroy;
|
||||
volatile bool _open;
|
||||
bool scheduleTerminate = false;
|
||||
|
||||
void sharedSetup(char* port, std::function<bool(NetClient*)> f);
|
||||
void updateClients();
|
||||
@ -149,6 +154,8 @@ namespace IO {
|
||||
void setOnDestroy(std::function<void()>);
|
||||
bool close();
|
||||
void setAutoPing(bool);
|
||||
ulong_64b getClientCount();
|
||||
NetClient* at(ulong_64b);
|
||||
};
|
||||
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user