xtunnelsfamilydata.cpp

xtunnel nat/fw traversal source code

void MakeSessionKeyColonPasswordDigestString(
   unsigned long ulEncryptionType,
   unsigned long ulSessionKeySize,
   const char* szSessionKey,
   const char* szPassword,
	char* szOutString
	)
	{
	unsigned long ulDigestSize = 0;
	char pDigest[ChallengeReplyParam::kMaxChallengeReplyBlobSize] = { 0 };
	
	MakeSessionKeyColonPasswordDigest(
	   ulEncryptionType,
	   ulSessionKeySize,
	   szSessionKey,
	   szPassword,
	   ulDigestSize,
	   pDigest
	   );

	switch (ulEncryptionType)
	   {
	   case EAlgorithm_MD5:
         GetUUIDString((uuid_t*)pDigest, szOutString);
         break;
	   case EAlgorithm_SHA1:
         GetSHA1DigestString((unsigned char*)pDigest, szOutString);
         break;
      default:
         szOutString[0] = 0;
         break;
      }
	}

void Get32ByteString(const unsigned char* pBytes, char* szOutString)
   {
	sprintf(
	   szOutString,
	   "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
      (unsigned int)(((unsigned char*)pBytes)[0]),
      (unsigned int)(((unsigned char*)pBytes)[1]),
      (unsigned int)(((unsigned char*)pBytes)[2]),
      (unsigned int)(((unsigned char*)pBytes)[3]),
      (unsigned int)(((unsigned char*)pBytes)[4]),
      (unsigned int)(((unsigned char*)pBytes)[5]),
      (unsigned int)(((unsigned char*)pBytes)[6]),
      (unsigned int)(((unsigned char*)pBytes)[7]),
      (unsigned int)(((unsigned char*)pBytes)[8]),
      (unsigned int)(((unsigned char*)pBytes)[9]),
      (unsigned int)(((unsigned char*)pBytes)[10]),
      (unsigned int)(((unsigned char*)pBytes)[11]),
      (unsigned int)(((unsigned char*)pBytes)[12]),
      (unsigned int)(((unsigned char*)pBytes)[13]),
      (unsigned int)(((unsigned char*)pBytes)[14]),
      (unsigned int)(((unsigned char*)pBytes)[15]),
      (unsigned int)(((unsigned char*)pBytes)[16]),
      (unsigned int)(((unsigned char*)pBytes)[17]),
      (unsigned int)(((unsigned char*)pBytes)[18]),
      (unsigned int)(((unsigned char*)pBytes)[19]),
      (unsigned int)(((unsigned char*)pBytes)[20]),
      (unsigned int)(((unsigned char*)pBytes)[21]),
      (unsigned int)(((unsigned char*)pBytes)[22]),
      (unsigned int)(((unsigned char*)pBytes)[23]),
      (unsigned int)(((unsigned char*)pBytes)[24]),
      (unsigned int)(((unsigned char*)pBytes)[25]),
      (unsigned int)(((unsigned char*)pBytes)[26]),
      (unsigned int)(((unsigned char*)pBytes)[27]),
      (unsigned int)(((unsigned char*)pBytes)[28]),
      (unsigned int)(((unsigned char*)pBytes)[29]),
      (unsigned int)(((unsigned char*)pBytes)[30]),
      (unsigned int)(((unsigned char*)pBytes)[31])
   );
   }

const char* GetSHA1DigestString(const unsigned char* pSHA1Digest, char* szOutString)
{
	static char szStorage[256];
	if (!szOutString)
		szOutString = szStorage;

	sprintf(
	   szOutString,
	   "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
      (unsigned int)(((unsigned char*)pSHA1Digest)[0]),
      (unsigned int)(((unsigned char*)pSHA1Digest)[1]),
      (unsigned int)(((unsigned char*)pSHA1Digest)[2]),
      (unsigned int)(((unsigned char*)pSHA1Digest)[3]),
      (unsigned int)(((unsigned char*)pSHA1Digest)[4]),
      (unsigned int)(((unsigned char*)pSHA1Digest)[5]),
      (unsigned int)(((unsigned char*)pSHA1Digest)[6]),
      (unsigned int)(((unsigned char*)pSHA1Digest)[7]),
      (unsigned int)(((unsigned char*)pSHA1Digest)[8]),
      (unsigned int)(((unsigned char*)pSHA1Digest)[9]),
      (unsigned int)(((unsigned char*)pSHA1Digest)[10]),
      (unsigned int)(((unsigned char*)pSHA1Digest)[11]),
      (unsigned int)(((unsigned char*)pSHA1Digest)[12]),
      (unsigned int)(((unsigned char*)pSHA1Digest)[13]),
      (unsigned int)(((unsigned char*)pSHA1Digest)[14]),
      (unsigned int)(((unsigned char*)pSHA1Digest)[15]),
      (unsigned int)(((unsigned char*)pSHA1Digest)[16]),
      (unsigned int)(((unsigned char*)pSHA1Digest)[17]),
      (unsigned int)(((unsigned char*)pSHA1Digest)[18]),
      (unsigned int)(((unsigned char*)pSHA1Digest)[19])
   );

   return szOutString;
}

const char* GetDigestString(unsigned long ulKeyEncryptionType, char* pDigest, char* szOutString)
   {
	switch (ulKeyEncryptionType)
	   {
	   case EAlgorithm_MD5:
         return GetUUIDString((uuid_t*)pDigest, szOutString);
	   case EAlgorithm_SHA1:
         return GetSHA1DigestString((unsigned char*)pDigest, szOutString);
      default:
         return NULL;
      }
   }

void MakeSHA1SessionKeyColonPasswordDigest(
   unsigned long ulSessionKeySize,
   const char* szSessionKey,
   const char* szPassword,
	unsigned long& ulOutDigestSize,
	char* pOutDigest
   )
   {
   CVsSHA1 cSHA1;

   cSHA1.Write((const unsigned char *)szSessionKey, ulSessionKeySize);
   cSHA1.Write((const unsigned char *)":", strlen(":")*sizeof(char));
   cSHA1.Write((const unsigned char *)szPassword, strlen(szPassword)*sizeof(char));
   cSHA1.Close();

   ulOutDigestSize = cSHA1.GetDigestBytesLength();
   memcpy(pOutDigest, cSHA1.GetDigestBytes(), ulOutDigestSize);
   //cSHA1.GetDigest(pOutDigest);

#if DEBUG
/*
   cout << "MakeSHA1SessionKeyColonPasswordDigest: password " << szPassword << "[" << strlen(szPassword) << "]" << endl;
   if (16 == ulSessionKeySize)
      cout << "   16 byte input: " << GetUUIDString((uuid_t*)szSessionKey, NULL) << endl;
   else if (20 == ulSessionKeySize)
      cout << "   20 byte input: " << XTunnels::GetSHA1DigestString((const unsigned char*)szSessionKey, NULL) << endl;
   else
      cout << "   unexpected input size of " << ulSessionKeySize << "!! " << endl;
   cout << "   20 byte digest: " << XTunnels::GetSHA1DigestString((const unsigned char*)pOutDigest, NULL) << endl;
*/
#endif // DEBUG
   }

void FillWithRandomLongs(void* pRandomize, int iSize)
   {
#ifndef VS_TARGET_OS_LINUX
   srandomdev(); // random() is now suitable for cryptographic use
#endif // VS_TARGET_OS_LINUX
   long* pFill = (long*)pRandomize;
   for (int iLong = 0; iLong < (iSize / 4); iLong++)
      pFill[iLong] = random();
   }

// returns copy created with new[]
char* CreateString(const char* szFromString)
   {
   char* szResult = NULL;
   if (szFromString)
      {
      szResult = new char[strlen(szFromString) + 1];
      strcpy(szResult, szFromString);
      }
   return szResult;
   }


long PipeRead(int pPipe[2], void* pData, unsigned long ulSize)
   {
#if DEBUG
   //cout << "X-Tunnels: PipeRead now attempting to read " << ulSize << " bytes " << endl;
#endif //DEBUG

   unsigned long ulResult = r_read(pPipe[EReadEnd], pData, ulSize);

#if DEBUG
	if (ulResult != ulSize)
	   cout << "X-Tunnels: PipeRead failed to read " << ulSize << " bytes, errno " << errno << endl;
/*
	else
	   cout << "X-Tunnels: PipeRead successful "  << endl;
*/  
#endif //DEBUG
   return ulResult;
   }

long PipeWrite(int pPipe[2], const void* pData, unsigned long ulSize)
   {
   unsigned long ulResult = r_write(pPipe[EWriteEnd], pData, ulSize);

#if DEBUG
	if (ulResult != ulSize)
	   cout << "X-Tunnels: PipeWrite failed to write " << ulSize << " bytes, errno " << errno << endl;
#endif //DEBUG

   return ulResult;
   }

int DecryptTripleDES(char* pOutDestination, unsigned long ulDestSize, char* pSource, unsigned long ulSourceSize, const char* szPassword)
	{
	if (!szPassword)
	    return 1;
	    
   int result = 0;
	
	istrstream input(pSource, ulSourceSize);
	{
	CVsDES decryptDES;
	decryptDES.OpenRead(szPassword, &input);
	unsigned long dwActualRead = ulDestSize;
	decryptDES.Read(pOutDestination, ulDestSize, &dwActualRead);
	decryptDES.Close();
	}
	
	// it's actually rounded up to next 4 bytes even; take value in header
	//result = ulDestSize == dwActualRead;
	
	return result;
	}

static int DecryptAES(CVsAES::AESKeyLength inBits, char* pOutDestination, unsigned long ulDestSize, char* pSource, unsigned long ulSourceSize, const char* szPassword)
	{
	if (!szPassword)
	    return 1;
	    
	int result = 0;
	
	istrstream input(pSource, ulSourceSize);
	{
	CVsAES decryptAES;
	decryptAES.OpenRead(szPassword, &input, inBits);
	//decryptAES.OpenRead("fuzzybunny", &input, inBits);
	unsigned long dwActualRead = ulDestSize;
	decryptAES.Read(pOutDestination, ulDestSize, &dwActualRead);
	decryptAES.Close();
	}
/*
#if DEBUG
   cout << "DecryptAES" << inBits << " encrypted " << ulSourceSize
      << " bytes to unencrypted " << ulDestSize << " bytes using password "
      << szPassword << ": " << 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;
	}

int DecryptAES128(char* pOutDestination, unsigned long ulDestSize, char* pSource, unsigned long ulSourceSize, const char* szPassword)
	{
	return DecryptAES(CVsAES::E128bits, pOutDestination, ulDestSize, pSource, ulSourceSize, szPassword);
	}
	
int DecryptAES192(char* pOutDestination, unsigned long ulDestSize, char* pSource, unsigned long ulSourceSize, const char* szPassword)
	{
	return DecryptAES(CVsAES::E192bits, pOutDestination, ulDestSize, pSource, ulSourceSize, szPassword);
	}
	
int DecryptAES256(char* pOutDestination, unsigned long ulDestSize, char* pSource, unsigned long ulSourceSize, const char* szPassword)
	{
	return DecryptAES(CVsAES::E256bits, pOutDestination, ulDestSize, pSource, ulSourceSize, szPassword);
	}

int EncryptTripleDES(char* pOutDestination, unsigned long& ulOutDestSize, char* pSource, unsigned long ulSourceSize, const char* szPassword)
	{
	if (!szPassword)
	    return 1;
	    
	int result = 0;
	ostrstream output(pOutDestination, ulOutDestSize);
	ulOutDestSize = 0; // will now be filled in with actual data count
	{
	CVsDES encryptDES;
	encryptDES.OpenWrite(szPassword, &output);
	encryptDES.Write(pSource, ulSourceSize, &ulOutDestSize);
/*
#if DEBUG
   cout << "EncryptTripleDES encrypting " << ulSourceSize << " bytes ... " << ulOutDestSize;
#endif // DEBUG
*/
	encryptDES.Close(&ulOutDestSize);
/*
#if DEBUG
   cout << " ... closed at " << ulOutDestSize << endl;
#endif // DEBUG
*/
	}
	return result;
	}

static int EncryptAES(CVsAES::AESKeyLength inBits, char* pOutDestination, unsigned long& ulOutDestSize, char* pSource, unsigned long ulSourceSize, const char* szPassword)
	{
	if (!szPassword)
	    return 1;
	    
	int result = 0;
	ostrstream output(pOutDestination, ulOutDestSize);
	ulOutDestSize = 0; // will now be filled in with actual data count
	{
	CVsAES encryptAES;
	encryptAES.OpenWrite(szPassword, &output, inBits);
	encryptAES.Write(pSource, ulSourceSize, &ulOutDestSize);
/*
#if DEBUG
   cout << "EncryptAES[" << inBits << "] encrypting " << ulSourceSize << " bytes with password " << szPassword << " ... " << 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;
	}

int EncryptAES128(char* pOutDestination, unsigned long& ulOutDestSize, char* pSource, unsigned long ulSourceSize, const char* szPassword)
	{
	return EncryptAES(CVsAES::E128bits, pOutDestination, ulOutDestSize, pSource, ulSourceSize, szPassword);
	}
	
int EncryptAES192(char* pOutDestination, unsigned long& ulOutDestSize, char* pSource, unsigned long ulSourceSize, const char* szPassword)
	{
	return EncryptAES(CVsAES::E192bits, pOutDestination, ulOutDestSize, pSource, ulSourceSize, szPassword);
	}
	
int EncryptAES256(char* pOutDestination, unsigned long& ulOutDestSize, char* pSource, unsigned long ulSourceSize, const char* szPassword)
	{
	return EncryptAES(CVsAES::E256bits, pOutDestination, ulOutDestSize, pSource, ulSourceSize, szPassword);
	}

} // end namespace XTunnels