public static void Encrypt()
{
Console.Clear();
ConsoleOutput.PutInitText();
Console.WriteLine("Zadanie 2 - Synchronous Stream Cipher - Szyfrowanie");
Console.WriteLine();
string dictWord;
string seed;
string input, output;
Console.Write("Podaj wielomian np. 1001: ");
dictWord = Console.ReadLine();
Console.Write("Podaj seed np. 1010: ");
seed = Console.ReadLine();
Console.Write("Podaj input file: ");
input = Console.ReadLine();
Console.Write("Podaj output file: ");
output = Console.ReadLine();
LFSR o = new LFSR(dictWord, seed);
//input = "C:/biomet/output.bin";
//input = "C:/biomet/Lenna1.png";
//output = "C:/biomet/fromBin.png";
LFSR_2_File zad2 = new LFSR_2_File(o, input, output);
zad2.DoWork();
}
private static void Encrypt()
{
Console.WriteLine("Enter the key");
string keyLine = Console.ReadLine();
int[] factors = keyLine.Split(' ').Select(e => int.Parse(e)).ToArray();
int key = getKey(factors);
Console.WriteLine("Enter the file name:");
string fileName = Console.ReadLine();
Console.WriteLine("Enter the new file name:");
string newFileName = Console.ReadLine();
using var oldStream = new FileStream(fileName, FileMode.Open, FileAccess.Read);
var lfsr = new LFSR(key);
using var crStream = new CryptoStream(oldStream, lfsr, CryptoStreamMode.Read);
using var newStream = new FileStream(newFileName, FileMode.OpenOrCreate, FileAccess.Write);
crStream.CopyTo(newStream);
}
private void btnFixValues_Click(object sender, EventArgs e)
{
if (btnFixField.Enabled)
{
MessageBox.Show("First fix the field!", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
string poly = "1" + string.Join("", txtFeedback.Text.Reverse());
Polynomial feedback = Polynomial.Parse(F, txtFeedback.Text, false);
lblFeedback.Text = "Feedback Polynomial: " + Polynomial.Parse(F, poly, false).ToString();
Polynomial initial = Polynomial.Parse(F, txtInitial.Text.Trim(), false);
lblInitial.Text = "Initial State: " + initial.ToString();
lfsr = new LFSR(feedback, initial.Coefficients);
txtOutput.Text = ""; // txtInitial.Text.Trim();
lblSeqSize.Text = "Ready";
btnGenSeq.Enabled = true;
btnFindPeriod.Enabled = true;
btnFixValues.Enabled = false;
}
public void cifrar() // hace operacion xor con el vector cifrante y el mensaje
{
for (int i = 0; i < S.Length; i++)
{
cifrado[i] = LFSR.make_xor(S[i], mensaje[i]);
}
}
public void descifrar()
{
for (int i = 0; i < cifrado.Length; i++)
{
descifrado[i] = LFSR.make_xor(S[i], cifrado[i]);
}
}
public void LFSR_Logic_Initialization()
{
LFSR lfsr = new LFSR();
lfsr.Init("1011", "1101");
Assert.AreEqual("1011", lfsr.Seed);
Assert.AreEqual("1101", lfsr.Polynomial);
}
public void LFSR_Shift_Works()
{
LFSR lfsr = new LFSR();
lfsr.Init("1011", "11001");
Assert.AreEqual(2, lfsr.Shift(4));
}
public void LFSR_Logic_XOR_Returns_1()
{
LFSR lfsr = new LFSR();
lfsr.Init("1011", "11001");
Assert.AreEqual(1, lfsr.XORBits(5));
Assert.AreEqual(1, lfsr.XORBits(10));
}
public void LSFR_Logic_Bit_Replacing_Works()
{
LFSR lfsr = new LFSR();
lfsr.Init("1011", "11001");
Assert.AreEqual(15, lfsr.ReplaceFirstBit(7, 1));
Assert.AreEqual(0, lfsr.ReplaceFirstBit(8, 0));
Assert.AreEqual(3, lfsr.ReplaceFirstBit(11, 0));
}
public void LFSR_Logic_XOR_Returns_0()
{
LFSR lfsr = new LFSR();
lfsr.Init("1011", "11001");
Assert.AreEqual(0, lfsr.XORBits(11));
Assert.AreEqual(0, lfsr.XORBits(13));
Assert.AreEqual(0, lfsr.XORBits(29));
}
public BitArray cifrar()
{
cifrarrr = new BitArray(message.Length);
for (int i = 0; i < cifrarrr.Length; i++)
{
cifrarrr[i] = LFSR.make_xor(message[i], S[i]);
}
return(cifrarrr);
}
public BitArray descifrar()
{
BitArray descifrar = new BitArray(message.Length);
for (int i = 0; i < descifrar.Length; i++)
{
descifrar[i] = LFSR.make_xor(cifrarrr[i], S[i]);
}
return(descifrar);
}
static public BitArray sumita_no_mas(BitArray A, BitArray B)
{
BitArray aux = new BitArray(A.Length);
for (int i = 0; i < A.Length; i++)
{
aux[i] = LFSR.make_xor(A[i], B[i]);
}
return(aux);
}
public void LFSR_Logic_Engine_Works()
{
LFSR lfsr = new LFSR();
lfsr.Init("1011", "11001");
string result = lfsr.GetOutput("", -1);
Assert.AreEqual("0110", result);
lfsr.Init("11101", "110111");
result = lfsr.GetOutput("", -1);
Assert.AreEqual("11010", result);
}
public static void Encrypt()
{
Console.Clear();
ConsoleOutput.PutInitText();
Console.WriteLine("Zadanie 1 - LFSR - Szyfrowanie");
Console.WriteLine();
string dictWord;
string seed;
int n;
Console.Write("Podaj wielomian: ");
dictWord = Console.ReadLine();
Console.Write("Podaj seed: ");
seed = Console.ReadLine();
Console.Write("Podaj ilosc n bitow do przesuniecia: ");
n = Int32.Parse(Console.ReadLine());
LFSR lfsr = new LFSR(dictWord, seed);
for (int i = 0; i < n; i++)
{
Console.WriteLine(lfsr.getLFSR_Value());
}
Console.ReadKey();
//var file = BinaryFile.Read("test.bin");
//Console.Write("Podaj ciag w formie bitowej: ");
//var seed = Console.ReadLine();
//Console.Write("Podaj stopień wielomianu (w formie bitowej, np x^6 + x^4 + 1 = 1010001): ");
//var wielomian = Console.ReadLine();
//var lfsr = new LFSR(seed, wielomian, 8);
//Console.WriteLine("Generate");
//for (var i = 0; i < 10; i++)
//{
// var r = lfsr.Generate(5);
// Console.WriteLine(lfsr + " " + r);
//}
//Console.ReadKey();
}
private void Button_Click(object sender, RoutedEventArgs e)
{
string _seed = seed.Text;
string _polynominal = polynominal.Text;
LFSR lfsr = new LFSR(_seed, _polynominal);
string text = "";
int tmp = int.Parse(inputfile.Text);
for (int i = 0; i < tmp; i++)
{
text += lfsr.wyswietlLFSR();
lfsr.GetNext();
}
File.WriteAllText(outputfile.Text, text);
}
public E0(BitArray msg, BitArray sd)
{
message = msg;
seed = sd;
S = new BitArray(msg.Length);
lfsr = new LFSR[5];
lfsr[0] = new LFSR(25);
lfsr[1] = new LFSR(31);
lfsr[2] = new LFSR(33);
lfsr[3] = new LFSR(39);
lfsr[4] = new LFSR(39);
int[] polinomios = new int [] { 24, 14, 9, 4 };
lfsr[4].set_polinomio(polinomios);
lfsr[4].set_bitss("111111111111111111111111111111111111111");
set_lfsr();
}
public A5(BitArray sem, BitArray mens) // constructor
{
mensaje = mens; // guardamos el mensaje
S = new BitArray(mensaje.Length); // definimos el vector cifrante , segun la longitud del mensaje
cifrado = new BitArray(mensaje.Length); // lo mismo hacemos con el cifrado
descifrado = new BitArray(mensaje.Length);
// S = new BitArray ();
mi_lfsr = new LFSR [3]; // convertimos el array de LFSR de 3, segun A5/1
mi_lfsr[0] = new LFSR(19); // creamos cada LFSR segun el size que le corresponde
mi_lfsr[1] = new LFSR(22);
mi_lfsr[2] = new LFSR(23);
semilla = sem; // guardamos la semilla
set_lfsr(); // llamamos a llenar los LFSR con la semilla dada
}
private void startGen_Click(object sender, RoutedEventArgs e)
{
int[] table = parseSyncKey(keyTextBox.Text);
if (validateSyncKey(table))
{
lsfrGen = new LFSR();
stopGen.IsEnabled = true;
startGen.IsEnabled = false;
syncKeyGenerated = false;
encrypt.IsEnabled = false;
decrypt.IsEnabled = false;
genStatusLabel.Content = "Your key is being generated.";
lsfrGen.StartGenerator(table);
}
else
{
//MessageBox.Show("SYNC key is invalid.");
}
}
void GetTab2Ready()
{
// Finite Field
F3 = new FiniteField(3);
// LFSR 1 - 3
string strf1 = "201", stri1 = "001";
Polynomial feedback1 = Polynomial.Parse(F3, strf1, false);
Polynomial initial1 = Polynomial.Parse(F3, stri1, false);
L1 = new LFSR(feedback1, initial1.Coefficients);
Tab2lblLFSR1.Text += "\r\n" + "Feedback: " + Polynomial.Parse(F3, "1" + strf1, false).ToString() + "\r\nInitial: " + stri1 + "\r\nPeriod = " + L1.Period;
// LFSR 2 - 4
string strf2 = "2001", stri2 = "0001";
Polynomial feedback2 = Polynomial.Parse(F3, strf2, false);
Polynomial initial2 = Polynomial.Parse(F3, stri2, false);
L2 = new LFSR(feedback2, initial2.Coefficients);
Tab2lblLFSR2.Text += "\r\n" + "Feedback: " + Polynomial.Parse(F3, "2" + strf2, false).ToString() + "\r\nInitial: " + stri2 + "\r\nPeriod = " + L2.Period;
// LFSR 3 - 5
string strf3 = "20001", stri3 = "00001";
Polynomial feedback3 = Polynomial.Parse(F3, strf3, false);
Polynomial initial3 = Polynomial.Parse(F3, stri3, false);
L3 = new LFSR(feedback3, initial3.Coefficients);
Tab2lblLFSR3.Text += "\r\n" + "Feedback: " + Polynomial.Parse(F3, "1" + strf3, false).ToString() + "\r\nInitial: " + stri3 + "\r\nPeriod = " + L3.Period;
// LFSR 4 - 7
string strf4 = "0000201", stri4 = "1012220";
Polynomial feedback4 = Polynomial.Parse(F3, strf4, false);
Polynomial initial4 = Polynomial.Parse(F3, stri4, false);
L4 = new LFSR(feedback4, initial4.Coefficients);
Tab2lblLFSR4.Text += "\r\n" + "Feedback: " + Polynomial.Parse(F3, "1" + strf4, false).ToString() + "\r\nInitial: " + stri4 + "\r\nPeriod = 26 (precomputed)";// +L4.Period;
// Nonlinear Combiner
NonlinCombOutput = "";
Tab2lblNonLinComb.Text += "\r\n(X1+X3) * (X2+X4)";
}
public void crear_cadena_cifrante() // realizamos todas las operaciones xor y push'es
{
bool a = false, b = false, c = false; // variables donde guardaremos el valor del bit de entrada de cada vector
bool result_a = false, result_b = false, result_c = false; // variables donde guardamos las operaciones xor
bool valor = false; // valor que pondremos dentro de S
int index_S = 0; // indice de S
// poner condicion al bucle
do // bucle
{
a = mi_lfsr[0].get_bit_entrada(); // obtenemos el valor de los bits que definen la entrada{8,10,10}
b = mi_lfsr[1].get_bit_entrada();
c = mi_lfsr[2].get_bit_entrada();
if (a == b && b == c) // en caso de que todos coincidadn
{
result_a = mi_lfsr[0].get_valor(); // obtenemos el valor de la operacion xor segun el polinomio
result_b = mi_lfsr[1].get_valor(); // de cada LFSR
result_c = mi_lfsr[2].get_valor();
result_a = mi_lfsr[0].push_valor(result_a); // el valor resultante lo pusheamos y obtendremos el bit sobrante
result_b = mi_lfsr[1].push_valor(result_b);
result_c = mi_lfsr[2].push_valor(result_c);
valor = LFSR.make_xor(result_a, result_b); // con el bit sobrante hacemos 2 xor,
valor = LFSR.make_xor(valor, result_c);
S[index_S] = valor; // con el resultado, lo metemos dentro del vector cifrante
}
// basicamente repetir lo anterior pero con 2 coincidencias en vez de 3
else
{
if (a == b)
{
result_a = mi_lfsr[0].get_valor();
result_b = mi_lfsr[1].get_valor();
result_a = mi_lfsr[0].push_valor(result_a);
result_b = mi_lfsr[1].push_valor(result_b);
valor = LFSR.make_xor(result_a, result_b);
valor = LFSR.make_xor(valor, mi_lfsr[2].get_last());
S[index_S] = valor;
}
if (a == c)
{
result_a = mi_lfsr[0].get_valor();
result_c = mi_lfsr[2].get_valor();
result_a = mi_lfsr[0].push_valor(valor);
result_c = mi_lfsr[2].push_valor(valor);
valor = LFSR.make_xor(result_a, result_c);
valor = LFSR.make_xor(valor, mi_lfsr[1].get_last());
S[index_S] = valor;
}
if (b == c)
{
result_c = mi_lfsr[2].get_valor();
result_b = mi_lfsr[1].get_valor();
result_b = mi_lfsr[1].push_valor(valor);
result_c = mi_lfsr[2].push_valor(valor);
valor = LFSR.make_xor(result_a, result_b);
valor = LFSR.make_xor(valor, mi_lfsr[0].get_last());
S[index_S] = valor;
}
}
index_S++;
}while(index_S < S.Length);
// una vez acabado de crear la cadena cifrante, mostramos la misma en bits
Console.WriteLine("La cadena cifrante generada es : ");
for (int i = 0; i < S.Length; i++)
{
if (S[i] == true)
{
Console.Write(" 1");
}
else
{
Console.Write(" 0");
}
}
}
public void crear_cadena_cifrante()
{
bool result_a = false, result_b = false, result_c = false, result_d = false, result_e = false; // bits resultantes de operaciones
bool[] inic = new bool [2] {
false, true
}; // bits de inicio de R1
int index_S = 0, contador = 0, r1, resultado = 0; //indice de la cadena cifrante,resultado de suma(decimal) de LFSR,r1 en decimal,resultado de la suma contador+r1
int[] sum = new int [1];
bool end;
BitArray suma = new BitArray(2, false);
BitArray R1 = new BitArray(inic);
BitArray R2 = new BitArray(2);
BitArray T2 = new BitArray(2);
BitArray T1;
R1 = swap_bit(R1);
do
{
// R1 inicializado a '01'
// obtenemos los bits de los LFSR
result_a = lfsr[0].get_valor();
result_b = lfsr[1].get_valor();
result_c = lfsr[2].get_valor();
result_d = lfsr[3].get_valor();
result_e = lfsr[4].get_valor();
result_a = lfsr[0].push_valor(result_a);
result_b = lfsr[1].push_valor(result_b);
result_c = lfsr[2].push_valor(result_c);
result_d = lfsr[3].push_valor(result_d);
result_e = lfsr[4].push_valor(result_e);
Console.WriteLine("Bit numero" + (index_S + 1));
Console.WriteLine("R1:");
show_chipher(R1);
end = LFSR.make_xor(result_a, result_b);
end = LFSR.make_xor(end, result_c);
end = LFSR.make_xor(end, result_d);
end = LFSR.make_xor(end, R1[1]);
end = LFSR.make_xor(end, result_e);
//Console.WriteLine(result_a);
//Console.WriteLine(result_b);
//Console.WriteLine(result_c);
//Console.WriteLine(result_d);
//Console.WriteLine(R1[1]);
// hacemos la suma decimal de los bits
contador = contad(result_a, result_b, result_c, result_d);
// obtenemos el valor decimal de R1 e inicializamos T1
T1 = R1;
Console.WriteLine("T1:");
show_chipher(T1);
r1 = get_int(R1);
S[index_S] = end;
// le damos la vuela a R1 y lo guardamos en R2
R2 = swap_bit(R1);
Console.WriteLine("R2:");
show_chipher(R2);
// inicializamos T en base del valor de R2
T2[0] = R2[1];
T2[1] = LFSR.make_xor(R2[0], R2[1]);
Console.WriteLine("T2:");
show_chipher(T2);
// inicializado R1 y R2, hacemos la suma con R1 y la divicion
resultado = contador + r1;
Console.WriteLine("Suma 1:" + contador);
Console.WriteLine("Suma 2: " + resultado);
resultado /= 2;
// convertimos el resultado en bits
suma = int_to_bool(resultado);
Console.WriteLine("Div:");
show_chipher(suma);
suma = sumita_no_mas(suma, T2);
Console.WriteLine("Suma T2: ");
show_chipher(suma);
suma = sumita_no_mas(suma, T1);
Console.WriteLine("Suma T1: ");
show_chipher(suma);
R1 = swap_bit(suma);
Console.WriteLine("");
Console.WriteLine("");
index_S++;
}while(index_S < S.Length);
}
