示例#1
0
        public static string Decrypt(string data, string hexKey)
        {
            //data karıştırılır
            string binaryData = BinaryHelper.GetBitsFromHex(data);

            var result = Crypt(binaryData, hexKey, EnumProcessType.DECRYPTION);

            return(BinaryHelper.GetStringFromBits(result));
        }
示例#2
0
        public static string Crypt(string binaryData, string hexKey, EnumProcessType processType)
        {
            //hexKey bit string'e dönüşütürülür
            string bitKey = BinaryHelper.GetBitsFromHex(hexKey);

            //Key 64 bit'ten 56 bit'e dönüştürülür
            bitKey = CompressionPermutationKeyInit(bitKey);

            string result = "";

            List <int> roundIndexes = new List <int>();

            for (int index = 0; index < ((decimal)binaryData.Length / (decimal)64); index++)
            {
                roundIndexes.Add(index);
            }

            //On decrpytion, rounds are reversed
            if (processType == EnumProcessType.DECRYPTION)
            {
                roundIndexes.Reverse();
            }


            foreach (int index in roundIndexes)
            {
                bool finished = false;

                string currentBinaryString = binaryData.Substring(index * 64);

                if (currentBinaryString.Length > 64)
                {
                    currentBinaryString = currentBinaryString.Substring(0, 64);

                    finished = processType == EnumProcessType.DECRYPTION && index == 0;
                }
                else
                {
                    finished = processType == EnumProcessType.ENCRYPTION ||  (processType == EnumProcessType.DECRYPTION && index == 0);
                }

                currentBinaryString = InitialPermutation(currentBinaryString);

                //32'şer bit olarak data ikiye ayrılır
                string leftBinaryString  = currentBinaryString.Substring(0, currentBinaryString.Length / 2);
                string rightBinaryString = currentBinaryString.Substring(currentBinaryString.Length / 2);

                var cryptIndexes = new List <int>();
                for (int cryptIndex = 0; cryptIndex < 16; cryptIndex++)
                {
                    cryptIndexes.Add(cryptIndex);
                }

                if (processType == EnumProcessType.DECRYPTION)
                {
                    cryptIndexes.Reverse();
                }

                //cryp işlemleri 16 kez tekrarlanır. Her adımda data çaprazlanır
                foreach (int cryptIndex in cryptIndexes)
                {
                    //Bu adım için 56 bitlik Key'den 48 bitlik yeni key üretilir
                    var transformedKey = KeyTransformation(bitKey, cryptIndex, processType);

                    //FUNCTION çalıştırılır
                    var expandedRightBinaryString = MainFunction(rightBinaryString, transformedKey);

                    //leftBinaryString (48bit) ve expandedRightBinaryString (48bit) XOR'lanır (her bit ikilik sistemde toplanıp mod2'si alınır)
                    leftBinaryString = XORArray(leftBinaryString, expandedRightBinaryString);

                    //left ve right'ın yerleri değiştirilerek yeni adıma hazırlanır. (çaprazlama)
                    string prevLeftBinaryString = leftBinaryString;
                    leftBinaryString  = rightBinaryString;
                    rightBinaryString = prevLeftBinaryString;
                }

                //sonuçta elde edilen left ve right birbirine eklenerek 64 bitlik data elde edilir
                var resultBinary = leftBinaryString + rightBinaryString;
                resultBinary = FinalPermutation(resultBinary);
                result      += resultBinary;

                if (finished)
                {
                    break;
                }
            }

            return(result);
        }