Fixed issues with auto-deletion of messages

Added key serialization/deserialization functions
Added experimental "soft-close" feature
Added ability to chain AsyncKeys (unstable?)

CPPTools/Crypto.cpp

@@ -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;

CPPTools/Crypto.h

@@ -50,11 +50,16 @@ namespace Crypto {
 
 	namespace RSA {
 		struct KeyData {
-			CryptoPP::RSA::PrivateKey *privKey;
+			const CryptoPP::RSA::PrivateKey *privKey;
-			CryptoPP::RSA::PublicKey *publKey;
+			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);

CPPTools/Net.cpp

@@ -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) {
+		if (!chain && !suppressDelete) delete keys;
-			delete keys->privKey;
-			delete keys->publKey;
-			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) {

CPPTools/Net.h

@@ -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);
 	};