C#

byte []  EncryptLicenseKey(byte[] licenseKey)
        {
            byte[] final = new byte[14];

            byte[] left = new byte[14];
            byte[] right = new byte[14];

            byte[] Aux = new byte[14];

            int i, k;

            left = licenseKey;
            right = licenseKey;

            for (i = 0; i < 4; i++)
            {
                KeyedHash(left, Aux);


                for (k = 0; k < 8; k++)
                    Aux[k] ^= right[k];


            }

            

            // Copy right into left, then copy left into aux (normally memcpy in c++) ?????
            return Aux;

        }

void KeyedHash(byte[] Data, byte[] Result)
        {
	       

	        byte[] Key = {0xff, 0xff, 0xff, 0xff}; // will obviosly change this
        
            

            HMACSHA1 mac = new HMACSHA1(Key);

            Result = mac.ComputeHash(Data);

            
             
}

void DecryptInstID(byte[] InstID)
{
    byte[] Aux = new byte[8];
    int i, k;

    for (i = 0; i < 4; i++)
    {
        KeyedHash(InstID, Aux);

        for (k = 0; k < 8; k++)
            Aux[k] ^= InstID[k + 8];
        
        byte[].Copy(InstID, 0, InstID, 8, 8);
        byte[].Copy(Aux, InstID, 8);
    }
}

MicroVirus wrote:

byte[].Copy(InstID, 0, InstID, 8, 8);
byte[].Copy(Aux, InstID, 8);

System.Array.Copy(licenseKey, 0, licenseKey, 8, 8);

Aux[k] ^= right[k + 8];

void DecryptInstID(byte[] InstID)
{
    byte[] Aux = new byte[8];
    int i, k;

    for (i = 0; i < 4; i++)
    {
        KeyedHash(InstID, out Aux);

        for (k = 0; k < 8; k++)
            Aux[k] ^= InstID[k + 8];

        Array.Copy(InstID, 0, InstID, 8, 8);
        Array.Copy(Aux, InstID, 8);
    }
}

void KeyedHash(byte[] data, out byte[] result)
{
    System.Security.Cryptography.HMACSHA1 mac = new System.Security.Cryptography.HMACSHA1(yourKeyHere);
    result = mac.ComputeHash(data, 0, 8);
}

MicroVirus wrote:

you said 15 bytes, but the C++ code suggests/needs 16 bytes)

Left = Right ^ First-8 (SHA-1 (Left + Key))
Right = Left

stephen.darling wrote:

Yes, and when I corrected that it worked. However, in my own code I modified InstID to be a lower amount of bytes. Where in this code do I edit it so that it can do the same, but with less bytes?

OriginalGriff wrote:

Be aware that SHA is not an encryption algorithm. It is a hashing algorithm.

OriginalGriff wrote:

If you try to use SHA as a base component for your data encryption, there is very little chance that you will ever be able to decrypt your data back to the original input.

Left = Right ^ First - 8 (SHA-1 (Left + Key))
Right = Left

OriginalGriff wrote:

There are good reasons why encrypted data is generally longer that the input

OriginalGriff wrote:

If you need the size of you encrypted data to be the same as your input, then you will heavily compromise the security of that data

void DecryptInstID(byte[]InstID)
{
	int length = InstID.Length;
	if(0 != length % 2) throw new ArgumentException("Must be even length");
	length >>= 1;
	
	byte[] Aux = new byte[length];

	int i, k;
 
	Left = InstID;
	Right = InstID + 8;
 
	for (i = 0; i < 4; i++)
	{
		KeyedHash(InstID, Aux, length);
 
		for (k = 0; k < 8; k++)
			Aux[k] ^= InstID[k + length];
			
		CopyBytes(InstID, InstID, length, 0, length);
		CopyBytes(InstID, Aux, 0, 0, 8);
	}
}

void CopyBytes(byte[] target, byte[] source, int targetIndex, int sourceIndex, int length){
	for(int i = 0; i < length; i++) target[i+targetIndex] = source[i+sourceIndex];
}