private void createRegistersBtn_Click(object sender, RoutedEventArgs e)
{
if (string.IsNullOrEmpty(numOfLfsrTxtBox.Text))
{
return;
}
int numOfRegisters = int.Parse(numOfLfsrTxtBox.Text);
Lfsr_list.Children.Clear();
registersLabel = new Label[numOfRegisters];
for (int i = 0; i < numOfRegisters; i++)
{
RegisterUserControl register = new RegisterUserControl();
register.RegisterNumberLabel.Content = "Rejestr " + (i + 1);
if (i % 2 == 0)
{
register.MainGrid.Background = Brushes.LightYellow;
}
Lfsr_list.Children.Add(register);
registersLabel[i] = register.rState;
}
Lfsr[] registers = new Lfsr[numOfRegisters];
for (int i = 0; i < registers.Length; i++)
{
registers[i] = new Lfsr(registersLabel[i].Content as string);
}
generator = new CascadeGenerator(registers);
}
public void testLfsr()
{
Lfsr lfsr = new Lfsr();
int previousValue = 0;
for (int i = 0; i < 100; i++)
{
lfsr.NextBit(false);
Assert.AreNotEqual(previousValue, lfsr.Value);
previousValue = lfsr.Value;
}
}
public IActionResult SelfShrinkingGenerate([FromBody] LfsrGeneratorsViewModel viewModel)
{
var numOfRegisters = viewModel.Registers.Length;
Lfsr[] registers = new Lfsr[numOfRegisters];
for (int i = 0; i < numOfRegisters; i++)
{
registers[i] = new Lfsr(viewModel.Registers[i]);
registers[i].SetFeedbackFunction(viewModel.FeedbackFunctions[i]);
}
SelfShrinkingGenerator generator = new SelfShrinkingGenerator(registers);
SeriesMode mode = (SeriesMode)viewModel.Mode;
try
{
switch (mode)
{
case SeriesMode.Binary:
{
var data = generator.GenerateBitsAsChars(viewModel.Length);
var r = LfsrHelper.GetRegisterAsStringArray(generator.Registers);
return(Json(new { data = new string(data), registers = r }));
}
case SeriesMode.Hex:
{
var data = generator.GenerateBytes(viewModel.Length);
var r = LfsrHelper.GetRegisterAsStringArray(generator.Registers);
return(Json(new { data = BitConverter.ToString(data), registers = r }));
}
case SeriesMode.Base64:
{
var data = generator.GenerateBytes(viewModel.Length);
var r = LfsrHelper.GetRegisterAsStringArray(generator.Registers);
return(Json(new { data = data, registers = r }));
}
}
}
catch (Exception e)
{
return(BadRequest(new { Result = false, Message = e.Message }));
}
return(Json(""));
}
public IActionResult SelfDecimationGenerate([FromBody] LfsrGeneratorsViewModel viewModel)
{
var numOfRegisters = viewModel.Registers.Length;
Lfsr[] registers = new Lfsr[numOfRegisters];
for (int i = 0; i < numOfRegisters; i++)
{
registers[i] = new Lfsr(viewModel.Registers[i]);
registers[i].SetFeedbackFunction(viewModel.FeedbackFunctions[i]);
}
SelfDecimationGenerator generator = new SelfDecimationGenerator(registers);
generator.K_value = (int)viewModel.K_value;
generator.D_value = (int)viewModel.D_value;
SeriesMode mode = (SeriesMode)viewModel.Mode;
switch (mode)
{
case SeriesMode.Binary:
{
var data = generator.GenerateBitsAsChars(viewModel.Length);
var r = LfsrHelper.GetRegisterAsStringArray(generator.Registers);
return(Json(new { data = new string(data), registers = r }));
}
case SeriesMode.Hex:
{
var data = generator.GenerateBytes(viewModel.Length);
var r = LfsrHelper.GetRegisterAsStringArray(generator.Registers);
return(Json(new { data = BitConverter.ToString(data), registers = r }));
}
case SeriesMode.Base64:
{
var data = generator.GenerateBytes(viewModel.Length);
var r = LfsrHelper.GetRegisterAsStringArray(generator.Registers);
return(Json(new { data = data, registers = r }));
}
}
return(Json(""));
}
private void SetFeedbackFunctions()
{
functionsDicts = Lfsr.GenerateFeedbackFunctions();
;
foreach (var item in functionsDicts)
{
int[] tapsArray = new int[item.Value.Length];
for (int i = 0; i < tapsArray.Length; i++)
{
tapsArray[i] = item.Value[i] + 1;
}
var polynomial = new PolynomialModel()
{
Length = item.Key,
Polynomial = string.Join(",", tapsArray)
};
_feedbackFunctions.Add(polynomial);
}
}
//WaveFileWriter m_wr;
//////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////
public NoiseWaveProvider32(SoundManager.eSoundChannel channel, ushort nrx0Adr, ushort nrx1Adr, ushort nrx2Adr, ushort nrx3Adr, ushort nrx4Adr, bool bUseSweepShift, string fileName)
{
m_channel = channel;
m_nrx0Adr = nrx0Adr;
m_nrx1Adr = nrx1Adr;
m_nrx2Adr = nrx2Adr;
m_nrx3Adr = nrx3Adr;
m_nrx4Adr = nrx4Adr;
m_frequency = 400.0f;
int l = 8820 * 4; // 8820 = 100ms
m_buffer = new float[l];
for (int i = 0; i < m_buffer.Length; i++)
{
m_buffer[i] = 0;
}
//WaveFormat wf = new WaveFormat(44100, 16, 2);
//m_wr = new WaveFileWriter(fileName, wf);
m_bufferReadingPos = m_buffer.Length / 2;
m_bufferWritingPos = 0;
m_Lfsr = new Lfsr(15);
}
private void Button_Click(object sender, RoutedEventArgs e)
{
uint parsedValue;
if ((series_length.Text).ToString().Length == 0)
{
MessageBox.Show("Podaj długość ciągu do wygenerowania.");
return;
}
else if (!uint.TryParse(series_length.Text, out parsedValue))
{
MessageBox.Show("Długość ciągu do wygenerowania musi być dodatnią liczbą całkowitą.");
return;
}
uint parsed;
if (!uint.TryParse(lfsr1.Text, out parsed))
{
MessageBox.Show("Wartości początkowe rejestrów muszą być dodatnią liczbą całkowitą.");
return;
}
else if ((lfsr1.Text).ToString().Length == 0)
{
MessageBox.Show("Uzupełnij pola z wartościami początkowymi rejestrów.");
return;
}
var registersLength = Convert.ToInt32(RegisterLength_ComboBox.SelectedItem);
int numOfLfsr = 1;
Lfsr[] lfsr = new Lfsr[numOfLfsr];
var boolArray = Convert.ToString(parsed, 2).Select(str => str.Equals('1')).Take(registersLength).ToArray();
var bitArray = new BitArray(registersLength);
for (int j = 0; j < boolArray.Length; j++)
{
bitArray[j] = boolArray[j];
}
lfsr[0] = new Lfsr(registersLength);
TextBox tb = (TextBox)this.FindName("lfsr1");
lfsr[0].SetRegisterValues(bitArray);
wynik.Clear();
LfsrGenerator generator = new SelfDecimationGenerator(lfsr);
if (typ.SelectedIndex == 0)
{
var gen = generator.GenerateBitsAsChars(Convert.ToInt32(series_length.Text));
wynik.Text = new string(gen);
}
else if (typ.SelectedIndex == 1)
{
var gen1 = generator.GenerateBytes(Convert.ToInt32(series_length.Text));
wynik.Text = BitConverter.ToString(gen1);
}
else if (typ.SelectedIndex == 2)
{
var gen1 = generator.GenerateIntegers(Convert.ToInt32(series_length.Text));
wynik.Text = String.Join(" ", gen1.Select(p => p.ToString()).ToArray());
}
}
private void GenerateBtn_Click(object sender, RoutedEventArgs e)
{
string r1 = r1State.Content as string;
string r2 = r2State.Content as string;
string r3 = r3State.Content as string;
Lfsr[] lfsrs = new Lfsr[3];
lfsrs[0] = new Lfsr(r1);
lfsrs[1] = new Lfsr(r2);
lfsrs[2] = new Lfsr(r3);
//setting custom feedback function
ChangeLfsrFeedbackFunctions(lfsrs);
for (int i = 0; i < lfsrs.Length; i++)
{
generator.ChangeRegister(lfsrs[i], i);
}
var format = outputFormatComboBox.SelectedIndex;
int seriesLength = 0;
if (outputLength.Text != "")
{
seriesLength = int.Parse(outputLength.Text);
}
ClearOutput();
Task.Run(() =>
{
SetLoadingCircle(true);
disableButtons();
ResetFipsIcons();
byte[] generatedBytes = null;
switch (format)
{
case 0:
{
lastGeneratedFormat = format;
lastGeneratedString = new string(generator.GenerateBitsAsChars(seriesLength));
SetOutputText(lastGeneratedString);
SetLoadingCircle(false);
break;
}
case 1:
{
generatedBytes = generator.GenerateBytes(seriesLength);
lastGeneratedFormat = format;
lastGeneratedString = Convert.ToBase64String(generatedBytes);
SetOutputText(lastGeneratedString);
SetLoadingCircle(false);
break;
}
default:
break;
}
UpdateRegisterState(generator);
enableButtons();
if (seriesLength >= 20000)
{
SingleBitTestResult singleBitResult = null;
SeriesTestResult seriesResult = null;
LongSeriesTestResult longSeriesResult = null;
PokerTestResult pokerResult = null;
if (format == 0)
{
FipsTests fipsTests = new FipsTests();
var testInput = lastGeneratedString.Substring(0, 20000);
singleBitResult = fipsTests.SingleBitTest(testInput);
seriesResult = fipsTests.SeriesTest(testInput);
longSeriesResult = fipsTests.LongSeriesTests(testInput);
pokerResult = fipsTests.PokerTest(testInput);
}
else if (format == 1)
{
FipsTests fipsTests = new FipsTests();
byte[] testArray = new byte[2500];
Array.Copy(generatedBytes, testArray, 2500);
if (generatedBytes != null)
{
singleBitResult = fipsTests.SingleBitTest(testArray);
seriesResult = fipsTests.SeriesTest(testArray);
longSeriesResult = fipsTests.LongSeriesTests(testArray);
pokerResult = fipsTests.PokerTest(testArray);
}
}
if (singleBitResult.TestPassed)
{
singleBitSuccess();
}
else
{
singleBitFail();
}
if (seriesResult.TestPassed)
{
seriesSuccess();
}
else
{
seriesFail();
}
if (longSeriesResult.TestPassed)
{
longSeriesSuccess();
}
else
{
longSeriesFail();
}
if (pokerResult.TestPassed)
{
pokerSuccess();
}
else
{
pokerFail();
}
}
});
}
private void Button_Click(object sender, RoutedEventArgs e)
{
int parsedValue;
if (!int.TryParse(series_length.Text, out parsedValue))
{
MessageBox.Show("Długość ciągu do wygenerowania musi być liczbą całkowitą.");
return;
}
else if ((series_length.Text).ToString().Length == 0)
{
MessageBox.Show("Podaj długość ciągu do wygenerowania.");
return;
}
else if (Convert.ToInt32(series_length.Text) < 1)
{
MessageBox.Show("Długość ciągu do wygenerowania musi być większa od zera.");
return;
}
byte parsed;
if (!byte.TryParse(lfsr1.Text, out parsed))
{
MessageBox.Show("Musisz podać wartość początkową rejestru z zakresu (0-255).");
return;
}
else if ((lfsr1.Text).ToString().Length == 0)
{
MessageBox.Show("Uzupełnij pole z wartością początkowom rejestru.");
return;
}
int numOfLfsr = 1;
Lfsr[] lfsr = new Lfsr[numOfLfsr];
for (int i = 0; i < numOfLfsr; i++)
{
lfsr[i] = new Lfsr();
TextBox tb = (TextBox)this.FindName("lfsr" + (i + 1).ToString());
lfsr[i].SetRegisterValues(new BitArray(new byte[] { Convert.ToByte(tb.Text) }));
}
Stopwatch sw = new Stopwatch();
wynik.Clear();
LfsrGenerator generator = new SelfDecimationGenerator(lfsr);
if (typ.SelectedIndex == 0)
{
sw.Start();
var gen = generator.GenerateBitsAsChars(Convert.ToInt32(series_length.Text));
sw.Stop();
foreach (var item in gen)
{
wynik.Text = wynik.Text + item;
}
sw.Reset();
}
else if (typ.SelectedIndex == 1)
{
sw.Start();
var gen1 = generator.GenerateBytes(Convert.ToInt32(series_length.Text));
sw.Stop();
foreach (var item in gen1)
{
wynik.Text = wynik.Text + item;
}
sw.Reset();
}
else if (typ.SelectedIndex == 2)
{
sw.Start();
var gen1 = generator.GenerateIntegers(Convert.ToInt32(series_length.Text));
sw.Stop();
foreach (var item in gen1)
{
wynik.Text = wynik.Text + item;
}
sw.Reset();
}
}
public Generators(Lfsr lfsr1, Lfsr lfsr2, Lfsr lfsr3)
{
this.lfsr1 = lfsr1;
this.lfsr2 = lfsr2;
this.lfsr3 = lfsr3;
}
private void Button_Click(object sender, RoutedEventArgs e)
{
uint parsedValue;
if ((series_length.Text).ToString().Length == 0)
{
MessageBox.Show("Podaj długość ciągu do wygenerowania.");
return;
}
else if (!uint.TryParse(series_length.Text, out parsedValue))
{
MessageBox.Show("Długość ciągu do wygenerowania musi być dodatnią liczbą całkowitą.");
return;
}
int numOfLfsr = Convert.ToInt32(lfsr_amount.Text);
Lfsr[] lfsr = new Lfsr[numOfLfsr];
uint[] parsed = new uint[numOfLfsr];
var registersLength = Convert.ToInt32(RegisterLength_ComboBox.SelectedItem);
for (int i = 0; i < numOfLfsr; i++)
{
string s = ((TextBox)Lfsr_list.Children[((i + 1) * 2) - 1]).Text;
if (s.Length == 0)
{
MessageBox.Show("Uzupełnij pola z wartościami początkowymi rejestrów.");
return;
}
else if (!uint.TryParse(s, out parsed[i]))
{
MessageBox.Show("Wartości początkowe rejestrów muszą być dodatnią liczbą całkowitą.");
return;
}
lfsr[i] = new Lfsr(registersLength);
var boolArray = Convert.ToString(parsed[i], 2).Select(str => str.Equals('1')).Take(registersLength).ToArray();
var bitArray = new BitArray(registersLength);
for (int j = 0; j < boolArray.Length; j++)
{
bitArray[j] = boolArray[j];
}
lfsr[i].SetRegisterValues(bitArray);
}
wynik.Clear();
LfsrGenerator generator = new ThresholdGenerator(lfsr);
if (typ.SelectedIndex == 0)
{
var gen = generator.GenerateBitsAsChars(Convert.ToInt32(series_length.Text));
wynik.Text = new string(gen);
}
else if (typ.SelectedIndex == 1)
{
var gen1 = generator.GenerateBytes(Convert.ToInt32(series_length.Text));
wynik.Text = BitConverter.ToString(gen1);
}
else if (typ.SelectedIndex == 2)
{
var gen1 = generator.GenerateIntegers(Convert.ToInt32(series_length.Text));
wynik.Text = String.Join(" ", gen1.Select(p => p.ToString()).ToArray());
}
}
private void Button_Click(object sender, RoutedEventArgs e)
{
int parsedValue;
byte parsed;
if (!int.TryParse(series_length.Text, out parsedValue))
{
MessageBox.Show("Długość ciągu do wygenerowania musi być liczbą całkowitą.");
return;
}
else if ((series_length.Text).ToString().Length == 0)
{
MessageBox.Show("Podaj długość ciągu do wygenerowania.");
return;
}
else if (Convert.ToInt32(series_length.Text) < 1)
{
MessageBox.Show("Długość ciągu do wygenerowania musi być większa od zera.");
return;
}
int numOfLfsr = Convert.ToInt32(lfsr_amount.Text);
Lfsr[] lfsr = new Lfsr[numOfLfsr];
for (int i = 0; i < numOfLfsr; i++)
{
lfsr[i] = new Lfsr();
string s = ((TextBox)Lfsr_list.Children[((i + 1) * 2) - 1]).Text;
if (s.Length == 0)
{
MessageBox.Show("Musisz podać wartości początkowe rejestrów.");
return;
}
else if (!byte.TryParse(s, out parsed))
{
MessageBox.Show("Musisz podać wartości początkowe rejestrów z zakresu (0-255).");
return;
}
lfsr[i].SetRegisterValues(new BitArray(new byte[] { Convert.ToByte(s) }));
}
Stopwatch sw = new Stopwatch();
wynik.Clear();
LfsrGenerator generator = new ThresholdGenerator(lfsr);
if (typ.SelectedIndex == 0)
{
sw.Start();
var gen = generator.GenerateBitsAsChars(Convert.ToInt32(series_length.Text));
sw.Stop();
foreach (var item in gen)
{
wynik.Text = wynik.Text + item;
}
sw.Reset();
}
else if (typ.SelectedIndex == 1)
{
sw.Start();
var gen1 = generator.GenerateBytes(Convert.ToInt32(series_length.Text));
sw.Stop();
foreach (var item in gen1)
{
wynik.Text = wynik.Text + item;
}
sw.Reset();
}
else if (typ.SelectedIndex == 2)
{
sw.Start();
var gen1 = generator.GenerateIntegers(Convert.ToInt32(series_length.Text));
sw.Stop();
foreach (var item in gen1)
{
wynik.Text = wynik.Text + item;
}
sw.Reset();
}
}
private void encryptBtn_Click(object sender, RoutedEventArgs e)
{
if (string.IsNullOrEmpty(inputEncrypt.Text))
{
return;
}
string input = inputEncrypt.Text;
var checkedRB = inputFormat.Children.OfType <RadioButton>().FirstOrDefault(r => r.IsChecked == true);
string format = checkedRB.DataContext as string;
byte[] encodedText = null;
bool changeRegisters = false;
if (ChangeRegistersCheckbox.IsChecked == true)
{
changeRegisters = true;
}
Lfsr[] lfsrs = new Lfsr[3] {
new Lfsr(19, true), new Lfsr(22, true), new Lfsr(23, true)
};
for (int i = 0; i < register19.Count; i++)
{
string txt = register19[i].Text;
char toAdd = '0';
if (txt.Length == 1)
{
toAdd = txt[0];
}
lfsrs[0].Register[i] = (toAdd == '1');
}
for (int i = 0; i < register22.Count; i++)
{
string txt = register22[i].Text;
char toAdd = '0';
if (txt.Length == 1)
{
toAdd = txt[0];
}
lfsrs[1].Register[i] = (toAdd == '1');
}
for (int i = 0; i < register23.Count; i++)
{
string txt = register23[i].Text;
char toAdd = '0';
if (txt.Length == 1)
{
toAdd = txt[0];
}
lfsrs[2].Register[i] = (toAdd == '1');
}
generator.ChangeRegister(lfsrs[0], 0);
generator.ChangeRegister(lfsrs[1], 1);
generator.ChangeRegister(lfsrs[2], 2);
Task.Run(() => {
DisableAllButtons();
ShowLoadingCircle();
switch (format)
{
case "ascii":
{
encodedText = Encoding.ASCII.GetBytes(input);
output = Encrypt(encodedText, changeRegisters);
break;
}
case "hex":
{
Regex regex = new Regex(hexPattern);
if (!regex.IsMatch(input))
{
Dispatcher.Invoke(() =>
{
HideLoadingCircle();
EnableAllButtons();
MessageBox.Show("Podano niepoprawny tekst dla formatu hex!");
});
return;
}
try
{
encodedText = Helpers.StringToByteArrayFastest(input);
}
catch (Exception ex)
{
Dispatcher.Invoke(() =>
{
HideLoadingCircle();
EnableAllButtons();
MessageBox.Show(ex.Message);
});
return;
}
output = Encrypt(encodedText, changeRegisters);
break;
}
case "base64":
{
try
{
encodedText = Convert.FromBase64String(input);
}
catch (FormatException)
{
Dispatcher.Invoke(() =>
{
HideLoadingCircle();
EnableAllButtons();
MessageBox.Show("niepoprawny format Base64!");
});
return;
}
output = Encrypt(encodedText, changeRegisters);
break;
}
case "unicode":
{
encodedText = Encoding.Unicode.GetBytes(input);
output = Encrypt(encodedText, changeRegisters);
break;
}
default:
break;
}
HideLoadingCircle();
EnableAllButtons();
asciiOutput = null;
hexOutput = null;
base64Output = null;
unicodeOutput = null;
WriteToOutputTextbox(output);
});
}
private void encryptFileBtn_Click(object sender, RoutedEventArgs e)
{
string input = outputLength.Text;
if (string.IsNullOrEmpty(input))
{
return;
}
int selectedOutputType = outputCombobox.SelectedIndex;
int selectedOutputFormat = outputFormatCombobox.SelectedIndex;
string filename = "";
if (outputCombobox.SelectedIndex == 1)
{
SaveFileDialog fileDialog = new SaveFileDialog();
if (fileDialog.ShowDialog() == true)
{
filename = fileDialog.FileName;
}
}
Lfsr[] lfsrs = new Lfsr[3] {
new Lfsr(19, true), new Lfsr(22, true), new Lfsr(23, true)
};
for (int i = 0; i < register19.Count; i++)
{
string txt = register19[i].Text;
char toAdd = '0';
if (txt.Length == 1)
{
toAdd = txt[0];
}
lfsrs[0].Register[i] = (toAdd == '1');
}
for (int i = 0; i < register22.Count; i++)
{
string txt = register22[i].Text;
char toAdd = '0';
if (txt.Length == 1)
{
toAdd = txt[0];
}
lfsrs[1].Register[i] = (toAdd == '1');
}
for (int i = 0; i < register23.Count; i++)
{
string txt = register23[i].Text;
char toAdd = '0';
if (txt.Length == 1)
{
toAdd = txt[0];
}
lfsrs[2].Register[i] = (toAdd == '1');
}
generator.ChangeRegister(lfsrs[0], 0);
generator.ChangeRegister(lfsrs[1], 1);
generator.ChangeRegister(lfsrs[2], 2);
Task.Run(() =>
{
ShowLoadingCircle();
DisableAllButtons();
int seriesLength = int.Parse(input);
if (selectedOutputType == 0)
{
if (selectedOutputFormat == 0)
{
char[] series = generator.GenerateBitsAsChars(seriesLength);
SetGeneratorOutput(new string(series));
}
else if (selectedOutputFormat == 1)
{
byte[] series = generator.GenerateBytes(seriesLength);
SetGeneratorOutput(Convert.ToBase64String(series));
}
}
else if (selectedOutputType == 1)
{
if (selectedOutputFormat == 0)
{
char[] series = generator.GenerateBitsAsChars(seriesLength);
File.WriteAllText(filename, new string(series));
}
else if (selectedOutputFormat == 1)
{
byte[] series = generator.GenerateBytes(seriesLength);
File.WriteAllBytes(filename, series);
}
}
EnableAllButtons();
HideLoadingCircle();
UpdateRegisters();
});
}
