static void Main(string[] args)
{
var bits = new BitArray(2);
bits[1] = true;
bits.Xor(bits); // Bitwise exclusive-OR bits with itself
Console.WriteLine(bits[1]); // False
}
public static byte[] Xor(byte[] value1, byte[] value2) {
var array1 = new BitArray(value1);
var array2 = new BitArray(value2);
var result = array1.Xor(array2);
byte[] b = new byte[result.Count / 8];
result.CopyTo(b, 0);
return b;
}
public static BitArray Clean(BitArray depthMap, int depthWidth, byte[] video, int videoWidth)
{
BitArray orig = new BitArray(depthMap);
// find the border: grow, extract the difference, grow again.
const int growthSize = 2;
var grownMap = Dilate(depthMap, depthWidth, growthSize);
var border = Dilate(depthMap.Xor(grownMap), depthWidth, growthSize + 1);
// get a more accurate picture by filtering by video
var filteredBorder = FilterByVideo(border, depthWidth, video, videoWidth);
var enhancedMap = (filteredBorder == null) ? orig : border.Not().Or(filteredBorder).And(grownMap);
return RemoveNoise(enhancedMap, depthWidth);
}
static public int Xor(IntPtr l)
{
try {
System.Collections.BitArray self = (System.Collections.BitArray)checkSelf(l);
System.Collections.BitArray a1;
checkType(l, 2, out a1);
var ret = self.Xor(a1);
pushValue(l, true);
pushValue(l, ret);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
void DecryptionCBC()
{
var key = Encoding.GetEncoding(1251).GetBytes(Key.ToString().PadLeft(8, '0'));
GenerationKey(new BitArray(key));
AddTempBit(BitArrayET);
BitArrayDT = new BitArray(BitArrayET.Length);
BitArray C = new BitArray(PSCh());
for (var i = 0; i < BitArrayET.Length; i += 64)
{
var aBitEncrypt = GetValue(BitArrayET, i, i + 64);
var aBitDecryption = base.Decryption(new BitArray(aBitEncrypt));
var M = C.Xor(aBitDecryption);
C = aBitEncrypt;
Concat(BitArrayDT, M, i);
}
}
/// <summary>
/// Xors the 2 component.
/// </summary>
/// <param name="compA">Component.</param>
/// <param name="compB">Component.</param>
/// <returns>Xor result as string</returns>
public string XOR(string compA, string compB = null)
{
if (compB == null)
{
compB = ReverseString(compA);
}
var barA = new BitArray(HexToByte(compA));
var barB = new BitArray(HexToByte(compB));
var barC = new BitArray(compA.Length);
barC = barB.Xor(barA);
var byteC = new byte[barC.Length / 8];
barC.CopyTo(byteC, 0);
return ByteToHex(byteC);
}
private Valor XOR(Valor llave1, Valor llave2)
{
byte[] llaveArray1 = ASCIIEncoding.ASCII.GetBytes(llave1.ToString());
byte[] llaveArray2 = ASCIIEncoding.ASCII.GetBytes(llave2.ToString());
BitArray bitArray1 = new BitArray(llaveArray1);
BitArray bitArray2 = new BitArray(llaveArray2);
BitArray bitArrayResultado=bitArray1.Xor(bitArray2);
byte[] llaveArrayResultado = ToByteArray(bitArrayResultado);
string resultado = Convert.ToBase64String(llaveArrayResultado, 0, llaveArrayResultado.Length);
return new Caracter(resultado);
}
static void BitArrayDemo()
{
var bits1 = new BitArray(8);
bits1.SetAll(true);
bits1.Set(1, false);
bits1[5] = false;
bits1[7] = false;
Console.Write("initialized: ");
DisplayBits(bits1);
Console.WriteLine();
DisplayBits(bits1);
bits1.Not();
Console.Write(" not ");
DisplayBits(bits1);
Console.WriteLine();
var bits2 = new BitArray(bits1);
bits2[0] = true;
bits2[1] = false;
bits2[4] = true;
DisplayBits(bits1);
Console.Write(" or ");
DisplayBits(bits2);
Console.Write(" : ");
bits1.Or(bits2);
DisplayBits(bits1);
Console.WriteLine();
DisplayBits(bits2);
Console.Write(" and ");
DisplayBits(bits1);
Console.Write(" : ");
bits2.And(bits1);
DisplayBits(bits2);
Console.WriteLine();
DisplayBits(bits1);
Console.Write(" xor ");
DisplayBits(bits2);
bits1.Xor(bits2);
Console.Write(" : ");
DisplayBits(bits1);
Console.WriteLine();
}
public CodedPiece CodeSegments()
{
List<int> pieceBuilders = new List<int>() { firstSegment.SegmentNumber };
BitArray xoredBits = new BitArray(firstSegment.Data);
foreach (FileSegment segment in segments.Skip(1))
{
var currentBits = new BitArray(segment.Data);
xoredBits = xoredBits.Xor(currentBits);
pieceBuilders.Add(segment.SegmentNumber);
}
return new CodedPiece()
{
BasedOnSegments = pieceBuilders,
CodedWord = xoredBits
};
}
/// <summary>
/// Bitwise XOR for 2 Bytes.
/// </summary>
/// <param name="t1">Left side for comparison</param>
/// <param name="t2">Right side for comparison</param>
/// <returns>Resulting byte</returns>
static internal byte BitwiseXOR(byte t1, byte t2)
{
BitArray baLft = null;
BitArray baRght = null;
BitArray baXor = null;
//Have to use Byte Arrays as the constructor for the BitArray, otherwise the
//integer value of the current byte is used to set the length of the bitArray instead of the value.
byte[] bytL = new byte[1];
byte[] bytR = new byte[1];
bytL[0] = t1;
bytR[0] = t2;
baLft = new BitArray(bytL);
baRght = new BitArray(bytR);
baXor = baLft.Xor(baRght);
byte[] ba2BytArr = new byte[8];
baXor.CopyTo(ba2BytArr, 0);
return ba2BytArr[0];
}
private bool PrefixesEquals(CidrRange other)
{
var leftMask = new BitArray(Prefix);
var leftSuffix = new BitArray(32, false);
for (int i = 31; i >= 32 - Suffix; i--)
{
leftSuffix[i] = true;
}
leftMask = leftSuffix.And(leftMask);
var rightMask = new BitArray(other.Prefix);
var rightSuffix = new BitArray(32, false);
for (int i = 31; i >= 32 - other.Suffix; i--)
{
rightSuffix[i] = true;
}
rightMask = rightSuffix.And(rightMask);
var result = rightMask.Xor(leftMask);
return result.Cast<bool>().ToArray().Skip(32 - Math.Min(Suffix, other.Suffix)).All(x => !x);
}
/// <summary>
/// Шифруем строку, используя двоичные данные ключа. Данные ключа должны быть длиннее чем сообщение
/// </summary>
/// <param name="message"></param>
/// <param name="keyData"></param>
/// <returns></returns>
public static String Encode(String message, byte[] keyData)
{
// Проверяем длину данных ключа
if (message.Length > keyData.Length)
throw new ArgumentException("Insufficient Key Data");
// Используем кодировку ASCII, чтобы получить массив байтов из строки сообщения
byte[] msgBytes = Encoding.ASCII.GetBytes(message);
byte[] trimData = new byte[msgBytes.Length];
// Оба битовых массива должны быть одной длины, копируем необходимое количество байт из массива ключевых данных
Array.Copy(keyData, trimData, trimData.Length);
// Создаем массив битов из данных сообщения и ключевых данных
BitArray msg = new BitArray(msgBytes);
BitArray key = new BitArray(trimData);
// Выполняем операцию XOR на двух массивах
BitArray output = msg.Xor(key);
// Копирует массив вывода в массив сообщения
output.CopyTo(msgBytes, 0);
// Используем кодировку base-64 чтобы преобразовать двоичные данные в печатаемую строку
return Convert.ToBase64String(msgBytes);
}
/// <summary>
/// Расшифровываем зашифрованную строку
/// </summary>
/// <param name="message"></param>
/// <param name="keyData"></param>
/// <returns></returns>
public static string Decode(String message, byte[] keyData)
{
// Восстанавливаем оригинальные байты из строки с кодировкой base-64
byte[] msgBytes = Convert.FromBase64String(message);
byte[] trimData = new byte[msgBytes.Length];
// Копируем необходимое число байтов из ключа
Array.Copy(keyData, trimData, trimData.Length);
// Выполняем xor на двоичных данных, чтобы восстановить начальные биты
BitArray msg = new BitArray(msgBytes);
BitArray key = new BitArray(trimData);
BitArray output = msg.Xor(key);
// Копируем переведенные биты в массив сообщения
output.CopyTo(msgBytes, 0);
// Воспроизводим изначальную строку используя ASCII декодирование
return Encoding.ASCII.GetString(msgBytes);
}
/// <summary>
/// DES一轮加密
/// </summary>
/// <param name="p"></param>
/// <param name="ki"></param>
/// <returns></returns>
private static RoundPackage Round(RoundPackage p, BitArray ki)
{
RoundPackage next = new RoundPackage(p.RoundID + 1);
//扩展/置换
BitArray exR = new BitArray(48);
for (int i = 0; i < 48; i++)
{
//扩展32位至48位
//E的值从1开始
exR[i] = p.R[E[i] - 1];
}
//XOR
var s = exR.Xor(ki);
//S盒（48->32）
s = SBox(s);
//置换
s = SwapP(s);
//XOR
next.R = s.Xor(p.L);
next.L = p.R;
return next;
}
string RenameLetters(string originalName)
{
BitArray arr = new BitArray(md5.ComputeHash(Encoding.UTF8.GetBytes(originalName)));
Random rand = new Random(originalName.GetHashCode() * seed);
byte[] xorB = new byte[arr.Length / 8];
rand.NextBytes(xorB);
BitArray xor = new BitArray(xorB);
BitArray result = arr.Xor(xor);
byte[] buff = new byte[result.Length / 8];
result.CopyTo(buff, 0);
StringBuilder ret = new StringBuilder();
int m = 0;
for (int i = 0; i < buff.Length; i++)
{
m = (m << 8) + buff[i];
while (m > 52)
{
int n = m % 26;
if (n < 26)
ret.Append((char)('A' + n));
else
ret.Append((char)('a' + (n - 26)));
m /= 52;
}
}
return ret.ToString();
}
private BitArray Xor(BitArray arr1, BitArray arr2)
{
return arr1.Xor(arr2);
}
private void doLiveoutSets(ProgramBlock<SparcInstruction> start)
{
bool changed = false;
do
{
changed = false;
foreach (var f in start.Functions)
{
if (coloringDone.Contains(f.Name))
continue;
f.VisitBlocks(b =>
{
var gset = genSets[b];
var kset = killSets[b];
var lset = liveoutSets[b];
var newLset = new BitArray(numRegs);
if (!b.IsReturn)
{
foreach (var suc in b.Nexts)
{
var sucKset = killSets[suc as BasicBlock<SparcInstruction>];
var sucGset = genSets[suc as BasicBlock<SparcInstruction>];
var sucLset = liveoutSets[suc as BasicBlock<SparcInstruction>];
var sucSet = new BitArray(numRegs);
//do lset - kset
sucSet.Or(sucLset).Xor(sucKset).And(sucLset);
//do gen union with the above
sucSet.Or(sucGset);
//union with new lset
newLset.Or(sucSet);
}
}
var countingSet = new BitArray(lset);
countingSet.Xor(newLset);
var countArr = new int[countingSet.IntArraySize()];
countingSet.CopyTo(countArr, 0);
for (int i = 0; i < countArr.Length; i++)
{
changed |= countArr[i] != 0;
}
if (changed)
{
liveoutSets[b] = newLset;
}
}, false);
}
}
while (changed);
}
void EncryptionCBC()
{
var key = Encoding.GetEncoding(1251).GetBytes(Key.ToString().PadLeft(8, '0'));
GenerationKey(new BitArray(key));
AddTempBit(BitArrayOT);
BitArrayET = new BitArray(BitArrayOT.Length);
BitArray C = new BitArray(PSCh());
for (var i = 0; i < BitArrayOT.Length; i += 64)
{
var M = GetValue(BitArrayOT, i, i + 64);
var aBitEncrypted = base.Encryption(new BitArray(C.Xor(M)));
C = aBitEncrypted;
Concat(BitArrayET, aBitEncrypted, i);
}
}
private static void AssertBitArraysAreEqual(BitArray actual, BitArray expected)
{
// check that these have the same length, and then their XOR is zero.
Assert.AreEqual(actual.Length, expected.Length);
var diff = actual.Xor(expected);
for (int i = 0; i < actual.Length; i++)
Assert.IsFalse(diff[i]);
}
static object SafeConstants(uint id)
{
Dictionary <uint, object> hashTbl;
if ((hashTbl = AppDomain.CurrentDomain.GetData("PADDINGPADDINGPADDING") as Dictionary <uint, object>) == null)
{
AppDomain.CurrentDomain.SetData("PADDINGPADDINGPADDING", hashTbl = new Dictionary <uint, object>());
MemoryStream stream = new MemoryStream();
Assembly asm = Assembly.GetCallingAssembly();
using (DeflateStream str = new DeflateStream(asm.GetManifestResourceStream("PADDINGPADDINGPADDING"), CompressionMode.Decompress))
{
byte[] dat = new byte[0x1000];
int read = str.Read(dat, 0, 0x1000);
do
{
stream.Write(dat, 0, read);
read = str.Read(dat, 0, 0x1000);
}while (read != 0);
}
AppDomain.CurrentDomain.SetData("PADDINGPADDINGPADDINGPADDING", stream.ToArray());
}
object ret;
uint x = (uint)new StackFrame(1).GetMethod().MetadataToken;
uint h = 0x67452301 ^ x;
uint h1 = 0x3bd523a0;
uint h2 = 0x5f6f36c0;
for (uint i = 1; i <= 64; i++)
{
h = (h & 0x00ffffff) << 8 | ((h & 0xff000000) >> 24);
uint n = (h & 0xff) % 64;
if (n >= 0 && n < 16)
{
h1 |= (((h & 0x0000ff00) >> 8) & ((h & 0x00ff0000) >> 16)) ^ (~h & 0x000000ff);
h2 ^= (h * i + 1) % 16;
h += (h1 | h2) ^ 12345678;
}
else if (n >= 16 && n < 32)
{
h1 ^= ((h & 0x00ff00ff) << 8) ^ (((h & 0x00ffff00) >> 8) | (~h & 0x0000ffff));
h2 += (h * i) % 32;
h |= (h1 + ~h2) & 12345678;
}
else if (n >= 32 && n < 48)
{
h1 += ((h & 0x000000ff) | ((h & 0x00ff0000) >> 16)) + (~h & 0x000000ff);
h2 -= ~(h + n) % 48;
h ^= (h1 % h2) | 12345678;
}
else if (n >= 48 && n < 64)
{
h1 ^= (((h & 0x00ff0000) >> 16) | ~(h & 0x0000ff)) * (~h & 0x00ff0000);
h2 += (h ^ i - 1) % n;
h -= ~(h1 ^ h2) + 12345678;
}
}
uint pos = h ^ id;
if (!hashTbl.TryGetValue(pos, out ret))
{
using (BinaryReader rdr = new BinaryReader(new MemoryStream((byte[])AppDomain.CurrentDomain.GetData("PADDINGPADDINGPADDINGPADDING"))))
{
rdr.BaseStream.Seek(pos, SeekOrigin.Begin);
byte type = rdr.ReadByte();
byte[] f = rdr.ReadBytes(rdr.ReadInt32());
Random rand = new Random(12345678 ^ (int)pos);
byte[] k = new byte[f.Length];
rand.NextBytes(k);
System.Collections.BitArray arr = new System.Collections.BitArray(f);
arr.Xor(new System.Collections.BitArray(k));
arr.CopyTo(f, 0);
if (type == 11)
{
ret = BitConverter.ToDouble(f, 0);
}
else if (type == 22)
{
ret = BitConverter.ToSingle(f, 0);
}
else if (type == 33)
{
ret = BitConverter.ToInt32(f, 0);
}
else if (type == 44)
{
ret = BitConverter.ToInt64(f, 0);
}
else if (type == 55)
{
ret = Encoding.UTF8.GetString(f);
}
hashTbl[pos] = ret;
}
}
return(ret);
}
public void afterIteration(int iterationIndex)
{
BitArray left_side_copy = new BitArray(leftSide[iterationIndex - 1]);
rightSide[iterationIndex] = left_side_copy.Xor(rightSide[iterationIndex]);
leftSide[iterationIndex] = rightSide[iterationIndex - 1];
}
static void Main(string[] args)
{
// Creates an initializes several BitArrays.
BitArray myBA1 = new BitArray(5);
BitArray myBA2 = new BitArray(5, false);
byte[] myBytes = new byte[5] { 1, 2, 3, 4, 5 };
BitArray myBA3 = new BitArray(myBytes);
bool[] myBools = new bool[5] { true, false, true, true, false };
BitArray myBA4 = new BitArray(myBools);
int[] myInts = new int[5] { 6, 7, 8, 9, 10 };
BitArray myBA5 = new BitArray(myInts);
// Displays the properties and values of the BitArrays.
Console.WriteLine("myBA1");
Console.WriteLine(" Count: {0}", myBA1.Count);
Console.WriteLine(" Length: {0}", myBA1.Length);
Console.WriteLine(" Values:");
PrintValues(myBA1, 8);
Console.WriteLine("myBA2");
Console.WriteLine(" Count: {0}", myBA2.Count);
Console.WriteLine(" Length: {0}", myBA2.Length);
Console.WriteLine(" Values:");
PrintValues(myBA2, 8);
Console.WriteLine("myBA3");
Console.WriteLine(" Count: {0}", myBA3.Count);
Console.WriteLine(" Length: {0}", myBA3.Length);
Console.WriteLine(" Values:");
PrintValues(myBA3, 8);
Console.WriteLine("myBA4");
Console.WriteLine(" Count: {0}", myBA4.Count);
Console.WriteLine(" Length: {0}", myBA4.Length);
Console.WriteLine(" Values:");
PrintValues(myBA4, 8);
Console.WriteLine("myBA5");
Console.WriteLine(" Count: {0}", myBA5.Count);
Console.WriteLine(" Length: {0}", myBA5.Length);
Console.WriteLine(" Values:");
PrintValues(myBA5, 8);
int[] myAntiInts = new int[5] { -1, -1, -1, -1, -1 };
BitArray myBA6 = new BitArray(myAntiInts);
Console.WriteLine("myBA6");
Console.WriteLine(" Count: {0}", myBA5.Count);
Console.WriteLine(" Length: {0}", myBA5.Length);
Console.WriteLine(" Values:");
PrintValues(myBA6, 8);
Console.WriteLine("\nXORing BA5 with BA6...\n");
BitArray myBA7 = myBA5.Xor(myBA6);
Console.WriteLine("myBA7");
Console.WriteLine(" Count: {0}", myBA5.Count);
Console.WriteLine(" Length: {0}", myBA5.Length);
Console.WriteLine(" Values:");
PrintValues(myBA7, 8);
Console.WriteLine("myBA5");
Console.WriteLine(" Count: {0}", myBA5.Count);
Console.WriteLine(" Length: {0}", myBA5.Length);
Console.WriteLine(" Values:");
PrintValues(myBA5, 8);
Console.WriteLine("myBA6");
Console.WriteLine(" Count: {0}", myBA5.Count);
Console.WriteLine(" Length: {0}", myBA5.Length);
Console.WriteLine(" Values:");
PrintValues(myBA6, 8);
Console.WriteLine("\nNot on myBA5:\n");
myBA5.Not();
Console.WriteLine("myBA5");
Console.WriteLine(" Count: {0}", myBA5.Count);
Console.WriteLine(" Length: {0}", myBA5.Length);
Console.WriteLine(" Values:");
PrintValues(myBA5, 8);
}
private BitArray feistelFunction(BitArray keyBits, BitArray Bittext_16)
{
BitArray afterParity = Bittext_16;
if (checkParity(keyBits)) //true if parity is even
{
afterParity = Bittext_16.Not();
//Console.WriteLine("Right after negating : " + BitOperations.getBinaryString(afterParity));
}
//Console.WriteLine("Keybits for xoring : " + BitOperations.getBinaryString(keyBits));
var feistelOutput = keyBits.Xor(new BitArray(afterParity));
//Console.WriteLine("right 16 bits after fiestal function : " + BitOperations.getBinaryString(a));
return feistelOutput;
}
BitArray F(BitArray aBite, BitArray Key)
{
ExtensionE(ref aBite);
aBite.Xor(Key);
BitArray tempBitArray = new BitArray(32);
var iBlock = 1;
var iTempBitsBlock = 0;
for (var i = 0; i < aBite.Length; i += 6)
{
SetBits(ref tempBitArray, GammirovaniyeS(GetValue(aBite, i, i + 6), iBlock++), iTempBitsBlock);
iTempBitsBlock += 4;
}
aBite = Permutation(tempBitArray, P);
return aBite;
}
/// <summary>
/// Generate one xor round.
/// </summary>
/// <param name="to">Where to put the result</param>
/// <param name="key">Key used</param>
/// <param name="counter">Shifter of the key</param>
private void GenerateOneRound(ref BitArray to, BitArray key, int counter)
{
this.ExtendToSizeLeft(ref this.KeyExtended, key, to.Length, counter);
to = to.Xor(this.KeyExtended);
}
public static void BitArray_Helper(Operator op)
{
BitArray ba2 = null;
BitArray ba3 = null;
BitArray ba4 = null;
// [] Standard cases (1,1) (1,0) (0,0).
ba2 = new BitArray(6, false);
ba3 = new BitArray(6, false);
ba2.Set(0, true);
ba2.Set(1, true);
ba3.Set(1, true);
ba3.Set(2, true);
switch (op)
{
case Operator.Xor:
ba4 = ba2.Xor(ba3);
Assert.True(ba4.Get(0)); //"Err_8! Expected ba4.Get(0) to be true"
Assert.False(ba4.Get(1)); //"Err_9! Expected ba4.Get(1) to be false"
Assert.True(ba4.Get(2)); //"Err_10! Expected ba4.Get(2) to be true"
Assert.False(ba4.Get(4)); //"Err_11! Expected ba4.Get(4) to be false"
break;
case Operator.And:
ba4 = ba2.And(ba3);
Assert.False(ba4.Get(0)); //"Err_12! Expected ba4.Get(0) to be false"
Assert.True(ba4.Get(1)); //"Err_13! Expected ba4.Get(1) to be true"
Assert.False(ba4.Get(2)); //"Err_14! Expected ba4.Get(2) to be false"
Assert.False(ba4.Get(4)); //"Err_15! Expected ba4.Get(4) to be false"
break;
case Operator.Or:
ba4 = ba2.Or(ba3);
Assert.True(ba4.Get(0)); //"Err_16! Expected ba4.Get(0) to be true"
Assert.True(ba4.Get(1)); //"Err_17! Expected ba4.Get(1) to be true"
Assert.True(ba4.Get(2)); //"Err_18! Expected ba4.Get(2) to be true"
Assert.False(ba4.Get(4)); //"Err_19! Expected ba4.Get(4) to be false"
break;
}
// [] Size stress cases.
ba2 = new BitArray(0x1000F, false);
ba3 = new BitArray(0x1000F, false);
ba2.Set(0x10000, true); // The bit for 1 (2^0).
ba2.Set(0x10001, true); // The bit for 2 (2^1).
ba3.Set(0x10001, true); // The bit for 2 (2^1).
switch (op)
{
case Operator.Xor:
ba4 = ba2.Xor(ba3);
Assert.True(ba4.Get(0x10000)); //"Err_20! Expected ba4.Get(0x10000) to be true"
Assert.False(ba4.Get(0x10001)); //"Err_21! Expected ba4.Get(0x10001) to be false"
Assert.False(ba4.Get(0x10002)); //"Err_22! Expected ba4.Get(0x10002) to be false"
Assert.False(ba4.Get(0x10004)); //"Err_23! Expected ba4.Get(0x10004) to be false"
break;
case Operator.And:
ba4 = ba2.And(ba3);
Assert.False(ba4.Get(0x10000)); //"Err_24! Expected ba4.Get(0x10000) to be false"
Assert.True(ba4.Get(0x10001)); //"Err_25! Expected ba4.Get(0x10001) to be true"
Assert.False(ba4.Get(0x10002)); //"Err_26! Expected ba4.Get(0x10002) to be false"
Assert.False(ba4.Get(0x10004)); //"Err_27! Expected ba4.Get(0x10004) to be false"
break;
case Operator.Or:
ba4 = ba2.Or(ba3);
Assert.True(ba4.Get(0x10000)); //"Err_28! Expected ba4.Get(0x10000) to be true"
Assert.True(ba4.Get(0x10001)); //"Err_29! Expected ba4.Get(0x10001) to be true"
Assert.False(ba4.Get(0x10002)); //"Err_30! Expected ba4.Get(0x10002) to be false"
Assert.False(ba4.Get(0x10004)); //"Err_31! Expected ba4.Get(0x10004) to be false"
break;
}
}
string RenameASCII(string originalName)
{
BitArray arr = new BitArray(md5.ComputeHash(Encoding.UTF8.GetBytes(originalName)));
Random rand = new Random(originalName.GetHashCode() * seed);
byte[] xorB = new byte[arr.Length / 8];
rand.NextBytes(xorB);
BitArray xor = new BitArray(xorB);
BitArray result = arr.Xor(xor);
byte[] ret = new byte[result.Length / 8];
result.CopyTo(ret, 0);
return Convert.ToBase64String(ret);
}
public static void BitArray_XorTest_Negative()
{
// [] ArgumentException, length of arrays is different
BitArray ba2 = new BitArray(11, false);
BitArray ba3 = new BitArray(6, false);
Assert.Throws<ArgumentException>(delegate { ba2.Xor(ba3); }); //"Err_37! wrong exception thrown."
// [] ArgumentNullException, null.
ba2 = new BitArray(6, false);
ba3 = null;
Assert.Throws<ArgumentNullException>(delegate { ba2.Xor(ba3); }); //"Err_38! wrong exception thrown."
}
string RenameUnreadable(string originalName)
{
BitArray arr = new BitArray(md5.ComputeHash(Encoding.UTF8.GetBytes(originalName)));
Random rand = new Random(originalName.GetHashCode() * seed);
byte[] xorB = new byte[arr.Length / 8];
rand.NextBytes(xorB);
BitArray xor = new BitArray(xorB);
BitArray result = arr.Xor(xor);
byte[] buff = new byte[result.Length / 8];
result.CopyTo(buff, 0);
StringBuilder ret = new StringBuilder();
int m = 0;
for (int i = 0; i < buff.Length; i++)
{
m = (m << 8) + buff[i];
while (m > 32)
{
ret.Append((char)(m % 32 + 1));
m /= 32;
}
}
return ret.ToString();
}
// Pour "mélanger" les bytes des fichiers
public BitArray crypteS(BitArray b)
{
BitArray cle_bit = new BitArray(key);
//byte[] Kcle = cle(b, key);
BitArray r = new BitArray(b.Length);
for (int i = 0; i < b.Length; i++)
{
r = cle_bit.Xor(b);
}
return r;
}
/// <summary>
/// Calculates f(<paramref name="a"/>), which is an affine transform (e.g. it's a matrix
/// multiply followed by a vector add).
/// </summary>
/// <param name="a">The byte to apply the transform to.</param>
/// <returns>The result of F(<paramref name="a"/)</returns>
private static byte CalculateF(byte a)
{
// Visually, b = f(a) is
//
// | b7 | | 1 1 1 1 1 0 0 0 | | a7 | | 0 |
// | b6 | | 0 1 1 1 1 1 0 0 | | a6 | | 1 |
// | b5 | | 0 0 1 1 1 1 1 0 | | a5 | | 1 |
// | b4 | * | 0 0 0 1 1 1 1 1 | * | a4 | + | 0 |
// | b3 | | 1 0 0 0 1 1 1 1 | | a3 | | 0 |
// | b2 | | 1 1 0 0 0 1 1 1 | | a2 | | 0 |
// | b1 | | 1 1 1 0 0 0 1 1 | | a1 | | 1 |
// | b0 | | 1 1 1 1 0 0 0 1 | | a0 | | 1 |
// Define the top row of the matrix
int[] shouldMultiplyBits = {1, 1, 1, 1, 1, 0, 0, 0};
// Create a function that converts the 1's and 0's to bits
Func<int[], BitArray> toBitArray = vector => new BitArray(vector.Select(b => b != 0).ToArray());
BitArray shouldMultiply = toBitArray(shouldMultiplyBits);
// Convert a to bits
BitArray aVector = new BitArray(new[] {a});
BitArray multiplyResult = new BitArray(8);
// Perform the multiply
for (int offset = 0; offset < 8; offset++)
{
for (int bit = 0; bit < 8; bit++)
{
bool currentMultiplyBitValue = shouldMultiplyBits[(8 + ((8 - offset) + bit))%8] != 0;
bool currentBitMultiplyResult = currentMultiplyBitValue && aVector[7 - bit];
if (currentBitMultiplyResult)
{
multiplyResult[offset] = !multiplyResult[offset];
}
}
}
// Perform the vector add, which is a simply xor
int[] affineVectorBits = {0, 1, 1, 0, 0, 0, 1, 1};
BitArray affineVector = toBitArray(affineVectorBits);
BitArray resultVector = multiplyResult.Xor(affineVector);
// We have the bits, now convert them back to a byte, we do this
// by OR-ing each bit to the value its position represents (if it is a 1).
byte result = 0;
byte multiplier = 0x80;
for (int i = 0; i < 8; i++)
{
if (resultVector[i])
{
result |= multiplier;
}
multiplier >>= 1;
}
return result;
}
public void xorWithKey(int iterationIndex)
{
BitArray resultArray = new BitArray(rightSide[iterationIndex]);
resultArray = resultArray.Xor(keys[iterationIndex]);
rightSide[iterationIndex] = resultArray;
}
