Esempio n. 1
0
    public void Ready_up_encryption()
    {
        message = laundry_data.Get_data();
        Russian();

        cipher_canvas.gameObject.SetActive(true);
        left_main.SetActive(true);
        left_txt.SetActive(false);
        left_img.SetActive(false);

        work_bits            = laundry_data.Get_raw_bits();
        picked_functions     = laundry_data.Get_picked_functions();
        number_of_iterations = laundry_data.Get_iterations();
        current_iteration    = 0;
        end_of_iteration     = false;
        number_of_blocks     = work_bits.Length / Static_Data.Get_double_segment_size();
        current_block        = 0;
        end_of_blocks        = false;
        cipher_state         = Cipher_State.Encryption;
        cipher_type          = laundry_data.Get_cipher_type();
        Set_current(work_bits, full_sqtr_size);

        full_sqtr_size = Calculate_sqrt_floor(work_bits.Length);
        Create_img(work_bits, full_sqtr_size);
        title_text.text = Text_Data.Get_raw_text();
        //current_key = Static_Data.Get_key();

        steps = laundry_data.Get_work_bytes();
    }
Esempio n. 2
0
        public IEnumerable <Static_Data> GetData(int id)
        {
            Guid               guid         = Guid.NewGuid();
            Static_Data        static_Data  = null;
            List <Static_Data> static_Datas = null;

            _logger.LogDebug($"Debug {guid.ToString()}");
            _logger.LogInformation($"Debug {guid.ToString()}");
            _logger.LogWarning($"Debug {guid.ToString()}");
            _logger.LogError($"Debug {guid.ToString()}");
            _logger.LogCritical($"Debug {guid.ToString()}");
            try
            {
                static_Datas = new List <Static_Data>();
                for (int i = 0; i < 10; i++)
                {
                    static_Data       = new Static_Data();
                    static_Data.Data  = "Data";
                    static_Data.Data1 = "Data1";
                    static_Data.Data2 = "Data2";
                    static_Datas.Add(static_Data);
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, ex.Message);
            }

            return(static_Datas);
        }
Esempio n. 3
0
    public List <BitArray> Get_bit_block(int number)
    {
        List <BitArray> bit_block = new List <BitArray>();
        BitArray        bits      = new BitArray(Static_Data.Get_segment_size());

        int counter = 0;

        for (int i = Static_Data.Get_double_segment_size() * number; i < Static_Data.Get_double_segment_size() * number + Static_Data.Get_segment_size(); i++)
        {
            bits[counter] = work_bits[i];

            counter++;
        }

        bit_block.Add(bits);
        bits    = new BitArray(Static_Data.Get_segment_size());
        counter = 0;

        for (int i = Static_Data.Get_double_segment_size() * number + Static_Data.Get_segment_size(); i < Static_Data.Get_double_segment_size() * (number + 1); i++)
        {
            bits[counter] = work_bits[i];

            counter++;
        }

        bit_block.Add(bits);

        return(bit_block);
    }
Esempio n. 4
0
    public void Set_bit_block(BitArray bits, int number)
    {
        int counter = 0;

        for (int i = Static_Data.Get_double_segment_size() * number; i < Static_Data.Get_double_segment_size() * (number + 1); i++)
        {
            work_bits[i] = bits[counter];
            counter++;
        }
    }
Esempio n. 5
0
    private void Fill_up_bits()
    {
        int segments = Mathf.CeilToInt((float)raw_bits.Length / (float)Static_Data.Get_double_segment_size());

        BitArray bits = new BitArray(segments * Static_Data.Get_double_segment_size());

        for (int i = 0; i < raw_bits.Length; i++)
        {
            bits[i] = raw_bits[i];
        }

        raw_bits  = bits;
        work_bits = bits;
    }
Esempio n. 6
0
    private void Set_current(BitArray bits, int sqtr_size)
    {
        current_bits      = bits;
        currnet_sqtr_size = sqtr_size;

        if (bits.Length > Static_Data.Get_max_txt_file())
        {
            txt_download_button.interactable = false;
        }
        else
        {
            txt_download_button.interactable = true;
        }
    }
Esempio n. 7
0
    //=== BUTTONS =====================================================================================================================================================

    private void Check_start_button()
    {
        if (iteration_text != "")
        {
            if (Int32.Parse(iteration_text) > Static_Data.Get_max_iteration())
            {
                input_field.text = Static_Data.Get_max_iteration().ToString();
            }
        }

        if (iteration_text == "0")
        {
            input_field.text = "1";
        }

        if (picked_functions.Count > 0 && input_field.text != "")
        {
            start_button.interactable = true;
        }
        else
        {
            start_button.interactable = false;
        }
    }
Esempio n. 8
0
 void Initialising_Data()
 {
     Static_Data.Initialising_FromFile();
 }
Esempio n. 9
0
    private BitArray Calculate_block()
    {
        var      list_block = laundry_data.Get_bit_block(current_block);
        BitArray block1     = list_block[0];
        BitArray block2     = list_block[1];

        BitArray block2t = new BitArray(block2.Length);

        for (int i = 0; i < block2.Length; i++)
        {
            block2t[i] = block2[i];

            Debug.Log(block2[i] + " " + block2t[i]);
        }

        BitArray double_block = new BitArray(Static_Data.Get_double_segment_size());

        // === FUNKCJE + KLUCZ ===

        int[] perm_tab = { 16,  7, 20, 21, 29, 12, 28, 17,  1, 15, 23, 26,
                           5,  18, 31, 10,  2,  8, 24, 14, 32, 27,  3,  9,19, 13, 30, 6,
                           22, 11,  4, 25 };



        if (picked_functions.Contains(Math_Functions.F1))
        {
            for (int i = 0; i < Static_Data.Get_segment_size(); i++)
            {
                // Debug.Log(block2[i]);



                block2[i] = block2[perm_tab[i] - 1];
            }
        }

        if (picked_functions.Contains(Math_Functions.F2))
        {
        }

        if (picked_functions.Contains(Math_Functions.F3))
        {
        }

        if (picked_functions.Contains(Math_Functions.F4))
        {
        }



        // === XOR ===

        for (int i = 0; i < block1.Length; i++)
        {
            block2[i] = block1[i] ^ block2[i];
        }

        // === ZAMIANA MIEJSCAMI

        for (int i = 0; i < Static_Data.Get_segment_size(); i++)
        {
            //Debug.Log(block2t[i]);

            double_block[i] = block2t[i];
        }

        int counter = 0;

        for (int i = Static_Data.Get_segment_size(); i < double_block.Length; i++)
        {
            double_block[i] = block2[counter];
            counter++;
        }

        // === DOPISANIE GOTOWEGO BLOKU DO PELNIEJ WIADOMOSCI ===

        laundry_data.Set_bit_block(double_block, current_block);

        current_block++;

        if (current_block >= number_of_blocks)
        {
            end_of_blocks = true;
        }

        return(double_block);
    }