xtunnelstestmain.cpp

xtunnel nat/fw traversal source code

      }
	// no reply to EMessageClientRequestSendPacket 
	CheckNoMoreData();

//#pragma mark *** EMessageClientRequestClosePort

	cout << "testing EMessageClientRequestClosePort from " << lastGoodPort << "..." << endl;
	g_tSendingPacket.m_tHeaderBasic.commandid = HOST2XT32(EMessageClientRequestClosePort);
	ulPacketsize = sizeof(ClientRequestClosePortParam);
	g_tSendingPacket.m_tHeaderBasic.payloadsize = HOST2XT32(ulPacketsize);
	g_tSendingPacket.m_tData.clientrequestcloseport.closeport = HOST2XT16(lastGoodPort);
	if (SendPacketToMasterServer(&g_tSendingPacket, ulPacketsize))
		{
		cout << "error sending EMessageClientRequestClosePort!" << endl;
		return 1;
		}
		
	// no reply to EMessageClientRequestClosePort 
	CheckNoMoreData();

//#pragma mark *** test X-Cipher

   char* szConnectWithXCipherTo = "[e-mail]";
	cout << "testing EMessageClientRequestXCipherSecureConversationKey to " << szConnectWithXCipherTo << "..." << endl;
	g_tSendingPacket.m_tHeaderBasic.commandid = HOST2XT32(EMessageClientRequestXCipherSecureConversationKey);
	ulPacketsize = 
	      sizeof(unsigned short)
	      + strlen(szConnectWithXCipherTo)
	      + sizeof(uuid_t);
	g_tSendingPacket.m_tData.m_tRequestKey.m_usRemoteUserAtHostSize = HOST2XT16(strlen(szConnectWithXCipherTo));
	strcpy(g_tSendingPacket.m_tData.m_tRequestKey.m_szRemoteUserAtHost, szConnectWithXCipherTo);
	uuid_t* m_tConversationSessionGUIDPtr = (uuid_t*)&g_tSendingPacket.m_tData.m_tRequestKey.m_szRemoteUserAtHost[strlen(szConnectWithXCipherTo)];
	memset(m_tConversationSessionGUIDPtr, 5, sizeof(uuid_t));
	if (SendPacketToMasterServer(&g_tSendingPacket, ulPacketsize))
		{
		cout << "error sending EMessageClientRequestXCipherSecureConversationKey!" << endl;
		return 1;
		}
		
	// server replies with results
	
	TServerToClientReplyXCipherSecureConversationKeyParam tXCipherResultUnpacked = { 0 };
   pReturnedPacket = GetMasterServerPacket(sClientPacketEncryption, EMessage_ServerToClient_ReplyXCipherSecureConversationKey);
   if (!pReturnedPacket)
		{
		cout << "error receiving EMessage_ServerToClient_ReplyXCipherSecureConversationKey!" << endl;
		return 1;
		}
   tXCipherResultUnpacked.m_usRemoteUserAtHostSize = XT2HOST16(pReturnedPacket->m_tData.m_tXCipherKey.m_usRemoteUserAtHostSize);
   char* pPackedResult = pReturnedPacket->m_tData.m_tXCipherKey.m_szRemoteUserAtHost;
   memcpy(tXCipherResultUnpacked.m_szRemoteUserAtHost, pPackedResult, tXCipherResultUnpacked.m_usRemoteUserAtHostSize);
   pPackedResult += tXCipherResultUnpacked.m_usRemoteUserAtHostSize;
   memcpy(&tXCipherResultUnpacked.m_tConversationSessionGUID, pPackedResult, sizeof(uuid_t));
   pPackedResult += sizeof(tXCipherResultUnpacked.m_tConversationSessionGUID);
   tXCipherResultUnpacked.m_dwErrorCode = XT2HOST32(*(unsigned long*)pPackedResult);
   pPackedResult += sizeof(tXCipherResultUnpacked.m_dwErrorCode);
   tXCipherResultUnpacked.m_usErrorReasonSize = XT2HOST16(*(unsigned short*)pPackedResult);
   pPackedResult += sizeof(tXCipherResultUnpacked.m_usErrorReasonSize);
   memcpy(tXCipherResultUnpacked.m_szErrorReason, pPackedResult, tXCipherResultUnpacked.m_usErrorReasonSize);
   pPackedResult += tXCipherResultUnpacked.m_usErrorReasonSize;
   tXCipherResultUnpacked.m_usCipherKeySize = XT2HOST16(*(unsigned short*)pPackedResult);
   pPackedResult += sizeof(tXCipherResultUnpacked.m_usCipherKeySize);
   memcpy(tXCipherResultUnpacked.m_szCipherKey, pPackedResult, tXCipherResultUnpacked.m_usCipherKeySize);
   pPackedResult += tXCipherResultUnpacked.m_usCipherKeySize;
  
   cout << "got EMessage_ServerToClient_ReplyXCipherSecureConversationKey:" << endl;
   cout << "   remote user@host: " << tXCipherResultUnpacked.m_szRemoteUserAtHost << " [" << tXCipherResultUnpacked.m_usRemoteUserAtHostSize << " bytes] " << endl;
   cout << "       request GUID: " << GetUUIDString(&tXCipherResultUnpacked.m_tConversationSessionGUID, NULL) << endl;
   cout << "              error: " << tXCipherResultUnpacked.m_dwErrorCode << " -- " << tXCipherResultUnpacked.m_szErrorReason << " [" << tXCipherResultUnpacked.m_usErrorReasonSize << " bytes] " << endl;
   cout << "         cipher key: " << tXCipherResultUnpacked.m_szCipherKey << " [" << tXCipherResultUnpacked.m_usCipherKeySize << " bytes] " << endl;
	CheckNoMoreData();


//#pragma mark *** EMessageDisconnect

#define TEST_TIMEOUT_DISCONNECT 0
#if TEST_TIMEOUT_DISCONNECT
	sleep(60);
	return 0;
#endif // TEST_TIMEOUT_DISCONNECT	

	cout << "last test: EMessageDisconnect..." << endl;
	g_tSendingPacket.m_tHeaderBasic.commandid = HOST2XT32(EMessageDisconnect);
	const char* politeGoodbye = "I'd like to leave now.";
	ulPacketsize = sizeof(unsigned long) + sizeof(unsigned short) + strlen(politeGoodbye);
	g_tSendingPacket.m_tHeaderBasic.payloadsize = HOST2XT32(ulPacketsize);
	g_tSendingPacket.m_tData.disconnect.reason = HOST2XT32(kDisconnectReasonNormal);
	g_tSendingPacket.m_tData.disconnect.messagesize = HOST2XT16(strlen(politeGoodbye));
	strcpy(g_tSendingPacket.m_tData.disconnect.message, politeGoodbye);
	if (SendPacketToMasterServer(&g_tSendingPacket, ulPacketsize))
		{
		cout << "error sending EMessageDisconnect!" << endl;
		return 1;
		}
		
	// expect a polite packet back	

   pReturnedPacket = GetMasterServerPacket(sClientPacketEncryption, EMessageDisconnect);
   if (!pReturnedPacket)
		{
		cout << "error receiving EMessageDisconnect data!" << endl;
		return 1;
		}
	pReturnedPacket->m_tData.disconnect.messagesize = XT2HOST16(pReturnedPacket->m_tData.disconnect.messagesize);
	// no trailing NUL
	pReturnedPacket->m_tData.disconnect.message[pReturnedPacket->m_tData.disconnect.messagesize] = 0;
	cout << "got reason " << XT2HOST32(pReturnedPacket->m_tData.disconnect.reason) << endl;
	cout << "got string[" << pReturnedPacket->m_tData.disconnect.messagesize << "]: " << pReturnedPacket->m_tData.disconnect.message << endl;
	CheckNoMoreData();


//#pragma mark *** all done

	// server will go away after EMessageDisconnect	
	return 0;
	}
	
// Usage - write usage specs to error output
void Usage(const char *name)
	{
	cerr << name << " server [destaddr seconds bytes/sec] " << endl;
	cerr << " -- test X-Tunnels server at address <server> " << endl;
	cerr << " optionally  " << endl;
	cerr << " -- forward random data over UDP to address <destaddr> " << endl;
	cerr << " -- continue forwarding for <seconds> " << endl;
	cerr << " -- bandwidth to forward will be <bytes/sec> " << endl;
	}

// so we can run it with test arguments
int XTunnelsTestMain(int argc, char *argv[])
	{
	char* szTestServerAddress = NULL;
	
	switch (argc)
		{
		case 5:
		   // doing a bandwidth test
		   szTestServerAddress = argv[1];
		   strcpy(g_szLoadTestDestinationAddress, argv[2]);
         g_ulLoadTestSeconds = atol(argv[3]);
         g_ulLoadTestBytesPerSecond = atol(argv[4]);
	      cout << "-- testxtunnels bandwidth test to " << szTestServerAddress 
	            << " for " << g_ulLoadTestSeconds << " seconds "
	            << " @ " << g_ulLoadTestBytesPerSecond << " bps " << endl;
		   break;
		case 2:
		   // doing a protocol test
		   szTestServerAddress = argv[1];
		   strcpy(g_szLoadTestDestinationAddress, "www.microsoft.com");
	      cout << "-- testxtunnels protocol test using argument server address " << szTestServerAddress << endl;
		   break;
		case 1:
		   // probably in debugger
		   szTestServerAddress = "xtunnels.xten.net";
		   //szTestServerAddress = "192.168.2.105";
		   //szTestServerAddress = "xtunnels1.test.xten.net";
		   strcpy(g_szLoadTestDestinationAddress, "www.microsoft.com");
	      cout << "-- testxtunnels using harcoded server address " << szTestServerAddress << endl;
		   break;
		default:
   		Usage(argv[0]);
	   	return 1;
		}

	try
		{
		if (!XCipher::InitializeXCipher(true))
		   throw;
		if (!CXTunnelsChildData::InitializeChildData())
		   throw;
		
		return TestServer(szTestServerAddress);
		}
	catch(...)
		{
		cout << "testxtunnels threw uncaught exception!" << endl;
		return 1;	// generic error
		}
   }

} // end anonymous namespace

#if UNITTEST_AES_ENCRYPTION
static int UnitTestEncryptAES(CVsAES::AESKeyLength inBits, const char* szCipherKey, char* pOutDestination, unsigned long& ulOutDestSize, const char* pSource, unsigned long ulSourceSize)
	{	    
	int result = 0;
	ostrstream output(pOutDestination, ulOutDestSize);
	ulOutDestSize = 0; // will now be filled in with actual data count
	{
	CVsAES encryptAES;
	encryptAES.OpenWrite(szCipherKey, &output, inBits);
	encryptAES.Write(pSource, ulSourceSize, &ulOutDestSize);
#if DEBUG
   cout << "UnitTestEncryptAES[" << inBits << "] encrypting " << ulSourceSize << " bytes with CipherKey " << szCipherKey << " ... " << ulOutDestSize;
#endif // DEBUG
	encryptAES.Close(&ulOutDestSize);
#if DEBUG
   cout << " ... closed at " << ulOutDestSize << endl;
   cout << "First unencrypted 20 bytes are " << GetSHA1DigestString((u_char*)pSource, NULL) << endl;
   cout << "First encrypted 20 bytes are " << GetSHA1DigestString((u_char*)pOutDestination, NULL) << endl;
#endif // DEBUG
	}
	return result;
	}
static int UnitTestDecryptAES(CVsAES::AESKeyLength inBits, const char* szCipherKey, char* pOutDestination, unsigned long ulDestSize, char* pSource, unsigned long ulSourceSize)
	{
	int result = 0;
	istrstream input(pSource, ulSourceSize);
	{
	CVsAES decryptAES;
	//decryptAES.OpenRead(ChildData()->m_szClientDecryptionKey, &input, inBits);
	decryptAES.OpenRead(szCipherKey, &input, inBits);
	unsigned long dwActualRead = ulDestSize;
	decryptAES.Read(pOutDestination, ulDestSize, &dwActualRead);
	decryptAES.Close();
	}

#if DEBUG
   cout << "UnitTestDecryptAES" << inBits << " encrypted " << ulSourceSize
      << " bytes to unencrypted " << ulDestSize << " bytes using CipherKey "
      << szCipherKey << ": " << endl;
   cout << "First encrypted 20 bytes are " << GetSHA1DigestString((u_char*)pSource, NULL) << endl;
   cout << "First unencrypted 20 bytes are " << GetSHA1DigestString((u_char*)pOutDestination, NULL) << endl;
   
#endif // DEBUG
	
	// it's actually rounded up to next 4 bytes even; take value in header
	//result = ulDestSize == dwActualRead;
	
	return result;
	}
#endif // UNITTEST_AES_ENCRYPTION

int main(int argc, char *argv[])
{
#if UNITTEST_AES_ENCRYPTION
   // Appendix B http://csrc.nist.gov/publications/fips/fips197/fips-197.pdf
   // note that to actually test this STAESPrivateData() must be patched to not mangle key passed in
   char szFIPS197Input[17] =
      {
      0x32, 0x43, 0xf6, 0xa8,
      0x88, 0x5a, 0x30, 0x8d,
      0x31, 0x31, 0x98, 0xa2,
      0xe0, 0x37, 0x07, 0x34,
      0x00
      };
   char szFIPS197CipherKey[17] =
      {
      0x2b, 0x7e, 0x15, 0x16,
      0x28, 0xae, 0xd2, 0xa6,
      0xab, 0xf7, 0x15, 0x88,
      0x09, 0xcf, 0x4f, 0x3c,
      0x00
      };

   char* szInput = szFIPS197Input;
   char* szCipherKey = szFIPS197CipherKey;
   //char* szInput = "fuzzybunny";
   //char* szCipherKey = "fuzzybunny";
   unsigned long ulInputLength = strlen(szInput);
   //unsigned long ulKeyLength = strlen(szCipherKey);
   CVsAES::AESKeyLength tKeyBits = CVsAES::E128bits;
   
   char pEncryptDestination[EMaxSmallBufferSize] = { 0 };
   unsigned long ulEncryptDestSize = EMaxSmallBufferSize;
   int encryptErr =  UnitTestEncryptAES(tKeyBits, szCipherKey, pEncryptDestination, ulEncryptDestSize, szInput, ulInputLength);
   cout << "EncryptDestination:  "<< pEncryptDestination << endl;
   char pDecryptDestination[EMaxSmallBufferSize] = { 0 };
   unsigned long ulDecryptDestSize = EMaxSmallBufferSize;
   encryptErr =  UnitTestDecryptAES(tKeyBits, szCipherKey, pDecryptDestination, ulDecryptDestSize, pEncryptDestination, ulEncryptDestSize);
   cout << "DecryptDestination:  " << pDecryptDestination << endl;
   cout << "AES" << tKeyBits << " unit test complete " << endl;
#endif // UNITTEST_AES_ENCRYPTION

/*
void aesdemo();
   aesdemo();
   return 0;
*/

	return XTunnelsTestMain(argc, argv);
	
	return 0;
}