xtunnelstestmain.cpp

xtunnel nat/fw traversal source code

	tServerChallenge.algorithm = XT2HOST32(pReturnedPacket->m_tData.serverchallenge.algorithm);
	tServerChallenge.challengeblobsize = XT2HOST32(pReturnedPacket->m_tData.serverchallenge.challengeblobsize);
   memcpy(tServerChallenge.challengeblob, pReturnedPacket->m_tData.serverchallenge.challengeblob, tServerChallenge.challengeblobsize);
	cout << "got challenge for algorithm " << tServerChallenge.algorithm
			<< " <blob> size " << tServerChallenge.challengeblobsize << endl;
   if (16 != tServerChallenge.challengeblobsize)
      cout << "WARNING: Unexpected server challengeblobsize of " << tServerChallenge.challengeblobsize << endl;

	CheckNoMoreData();
   }
   
//#pragma mark *** EMessageChallengeReply

	cout << "testing EMessageChallengeReply..." << endl;
   ChallengeReplyParam tChallengeUnpacked = { 0 };
	{
   if (ELoginAnonymous != ulConnectionType)
      {
      // challengereply from what server sent us
   	ChildData()->m_ulKeyEncryptionType = ulLoginAlgorithm;
   	ChildData()->SetPassword(userPassword);

      MakeSessionKeyColonPasswordDigest(
         ulLoginAlgorithm,
         tServerChallenge.challengeblobsize,
         (char*)tServerChallenge.challengeblob,
         userPassword,
         tChallengeUnpacked.challengereplyblobsize,
         tChallengeUnpacked.challengereplyblob
      );
      // session key we make up, and set here our encryption key to go with it
   	uuid_t tUniqueKey;
   	FillWithRandomLongs(&tUniqueKey, sizeof(tUniqueKey));
   	char sessionkey[EMaxSmallBufferSize] = { 0 };
   	GetUUIDString((uuid_t*)&tUniqueKey, sessionkey);
   	unsigned long ulSessionKeySize = strlen(sessionkey);
   	// note that ChildData()->m_ulKeyEncryptionType = algorithm; was set above
   	ChildData()->MakeServerEncryptionKey(ulSessionKeySize, sessionkey);
      tChallengeUnpacked.sessionkeysize = ulSessionKeySize;
      memcpy(tChallengeUnpacked.sessionkey, sessionkey, ulSessionKeySize);
      }
   // now pack and send it
	ulPacketsize = 
	   sizeof(tChallengeUnpacked.challengereplyblobsize)
	   + tChallengeUnpacked.challengereplyblobsize
	   + sizeof(tChallengeUnpacked.sessionkeysize)
	   + tChallengeUnpacked.sessionkeysize;
	g_tSendingPacket.m_tHeaderBasic.commandid = HOST2XT32(EMessageChallengeReply);
	g_tSendingPacket.m_tHeaderBasic.payloadsize = HOST2XT32(ulPacketsize);
   char* pCurrentPayloadOffset = g_tSendingPacket.m_tData.m_pPayload;
   *(unsigned long*)pCurrentPayloadOffset = HOST2XT32(tChallengeUnpacked.challengereplyblobsize);
   pCurrentPayloadOffset += sizeof(tChallengeUnpacked.challengereplyblobsize);
   memcpy(pCurrentPayloadOffset, tChallengeUnpacked.challengereplyblob, tChallengeUnpacked.challengereplyblobsize);
   pCurrentPayloadOffset += tChallengeUnpacked.challengereplyblobsize;
   *(unsigned short*)pCurrentPayloadOffset = HOST2XT16(tChallengeUnpacked.sessionkeysize);
   pCurrentPayloadOffset += sizeof(tChallengeUnpacked.sessionkeysize);
   memcpy(pCurrentPayloadOffset, tChallengeUnpacked.sessionkey, tChallengeUnpacked.sessionkeysize);
   pCurrentPayloadOffset += tChallengeUnpacked.sessionkeysize;
   
	if (SendPacketToMasterServer(&g_tSendingPacket, ulPacketsize))
		{
		cout << "error sending EMessageChallengeReply!" << endl;
		return 1;
		}
	}

	// server replies with own EMessageChallengeReply 
   
   pReturnedPacket = GetMasterServerPacket(sClientPacketEncryption, EMessageChallengeReply);
   if (!pReturnedPacket)
		{
		cout << "error receiving EMessageChallengeReply!" << endl;
		return 1;
		}
   char szServersReplyToClientChallenge[EMaxSmallBufferSize] = { 0 };
	unsigned long ulBlobSize = XT2HOST32(pReturnedPacket->m_tData.challengereply.challengereplyblobsize);
   char* szPackedChallengeReplyData = pReturnedPacket->m_tData.challengereply.challengereplyblob;
	memcpy(szServersReplyToClientChallenge, szPackedChallengeReplyData, ulBlobSize);
	szPackedChallengeReplyData += ulBlobSize;
   unsigned short usSessionKeySize = XT2HOST16(*(unsigned short*)szPackedChallengeReplyData);
   szPackedChallengeReplyData += sizeof(unsigned short);
	cout << "got challengereply with <blob> size " << ulBlobSize << " <encryption key> size " << usSessionKeySize << endl;
	CheckNoMoreData();
	if (ulConnectionType != ELoginAnonymous)
   	{
      char szClientsAnswerToClientChallenge[EMaxSmallBufferSize] = { 0 };
      unsigned long ulDigestSize = 0;
      MakeSessionKeyColonPasswordDigest(
         ulLoginAlgorithm,
         tHelloUnpacked.challengeblobsize,
         tHelloUnpacked.challengeblob,
         userPassword,
      	ulDigestSize,
      	szClientsAnswerToClientChallenge
      	);
   	char digest[255] = { 0 };
   	char server[255] = { 0 };
   	char source[255] = { 0 };
   	ChildData()->GetDigestString(szClientsAnswerToClientChallenge, digest);
   	ChildData()->GetDigestString(szServersReplyToClientChallenge, server);
   	ChildData()->GetDigestString(tHelloUnpacked.challengeblob, source);
   	cout << "Our challenge: " << source << "[" << tHelloUnpacked.challengeblobsize << "]" << endl;
   	cout << "Our response to our challenge:      " << digest << "[" << ulDigestSize << "]" << endl;
   	cout << "Server's response to our challenge: " << server << "[" << ulBlobSize << "]" << endl;
   	bool isOK = 0 == memcmp(szClientsAnswerToClientChallenge, szServersReplyToClientChallenge, ulBlobSize);
   	if (!isOK)
   		{
   		cout << "FATAL ERROR: Server's response to challenge for " << userName << "/" << userPassword << " did not match!" << endl;
   		return 1;
   		}
   	else
   		cout << "Server's response to challenge for " << userName << "/" << userPassword << " matched." << endl;
   	}
	// we are client, yes, but we're using server support calls so client/server decryption is reversed in the tool
	// note that ChildData()->m_ulKeyEncryptionType = algorithm; was set above
	ChildData()->MakeClientDecryptionKey(usSessionKeySize,szPackedChallengeReplyData);


//#pragma mark *** EMessageClientReady

	cout << "testing EMessageClientReady..." << endl;
	g_tSendingPacket.m_tHeaderBasic.commandid = HOST2XT32(EMessageClientReady);
	ulPacketsize = 0;
	g_tSendingPacket.m_tHeaderBasic.payloadsize = HOST2XT32(ulPacketsize);
	if (SendPacketToMasterServer(&g_tSendingPacket, ulPacketsize))
		{
		cout << "error sending EMessageClientReady!" << endl;
		return 1;
		}
		
	// IF destination is X-Cipher enabled expect server support packet back
   pReturnedPacket = GetMasterServerPacket(sClientPacketEncryption, EMessage_ServerToClient_NotifyServerSupport);
   if (!pReturnedPacket)
		{
		cout << "error receiving EMessage_ServerToClient_NotifyServerSupport packet! " << endl;
		// naah, don't count this as an error, probably X-Cipher is off
		//return 1;
		cout << "Is X-Cipher support actually on?" << endl;
		}
	else
	   cout << "got server support packet " << endl;
	
	// server replies with session m_tData
	
   pReturnedPacket = GetMasterServerPacket(sClientPacketEncryption, EMessageServerReady);
   if (!pReturnedPacket)
		{
		cout << "error receiving EMessageServerReady header!" << endl;
		return 1;
		}
	pReturnedPacket->m_tData.serverready.externalip = XT2HOST32(pReturnedPacket->m_tData.serverready.externalip);
	char externalip[2048] = { 0 };
	struct in_addr addr = { pReturnedPacket->m_tData.serverready.externalip };
	addr2name(addr, externalip, 2048);
	uuid_t tServersSessionUUID = { 0 };
	memcpy(&tServersSessionUUID, &pReturnedPacket->m_tData.serverready.sessionuuid, sizeof(uuid_t));
	// 1 byte bools don't need swapping
	//pReturnedPacket->m_tData.serverready.startnew = XT2HOST32(pReturnedPacket->m_tData.serverready.startnew);
	pReturnedPacket->m_tData.serverready.m_wServerAssignedUDPRedirectPort = XT2HOST16(pReturnedPacket->m_tData.serverready.m_wServerAssignedUDPRedirectPort);
	pReturnedPacket->m_tData.serverready.m_dwServerSessionTimeoutInSeconds = XT2HOST32(pReturnedPacket->m_tData.serverready.m_dwServerSessionTimeoutInSeconds);
	cout << "got ready packet " << externalip
			<< (pReturnedPacket->m_tData.serverready.startnew ? " new" : " old") << " <sessionid> timeout = " 
			<< pReturnedPacket->m_tData.serverready.m_dwServerSessionTimeoutInSeconds << " redirect port = " 
			<< pReturnedPacket->m_tData.serverready.m_wServerAssignedUDPRedirectPort << endl;
	CheckNoMoreData();


//#pragma mark *** EMessageClientRequestSinglePort

	cout << "testing EMessageClientRequestSinglePort..." << endl;
	g_tSendingPacket.m_tHeaderBasic.commandid = HOST2XT32(EMessageClientRequestSinglePort);
	ulPacketsize = sizeof(ClientRequestSinglePortParam);
	g_tSendingPacket.m_tHeaderBasic.payloadsize = HOST2XT32(ulPacketsize);
	uuid_t requestuuid = { 0 };
	for (int i = 0; i < (int)sizeof(requestuuid); i++)
		((char*)&requestuuid)[i] = /*'a' +*/ i;
	g_tSendingPacket.m_tData.clientrequestsingleport.requestuuid = requestuuid;
	if (SendPacketToMasterServer(&g_tSendingPacket, ulPacketsize))
		{
		cout << "error sending EMessageClientRequestSinglePort!" << endl;
		return 1;
		}
		
	// server replies with a new port
	
   pReturnedPacket = GetMasterServerPacket(sClientPacketEncryption, EMessageServerPortsAvailable);
   if (!pReturnedPacket)
		{
		cout << "error receiving EMessageServerPortsAvailable!" << endl;
		return 1;
		}
	unsigned long lastGoodPort = XT2HOST16(pReturnedPacket->m_tData.serverportsavailable.portBase);
	cout << "got " << sizeof(uuid_t) << " byte <requestID> 1 port at portBase " << lastGoodPort << endl;
	bool uuidsmatch = 0 == memcmp(&requestuuid, &pReturnedPacket->m_tData.serverportsavailable.requestuuid, sizeof(uuid_t));
	if (!uuidsmatch)
		cout << "WARNING: request ID returned does NOT match the one sent!" << endl;
	CheckNoMoreData();

//#pragma mark *** EMessageClientRequestEvenBasedPortPair

#define TEST_ENCRYPTION 1
#if TEST_ENCRYPTION
   if (ulConnectionType == ELoginNamePassword)
      {
      // PreparePacketForTransmit() has checkers for these
   	sClientPacketEncryption = EAlgorithm_Triple_DES;
   	//sClientPacketEncryption = EAlgorithm_AES_128_Bits;
   	}
#endif // TEST_ENCRYPTION

	cout << "testing EMessageClientRequestEvenBasedPortPair..." << endl;
	g_tSendingPacket.m_tHeaderBasic.commandid = HOST2XT32(EMessageClientRequestEvenBasedPortPair);
	g_tSendingPacket.m_tHeaderBasic.payloadsize = HOST2XT32(sizeof(ClientRequestEvenBasedPortPairParam));
	g_tSendingPacket.m_tData.clientrequestevenbasedportpair.requestuuid = requestuuid;
	if (SendPacketToMasterServer(&g_tSendingPacket, ulPacketsize))
		{
		cout << "error sending EMessageClientRequestEvenBasedPortPair!" << endl;
		return 1;
		}
		
	// server replies with a new port base
	
   pReturnedPacket = GetMasterServerPacket(sClientPacketEncryption, EMessageServerPortsAvailable);
   if (!pReturnedPacket)
		{
		cout << "error receiving EMessageServerPortsAvailable!" << endl;
		return 1;
		}
	lastGoodPort = XT2HOST16(pReturnedPacket->m_tData.serverportsavailable.portBase);
	cout << "got " << sizeof(uuid_t) << " byte <requestID> 2 ports at portBase " << lastGoodPort << endl;
	uuidsmatch = 0 == memcmp(&requestuuid, &pReturnedPacket->m_tData.serverportsavailable.requestuuid, sizeof(uuid_t));
	if (!uuidsmatch)
		cout << "WARNING: request ID returned does NOT match the one sent!" << endl;
	CheckNoMoreData();

//#pragma mark *** EMessageClientRequestSendPacket

	cout << "testing EMessageClientRequestSendPacket from " << lastGoodPort << "..." << endl;
	int iRequestSendPacketBlockSize = 2048;
	g_tSendingPacket.m_tHeaderBasic.commandid = HOST2XT32(EMessageClientRequestSendPacket);
	ulPacketsize = sizeof(unsigned short) + sizeof(unsigned long) 
			+ sizeof(unsigned short) + sizeof(unsigned long) + iRequestSendPacketBlockSize;
	g_tSendingPacket.m_tHeaderBasic.payloadsize = HOST2XT32(ulPacketsize);
	g_tSendingPacket.m_tData.clientrequestsendpacket.fromport = HOST2XT16(lastGoodPort);
	in_addr_t desttest = 0;
	name2addr(g_szLoadTestDestinationAddress, &desttest);
	g_tSendingPacket.m_tData.clientrequestsendpacket.destip = HOST2XT32(desttest);
	g_tSendingPacket.m_tData.clientrequestsendpacket.destport = HOST2XT16(lastGoodPort + 10);
	g_tSendingPacket.m_tData.clientrequestsendpacket.packetblobsize = HOST2XT32(iRequestSendPacketBlockSize);
	//bzero(g_tSendingPacket.m_tData.clientrequestsendpacket.packetblob, iRequestSendPacketBlockSize);
	FillWithRandomLongs(g_tSendingPacket.m_tData.clientrequestsendpacket.packetblob, iRequestSendPacketBlockSize);
	if (SendPacketToMasterServer(&g_tSendingPacket, ulPacketsize))
		{
		cout << "error sending EMessageClientRequestSendPacket!" << endl;
		return 1;
		}
   if (g_ulLoadTestSeconds && g_ulLoadTestBytesPerSecond)
      {
		cout << "starting " << g_ulLoadTestSeconds << " seconds x " << g_ulLoadTestBytesPerSecond << " bytes/sec load test..." << endl;

      struct timeval tNextSecond = { 0 };
      struct timeval tNow = { 0 };
	   gettimeofday(&tNextSecond, NULL);
	   unsigned long ulDataThisSecond = 0;
	   int iSendLoadTestError = 0;
	   while (g_ulLoadTestSeconds)
	      {
	      g_ulLoadTestSeconds--;
	      tNextSecond.tv_sec++;
	      ulDataThisSecond = g_ulLoadTestBytesPerSecond;
	      iSendLoadTestError = 0;
	      gettimeofday(&tNow, NULL);
	      while (!iSendLoadTestError && (ulDataThisSecond > 0))
	         {
	         iSendLoadTestError = SendPacketToMasterServer(&g_tSendingPacket, ulPacketsize);
	         ulDataThisSecond -= iRequestSendPacketBlockSize;
	         if (iSendLoadTestError)
   		      cout << "error sending load test packet!" << endl;
   		   while ((tNow.tv_sec < tNextSecond.tv_sec) || (tNow.tv_usec < tNextSecond.tv_usec))
   		      {
   		      // is there a sub-second sleep call of some sort??
	            gettimeofday(&tNow, NULL);
	            }
	         }
	      }
      
		cout << "completed " << g_ulLoadTestSeconds << " seconds x " << g_ulLoadTestBytesPerSecond << " bytes/sec load test!" << endl;