Changeset 846


Ignore:
Timestamp:
Nov 15, 2009, 7:25:59 PM (12 years ago)
Author:
kohnen
Message:

Transposition now works on Byte-Arrays instead of Strings

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/Transposition/Transposition.cs

    r833 r846  
    2121
    2222        private String keyword = "";
    23         private String input = "";
    24         private String output = "";
     23        private byte[] input;
     24        private byte[] output;
    2525        private TranspositionSettings settings;
    2626        private TranspositionPresentation myPresentation;
    2727
    28         private char[,] read_in_matrix;
    29         private char[,] permuted_matrix;
     28        private byte[,] read_in_matrix;
     29        private byte[,] permuted_matrix;
    3030        private int[] key;
    3131        # endregion       
     
    5555        /// Get read in matrix.
    5656        /// </summary>
    57         public char[,] Read_in_matrix
     57        public byte[,] Read_in_matrix
    5858        {
    5959            get
     
    6666        /// Get permuted matrix.
    6767        /// </summary>
    68         public char[,] Permuted_matrix
     68        public byte[,] Permuted_matrix
    6969        {
    7070            get
     
    8989
    9090        [PropertyInfo(Direction.InputData, "Input", "input", "Text to be encrypted.", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
    91         public string Input
     91        public Byte[] Input
    9292        {
    9393            get
     
    119119
    120120        [PropertyInfo(Direction.OutputData, "Output", "output", "", DisplayLevel.Beginner)]
    121         public string Output
     121        public byte[] Output
    122122        {
    123123            get
     
    154154        {
    155155            ProcessTransposition();
    156             myPresentation.main(Read_in_matrix,Permuted_matrix,key,Keyword,Input,Output,this.settings.Permutation,this.settings.ReadIn,this.settings.ReadOut);
     156            //myPresentation.main(Read_in_matrix,Permuted_matrix,key,Keyword,Input,Output,this.settings.Permutation,this.settings.ReadIn,this.settings.ReadOut);
    157157           
    158158        }
     
    241241            {
    242242                Transposition_LogMessage("Keyword is not valid", NotificationLevel.Error);
    243                 Output = "";
    244             }
    245         }
    246 
    247         private String encrypt(String input, int[] key)
     243                Output = null;
     244            }
     245        }
     246
     247        private byte[] encrypt(byte[] input, int[] key)
    248248        {
    249249            if (key != null && input != null && key.Length > 0)
     
    251251                if (is_Valid_Keyword(key))
    252252                {
    253                     String encrypted = "";
     253                    byte[] encrypted = null;
    254254
    255255                    if (((TranspositionSettings.PermutationMode)settings.Permutation).Equals(TranspositionSettings.PermutationMode.byRow))
     
    308308                {
    309309                    Transposition_LogMessage("Keyword is not valid", NotificationLevel.Error);
    310                     return "";
     310                    return null;
    311311                }
    312312            }
     
    314314            {
    315315                // 2do: Anzeige "Kein gültiges Keyword
    316                 return "";
    317             }
    318         }
    319 
    320         private String decrypt(String input, int[] key)
     316                return null;
     317            }
     318        }
     319
     320        private byte[] decrypt(byte[] input, int[] key)
    321321        {
    322322            if (key != null && input != null && key.Length > 0)
     
    324324                if (is_Valid_Keyword(key))
    325325                {
    326                     String decrypted = "";
     326                    byte[] decrypted= null ;
    327327                    if (((TranspositionSettings.PermutationMode)settings.Permutation).Equals(TranspositionSettings.PermutationMode.byRow))
    328328                    {
     
    375375                        }
    376376                    }
    377 
    378377                    return decrypted;
    379378                }
     
    381380                {
    382381                    Transposition_LogMessage("Keyword is not valid", NotificationLevel.Error);
    383                     return "";
     382                    return null;
    384383                }
    385384            }
     
    387386            {
    388387                // 2do: Anzeige "Kein gültiges Keyword
    389                 return "";
    390             }
    391         }
    392 
    393         private char[,] enc_read_in_by_row(String input, int keyword_length)
     388                return null;
     389            }
     390        }
     391
     392        private byte[,] enc_read_in_by_row(byte[] input, int keyword_length)
    394393        {
    395394            int size = input.Length / keyword_length;
     
    401400
    402401            int pos = 0;
    403             char[,] matrix = new char[keyword_length, size];
     402            byte[,] matrix = new byte[keyword_length, size];
    404403
    405404            for (int i = 0; i < size; i++)
     
    417416        }
    418417
    419         private char[,] enc_read_in_by_column(String input, int keyword_length)
     418        private byte[,] enc_read_in_by_column(byte[] input, int keyword_length)
    420419        {
    421420            int size = input.Length / keyword_length;
     
    428427            int pos = 0;
    429428
    430             char[,] matrix = new char[keyword_length, size];
     429            byte[,] matrix = new byte[keyword_length, size];
    431430            for (int i = 0; i < keyword_length; i++)
    432431            {
     
    447446        }
    448447
    449         private char[,] enc_read_in_by_row_if_row_perm(String input, int keyword_length)
     448        private byte[,] enc_read_in_by_row_if_row_perm(byte[] input, int keyword_length)
    450449        {
    451450            int height = keyword_length;
     
    457456            }
    458457
    459             char[,] matrix = new char[length, height];
     458            byte[,] matrix = new byte[length, height];
    460459            int pos = 0;
    461460
     
    486485        }
    487486
    488         private char[,] enc_read_in_by_column_if_row_perm(String input, int keyword_length)
     487        private byte[,] enc_read_in_by_column_if_row_perm(byte[] input, int keyword_length)
    489488        {
    490489            int height = keyword_length;
     
    496495            }
    497496
    498             char[,] matrix = new char[length, height];
     497            byte[,] matrix = new byte[length, height];
    499498            int pos = 0;
    500499
     
    513512        }
    514513
    515         private char[,] dec_read_in_by_column(String input, int[] keyword)
     514        private byte[,] dec_read_in_by_column(byte[] input, int[] keyword)
    516515        {
    517516            int size = input.Length / keyword.Length;
     
    522521            }
    523522
    524             char[,] matrix = new char[keyword.Length, size];
     523            byte[,] matrix = new byte[keyword.Length, size];
    525524            int pos = 0;
    526525
     
    561560        }
    562561
    563         private char[,] dec_read_in_by_column_if_row_perm(String input, int[] keyword)
     562        private byte[,] dec_read_in_by_column_if_row_perm(byte[] input, int[] keyword)
    564563        {
    565564            int size = input.Length / keyword.Length;
     
    570569            }
    571570
    572             char[,] matrix = new char[size, keyword.Length];
     571            byte[,] matrix = new byte[size, keyword.Length];
    573572            int pos = 0;
    574573
     
    609608        }
    610609
    611         private char[,] dec_read_in_by_row(String input, int[] keyword)
     610        private byte[,] dec_read_in_by_row(byte[] input, int[] keyword)
    612611        {
    613612            int size = input.Length / keyword.Length;
     
    618617            }
    619618
    620             char[,] matrix = new char[keyword.Length, size];
     619            byte[,] matrix = new byte[keyword.Length, size];
    621620            int pos = 0;
    622621
     
    657656        }
    658657
    659         private char[,] dec_read_in_by_row_if_row_perm(String input, int[] keyword)
     658        private byte[,] dec_read_in_by_row_if_row_perm(byte[] input, int[] keyword)
    660659        {
    661660            int size = input.Length / keyword.Length;
     
    666665            }
    667666
    668             char[,] matrix = new char[size, keyword.Length];
     667            byte[,] matrix = new byte[size, keyword.Length];
    669668            int pos = 0;
    670669
     
    705704        }
    706705
    707         private char[,] enc_permut_by_column(char[,] readin_matrix, int[] keyword)
     706        private byte[,] enc_permut_by_column(byte[,] readin_matrix, int[] keyword)
    708707        {
    709708            int x = keyword.Length;
    710709            int y = readin_matrix.Length / keyword.Length;
    711             char[,] matrix = new char[x, y];
     710            byte[,] matrix = new byte[x, y];
    712711            int pos = 0;
    713712
     
    730729        }
    731730
    732         private char[,] enc_permute_by_row(char[,] readin_matrix, int[] keyword)
     731        private byte[,] enc_permute_by_row(byte[,] readin_matrix, int[] keyword)
    733732        {
    734733            int y = keyword.Length;
    735734            int x = readin_matrix.Length / keyword.Length;
    736             char[,] matrix = new char[x, y];
     735            byte[,] matrix = new byte[x, y];
    737736            int pos = 0;
    738737
     
    755754        }
    756755
    757         private char[,] dec_permut_by_column(char[,] readin_matrix, int[] keyword)
     756        private byte[,] dec_permut_by_column(byte[,] readin_matrix, int[] keyword)
    758757        {
    759758            int x = keyword.Length;
    760759            int y = readin_matrix.Length / keyword.Length;
    761             char[,] matrix = new char[x, y];
     760            byte[,] matrix = new byte[x, y];
    762761
    763762            for (int i = 0; i < x; i++)
     
    771770        }
    772771
    773         private static char[,] dec_permut_by_row(char[,] readin_matrix, int[] keyword)
     772        private byte[,] dec_permut_by_row(byte[,] readin_matrix, int[] keyword)
    774773        {
    775774            int x = keyword.Length;
    776775            int y = readin_matrix.Length / keyword.Length;
    777             char[,] matrix = new char[y, x];
     776            byte[,] matrix = new byte[y, x];
    778777
    779778            for (int i = 0; i < x; i++)
     
    787786        }
    788787
    789         private String read_out_by_row(char[,] matrix, int keyword_length)
     788        private byte[] read_out_by_row(byte[,] matrix, int keyword_length)
    790789        {
    791790            int x = keyword_length;
    792791            int y = matrix.Length / keyword_length;
    793             String enc = "";
    794             char empty_char = new char();
    795 
     792            byte empty_byte = new byte();
     793            int count_empty = 0;
     794                       
     795            for(int i=0; i<y; i++)
     796            {
     797                for(int j=0; j<x; j++)
     798                {
     799                    byte tmp = matrix[j, i];
     800                    if (tmp.Equals(empty_byte))
     801                    {
     802                        count_empty++;
     803                    }
     804                }
     805            }
     806            byte[] enc = new byte[matrix.Length-count_empty];
     807
     808            int pos = 0;
    796809            for (int i = 0; i < y; i++)
    797810            {
    798811                for (int j = 0; j < x; j++)
    799812                {
    800                     char tmp = matrix[j, i];
    801                     if (!tmp.Equals(empty_char))
    802                     {
    803                         enc += tmp;
     813                    byte tmp = matrix[j, i];
     814                    if (!tmp.Equals(empty_byte))
     815                    {
     816                        enc[pos] = tmp;
     817                        pos++;
    804818                    }
    805819                }
     
    808822        }
    809823
    810         private String read_out_by_row_if_row_perm(char[,] matrix, int keyword_length)
     824        private byte[] read_out_by_row_if_row_perm(byte[,] matrix, int keyword_length)
    811825        {
    812826            int y = keyword_length;
    813827            int x = matrix.Length / keyword_length;
    814             String enc = "";
    815             char empty_char = new char();
    816 
     828           
     829            byte empty_byte = new byte();
     830            int empty_count = 0;
    817831            for (int i = 0; i < y; i++)
    818832            {
    819833                for (int j = 0; j < x; j++)
    820834                {
    821                     char tmp = matrix[j, i];
    822                     if (!tmp.Equals(empty_char))
    823                     {
    824                         enc += tmp;
     835                    byte tmp = matrix[j, i];
     836                    if (tmp.Equals(empty_byte))
     837                    {
     838                        empty_count++;
     839                    }
     840                }
     841            }
     842
     843            byte[] enc = new byte[matrix.Length - empty_count];
     844            int pos = 0;
     845
     846            for (int i = 0; i < y; i++)
     847            {
     848                for (int j = 0; j < x; j++)
     849                {
     850                    byte tmp = matrix[j, i];
     851                    if (!tmp.Equals(empty_byte))
     852                    {
     853                        enc[pos] = tmp;
     854                        pos++;
    825855                    }
    826856                }
     
    829859        }
    830860
    831         private String read_out_by_column(char[,] matrix, int keyword_length)
     861        private byte[] read_out_by_column(byte[,] matrix, int keyword_length)
    832862        {
    833863            int x = keyword_length;
    834864            int y = matrix.Length / keyword_length;
    835             String enc = "";
    836             char empty_char = new char();
     865           
     866            byte empty_byte = new byte();
     867            int empty_count = 0;
    837868
    838869            for (int i = 0; i < x; i++)
     
    840871                for (int j = 0; j < y; j++)
    841872                {
    842                     char tmp = matrix[i, j];
    843                     if (!tmp.Equals(empty_char))
    844                     {
    845                         enc += tmp;
     873                    byte tmp = matrix[i, j];
     874                    if (tmp.Equals(empty_byte))
     875                    {
     876                        empty_count++;
     877                    }
     878                }
     879            }
     880
     881            byte[] enc = new byte[matrix.Length - empty_count];
     882            int pos =0;
     883            for (int i = 0; i < x; i++)
     884            {
     885                for (int j = 0; j < y; j++)
     886                {
     887                    byte tmp = matrix[i, j];
     888                    if (!tmp.Equals(empty_byte) || tmp.Equals(null))
     889                    {
     890                        enc[pos] = tmp;
     891                        pos++; 
    846892                    }
    847893                }
     
    850896        }
    851897
    852         private String read_out_by_column_if_row_perm(char[,] matrix, int keyword_length)
     898        private byte[] read_out_by_column_if_row_perm(byte[,] matrix, int keyword_length)
    853899        {
    854900            int y = keyword_length;
    855901            int x = matrix.Length / keyword_length;
    856             String enc = "";
    857             char empty_char = new char();
    858 
     902           
     903            byte empty_byte = new byte();
     904            int empty_count = 0;
    859905            for (int i = 0; i < x; i++)
    860906            {
    861907                for (int j = 0; j < y; j++)
    862908                {
    863                     char tmp = matrix[i, j];
    864                     if (!tmp.Equals(empty_char))
    865                     {
    866                         enc += tmp;
     909                    byte tmp = matrix[i, j];
     910                    if (tmp.Equals(empty_byte))
     911                    {
     912                        empty_count++;
     913                    }
     914                }
     915            }
     916
     917            byte[] enc = new byte[matrix.Length - empty_count];
     918            int pos = 0;
     919            for (int i = 0; i < x; i++)
     920            {
     921                for (int j = 0; j < y; j++)
     922                {
     923                    byte tmp = matrix[i, j];
     924                    if (!tmp.Equals(empty_byte))
     925                    {
     926                        enc[pos] = tmp;
     927                        pos++;
    867928                    }
    868929                }
Note: See TracChangeset for help on using the changeset viewer.