public static String FromByteArrayReversed(Byte[] b)
{
StringBuilder sb = new StringBuilder(b.Length * 2);
foreach (Byte _b in b.Reverse())
{
sb.Append(_b.ToString("x2"));
}
return sb.ToString();
}
public void Restore(Byte[] distortedText, out Byte[] plainText)
{
int length = distortedText.Length;
int ceiling = length - 1;
UInt32[] rChaoticSequence = m_GenerateDistortionSequence(length).Reverse().ToArray();
Byte[] rDistortedText = distortedText.Reverse().ToArray();
for(int i = 0; i < length; ++i)
{
Utils.Swap(ref rDistortedText[i], ref rDistortedText[ceiling - rChaoticSequence[i] % length]);
}
plainText = rDistortedText.Reverse().ToArray();
}
public static String FromByteArray(Byte[] b)
{
StringBuilder sb = new StringBuilder();
BigInteger bi = new BigInteger(b.Reverse().Concat(new Byte[] {0x00}).ToArray()); // concat adds sign byte
// Calc base58 representation
while (bi > 0)
{
int mod = (int)(bi % 58);
bi /= 58;
sb.Insert(0, base58chars[mod]);
}
// Add 1s for leading 0x00 bytes
for (int i = 0; i < b.Length && b[i] == 0x00; i++)
sb.Insert(0, '1');
return sb.ToString();
}
private void Parse(Templates templates)
{
this._flowset = new List<FlowSet>();
Int32 length = _bytes.Length - 20;
Byte[] header = new Byte[20];
Byte[] flowset = new Byte[length];
Array.Copy(_bytes, 0, header, 0, 20);
Array.Copy(_bytes, 20, flowset, 0, length);
this._header = new Header(header);
byte[] reverse = flowset.Reverse().ToArray();
int templengh = 0;
while ((templengh + 2) < flowset.Length)
{
UInt16 lengths = BitConverter.ToUInt16(reverse, flowset.Length - sizeof(Int16) - (templengh+2));
Byte[] bflowsets = new Byte[lengths];
Array.Copy(flowset, templengh, bflowsets, 0, lengths);
FlowSet flowsets = new FlowSet(bflowsets, templates);
this._flowset.Add(flowsets);
templengh += lengths;
}
}
public static string GetBinaryString(Byte[] data)
{
string output = "";
foreach (byte lByte in data.Reverse())
{
char[] b = new char[8];
int pos = 7;
int i = 0;
while (i < 8)
{
if ((lByte & (1 << i)) != 0)
{
b[pos] = '1';
}
else
{
b[pos] = '0';
}
pos--;
i++;
}
output += new string(b);
}
return output;
}
/// <summary>
/// DES加密
/// </summary>
/// <param name="plain">8Byte字节数组明文</param>
/// <param name="key">8Byte字节数组密文</param>
/// <returns></returns>
public static byte[] Encrypt(Byte[] plain, Byte[] key)
{
if (plain.Length > 8 || key.Length > 8)
{
throw new ArgumentException("Plain text and key should be 8 bytes.");
}
//不足8字节，补0
if (plain.Length < 8)
{
plain = plain.Concat(new Byte[8 - plain.Length]).ToArray();
}
if (key.Length < 8)
{
key = key.Concat(new Byte[8 - key.Length]).ToArray();
}
//转为位数组 处理小端->大端
BitArray input = new BitArray(plain.Reverse().ToArray()).Reverse();
BitArray inputKey = new BitArray(key.Reverse().ToArray()).Reverse();
Debug.WriteLine("[PLAIN]" + input.PrintInBinary());
Debug.WriteLine("[KEY]" + inputKey.PrintInBinary());
//初始置换
input = FirstSwap(input);
//Debug.WriteLine(input.PrintInHex());
BitArray[] keys = new BitArray[16];
//设置L R
RoundPackage rounds = new RoundPackage();
rounds.L.SetRange(0, 32, input);
rounds.R.SetRange(0, 32, input, 32);
//生成16轮用子密钥
keys = GenerateKeys(inputKey);
//16轮加密
for (int i = 0; i < 16; i++)
{
rounds = Round(rounds, keys[i]);
//Debug.WriteLine("i:{3}, L:{0},R:{1},Ki:{2}", rounds.L.PrintInBinary(), rounds.R.PrintInBinary(), keys[i].PrintInBinary(),i+1);
}
//Debug.WriteLine("L:{0},R:{1}", rounds.L.PrintInBinary(), rounds.R.PrintInBinary());
BitArray output = new BitArray(64);
//拼接：R+L
output = rounds.R.Append(rounds.L);
//Debug.WriteLine(output.PrintInBinary());
//逆初始置换
output = ReverseFirstSwap(output);
Debug.WriteLine("[ENCRYPT]" + output.PrintInBinary());
return output.ToByteArray();
}
public static byte[] Decrypt(Byte[] inputBytes, Byte[] key)
{
if (inputBytes.Length > 8 || key.Length > 8)
{
throw new ArgumentException("Encrypted text and key should be 8 bytes.");
}
if (inputBytes.Length < 8)
{
inputBytes = inputBytes.Concat(new Byte[8 - inputBytes.Length]).ToArray();
}
if (key.Length < 8)
{
key = key.Concat(new Byte[8 - key.Length]).ToArray();
}
//BitArray input = new BitArray(inputBytes);
//BitArray inputKey = new BitArray(key);
//处理小端->大端
BitArray input = new BitArray(inputBytes.Reverse().ToArray()).Reverse();
BitArray inputKey = new BitArray(key.Reverse().ToArray()).Reverse();
Debug.WriteLine("[ENCRYPTED]" + input.PrintInBinary());
Debug.WriteLine("[KEY]" + inputKey.PrintInBinary());
input = FirstSwap(input);
BitArray[] keys = new BitArray[16];
RoundPackage rounds = new RoundPackage();
rounds.L.SetRange(0, 32, input);
rounds.R.SetRange(0, 32, input, 32);
keys = GenerateKeys(inputKey);
//Debug.WriteLine("L:{0},R:{1},Ki:{2}", rounds.L.PrintInHex(), rounds.R.PrintInHex(), keys[15].PrintInHex());
for (int i = 15; i >= 0; i--)
{
rounds = Round(rounds, keys[i]);
//Debug.WriteLine("L:{0},R:{1},Ki:{2}", rounds.L.PrintInHex(), rounds.R.PrintInHex(), keys[i].PrintInHex());
}
BitArray output = new BitArray(64);
output = rounds.R.Append(rounds.L);
output = ReverseFirstSwap(output);
Debug.WriteLine("[DECRYPT]" + output.PrintInBinary());
return output.ToByteArray();
}