/// <summary>
/// Decrypts a set of Taylor Swift lyrics into the original byte data.
/// </summary>
/// <param name="data">The string representation of the Taylor Swift lyrics to decrypt.</param>
/// <param name="key">The 256 bit Key used to encrypt the data.</param>
/// <param name="iv">The 128 bit IV used to encrypt the data.</param>
public byte[] Decrypt(string data, byte[] key, byte[] iv)
{
// Validate key parameter
if (key == null)
throw new ArgumentNullException("key");
if (key.Length == 0)
throw new ArgumentException("The key parameter can not be empty.", "key");
if (key.Length * 8 != KeyBitSize)
throw new ArgumentException($"The key parameter must be {KeyBitSize} bits long.", "key");
// Validate iv parameter
if (iv == null)
throw new ArgumentNullException("iv");
if (iv.Length == 0)
throw new ArgumentException("The iv parameter can not be empty.", "iv");
if (iv.Length * 8 != BlockBitSize)
throw new ArgumentException($"The iv parameter must be {BlockBitSize} bits long.", "iv");
// Get fingerprint id's from the fingerprint strings
var fingerprintIds = new List<int>();
foreach (var lyric in data.Split('\n'))
{
if (lyric.Trim() == string.Empty)
continue;
fingerprintIds.Add(
_fingerprintManager.GetIndexOfFingerprint(
_fingerprintManager.GetFromLyric(lyric)));
}
var bitArray = new BitArray(fingerprintIds.Count * 10);
var index = 0;
foreach (var x in fingerprintIds)
{
var arr = new BitArray(new int[] { x });
bitArray.Set(index++, arr.Get(0));
bitArray.Set(index++, arr.Get(1));
bitArray.Set(index++, arr.Get(2));
bitArray.Set(index++, arr.Get(3));
bitArray.Set(index++, arr.Get(4));
bitArray.Set(index++, arr.Get(5));
bitArray.Set(index++, arr.Get(6));
bitArray.Set(index++, arr.Get(7));
bitArray.Set(index++, arr.Get(8));
bitArray.Set(index++, arr.Get(9));
}
var encryptedData = bitArray.ToByteArray();
// Remove Padding from encrypted data
var paddingLength = encryptedData[encryptedData.Length - 1];
Array.Resize(ref encryptedData, encryptedData.Length - paddingLength);
// Decrypt Data
var decryptedData = DecryptPayload(encryptedData, key, iv);
return decryptedData;
}
public byte[] DecodeHiddenMessage(byte[] container)
{
var openedFile = TextUtils.GetUTF8CharArrayFromByteStream(container);
var messageBits = new BitArray(openedFile.SpaceCount());
var shouldReadOneBit = false;
var numberOfBitToPut = 0;
for (var i = 0; i < openedFile.Length; i++)
{
if (shouldReadOneBit)
{
messageBits.Set(numberOfBitToPut, openedFile[i] == SPACE);
numberOfBitToPut++;
shouldReadOneBit = false;
continue;
}
shouldReadOneBit = openedFile[i] == SPACE;
}
return messageBits.ToByteArray();
}
/// <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();
}
public static void EncryptWithAddZero(string file_input, string file_output, string key1)
{
FileStream input;
BinaryReader br;
FileStream output;
BinaryWriter bw;
byte[] block;
key = new Key(key1);
Utils.key.makeKey();
try
{
input = new FileStream(file_input, FileMode.Open, FileAccess.Read);
br = new BinaryReader(input);
output = new FileStream(file_output, FileMode.Create, FileAccess.Write);
bw = new BinaryWriter(output);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return;
}
try
{
while ((block = br.ReadBytes(8)).Length > 0)
{
if (input.Position == input.Length)
{
byte[] lol = new byte[8];
for (int i = 0; i < 8; i++)
{
if (i < block.Length)
{
lol[i] = block[i];
}
else
{
lol[i] += (byte)0;
}
}
int block_do_zapisu = 8 - block.Length;
BitArray encrypted_message = Utils.makeMessage(napraw(lol));
bw.Write((encrypted_message.ToByteArray()));
BitArray b = new BitArray(new int[] { block_do_zapisu, 0 });
b = Utils.makeMessage(napraw(b.ToByteArray()));
bw.Write((b.ToByteArray()));
}
else
{
BitArray encrypted_message = Utils.makeMessage(napraw(block));
bw.Write((encrypted_message.ToByteArray()));
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
input.Close();
output.Close();
br.Close();
bw.Close();
}
finally
{
input.Close();
output.Close();
br.Close();
bw.Close();
}
}
public byte[] DecodeHiddenMessage(byte[] container)
{
_customCodingValidator.CheckIfCanDecodeMessageOrThrow(container);
var settings = new SettingsFrameFromContent(container);
var headerPositiveBits = settings.ToBitArray().GetPositiveBitsCount();
var headerSize = headerPositiveBits + HEADER_FRAME_MIN_SIZE;
var hiddenMessageBits = new BitArray(settings.MessageLength);
var decodedHiddenBits = 0;
var hiddenBitCounter = 0;
var containerChars = TextUtils.GetUTF8CharArrayFromByteStream(container);
for (int i = headerSize + settings.Shift; i < headerSize + settings.MessageLength; i+= settings.JumpValue + 1)
{
if (hiddenBitCounter < hiddenMessageBits.Length)
{
var let = containerChars[i + decodedHiddenBits];
if (containerChars[i + decodedHiddenBits] == settings.Coding)
{
hiddenMessageBits.Set(hiddenBitCounter, true);
decodedHiddenBits++;
}
else
{
hiddenMessageBits.Set(hiddenBitCounter, false);
}
hiddenBitCounter++;
}
else
{
break;
}
}
var arej = hiddenMessageBits.ToByteArray();
return arej;
}
public void UpdatePermissions(IList<Permission> list)
{
var bits = new BitArray(new byte[Enum.GetValues(typeof(Permission)).Length]);
foreach (var item in list)
{
bits[(int)item] = true;
}
Permissions = bits.ToByteArray();
}
