Changeset 796


Ignore:
Timestamp:
Oct 28, 2009, 7:28:18 PM (12 years ago)
Author:
kohnen
Message:

permutation "by row" added

Location:
trunk/CrypPlugins/Transposition
Files:
2 edited

Legend:

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

    r782 r796  
    2121
    2222        private String keyword = "";
    23         private String dpkeyword = "";
    2423        private String input = "";
    2524        private String output = "";
     
    7170        }
    7271
    73         [PropertyInfo(Direction.InputData, "Double transposition keyword", "double transposition keyword", "Keyword ued for double transposition. If empty, the first keyword is used for the second transposition, too.", DisplayLevel.Beginner)]
    74         public string DoubleTransposition
    75         {
    76             get
    77             {
    78                 return this.dpkeyword;
    79             }
    80             set
    81             {
    82                 this.dpkeyword = value;
    83                 OnPropertyChange("DoubleTransposition");
    84             }
    85         }
    86 
    87 
    8872        [PropertyInfo(Direction.OutputData, "Output", "output", "", DisplayLevel.Beginner)]
    8973        public string Output
     
    180164            {
    181165                int[] key = null;
    182                 int[] dpkey = null;
    183 
    184                 if (keyword.Contains('1'))
     166
     167                if (keyword.Contains(','))
    185168                {
    186169                    key = get_Keyword_Array(keyword);
     
    192175                }
    193176
    194 
    195                 if (DoubleTransposition == null || DoubleTransposition.Equals(""))
    196                 {
    197                     dpkey = key;
    198                 }
    199 
    200                 else
    201                 {
    202                     if (dpkeyword.Contains('1'))
    203                     {
    204                         dpkey = get_Keyword_Array(dpkeyword);
    205                     }
    206 
     177                switch (settings.Action)
     178                {
     179                    case 0:
     180                        Output = encrypt(input, key);
     181                        break;
     182                    case 1:
     183                        Output = decrypt(input, key);
     184                        break;
     185                    default:
     186                        break;
     187                }
     188                ProgressChanged(1, 1);
     189            }
     190
     191            catch (Exception)
     192            {
     193                Transposition_LogMessage("Keyword is not valid" , NotificationLevel.Error);
     194                Output = "";
     195            }
     196        }
     197
     198        private String encrypt(String input, int[] key)
     199        {
     200            if (key != null && input != null && key.Length > 0)
     201            {
     202                if (is_Valid_Keyword(key))
     203                {
     204                    String encrypted = "";
     205                    char[,] matrix = null;
     206
     207                    if (((TranspositionSettings.PermutationMode)settings.Permutation).Equals(TranspositionSettings.PermutationMode.byRow))
     208                    {
     209                        switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
     210                        {
     211                            case TranspositionSettings.ReadInMode.byRow:
     212                                matrix = enc_read_in_by_row_if_row_perm(input, key.Length); break;
     213                            case TranspositionSettings.ReadInMode.byColumn:
     214                                matrix = enc_read_in_by_column_if_row_perm(input, key.Length); break;
     215                            default:
     216                                break;
     217                        }
     218
     219                        matrix = enc_permute_by_row(matrix, key);
     220
     221                        switch ((TranspositionSettings.ReadOutMode)settings.ReadOut)
     222                        {
     223                            case TranspositionSettings.ReadOutMode.byRow:
     224                                encrypted = read_out_by_row_if_row_perm(matrix, key.Length); break;
     225                            case TranspositionSettings.ReadOutMode.byColumn:
     226                                encrypted = read_out_by_column_if_row_perm(matrix, key.Length); break;
     227                            default:
     228                                break;
     229                        }
     230                    }
     231
     232                    // permute by column:
    207233                    else
    208234                    {
    209                         dpkey = sortKey(dpkeyword);
    210                     }
    211                 }
    212 
    213                 if (settings.DoubleTransposition)
    214                 {
    215                     switch (settings.Action)
    216                     {
    217                         case 0:
    218                             String enc_tmp = encrypt(input, key);
    219                             Output = encrypt(enc_tmp, dpkey);
    220                             break;
    221 
    222                         case 1:
    223                             String dec_tmp = decrypt(input, dpkey);
    224                             Output = decrypt(dec_tmp, key);
    225                             break;
    226 
    227                         default:
    228                             break;
    229                     }
    230                 }
    231 
    232                 else
    233                 {
    234                     switch (settings.Action)
    235                     {
    236 
    237                         case 0:
    238                             Output = encrypt(input, key);
    239                             break;
    240                         case 1:
    241                             Output = decrypt(input, key);
    242                             break;
    243                         default:
    244                             break;
    245                     }
    246                 }
    247 
    248                 ProgressChanged(1, 1);
    249             }
    250 
    251             catch (Exception)
    252             {
    253                 Transposition_LogMessage("Keyword is not valid", NotificationLevel.Error);
    254                 Output = "";
    255             }
    256         }
    257 
    258         private String encrypt(String input, int[] key)
    259         {
    260             if (key != null && input != null && key.Length>0)
    261             {
    262                 if (is_Valid_Keyword(key))
    263                 {
    264                     char[,] matrix = null;
    265 
    266                     switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
    267                     {
    268                         case TranspositionSettings.ReadInMode.byRow:
    269                             matrix = enc_read_in_by_row(input, key.Length); break;
    270                         case TranspositionSettings.ReadInMode.byColumn:
    271                             matrix = enc_read_in_by_column(input, key.Length); break;
    272                         default:
    273                             break;
    274                     }
    275 
    276                     switch ((TranspositionSettings.PermutationMode)settings.Permutation)
    277                     {
    278                         case TranspositionSettings.PermutationMode.byColumn:
    279                             matrix = enc_permut_by_column(matrix, key); break;
    280 
    281                         // Permute by row still to do
    282                         case TranspositionSettings.PermutationMode.byRow:
    283                             matrix = enc_permut_by_column(matrix, key); break;
    284                         default:
    285                             break;
    286                     }
    287 
    288                     String encrypted = "";
    289 
    290                     switch ((TranspositionSettings.ReadOutMode)settings.ReadOut)
    291                     {
    292                         case TranspositionSettings.ReadOutMode.byRow:
    293                             encrypted = read_out_by_row(matrix, key.Length); break;
    294                         case TranspositionSettings.ReadOutMode.byColumn:
    295                             encrypted = read_out_by_column(matrix, key.Length); break;
    296                         default:
    297                             break;
     235                        switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
     236                        {
     237                            case TranspositionSettings.ReadInMode.byRow:
     238                                matrix = enc_read_in_by_row(input, key.Length); break;
     239                            case TranspositionSettings.ReadInMode.byColumn:
     240                                matrix = enc_read_in_by_column(input, key.Length); break;
     241                            default:
     242                                break;
     243                        }
     244
     245                        matrix = enc_permut_by_column(matrix, key);
     246
     247                        switch ((TranspositionSettings.ReadOutMode)settings.ReadOut)
     248                        {
     249                            case TranspositionSettings.ReadOutMode.byRow:
     250                                encrypted = read_out_by_row(matrix, key.Length); break;
     251                            case TranspositionSettings.ReadOutMode.byColumn:
     252                                encrypted = read_out_by_column(matrix, key.Length); break;
     253                            default:
     254                                break;
     255                        }
    298256                    }
    299257
     
    315273        private String decrypt(String input, int[] key)
    316274        {
    317             if (key != null && input != null && key.Length>0)
     275            if (key != null && input != null && key.Length > 0)
    318276            {
    319277                if (is_Valid_Keyword(key))
    320278                {
    321279                    char[,] matrix = null;
    322 
    323                     switch ((TranspositionSettings.ReadOutMode)settings.ReadOut)
    324                     {
    325                         case TranspositionSettings.ReadOutMode.byRow:
    326                             matrix = dec_read_in_by_column(input, key); break;
    327                         case TranspositionSettings.ReadOutMode.byColumn:
    328                             matrix = dec_read_in_by_row(input, key); break;
    329                         default:
    330                             break;
    331                     }
    332 
    333                     switch ((TranspositionSettings.PermutationMode)settings.Permutation)
    334                     {
    335                         case TranspositionSettings.PermutationMode.byRow:
    336                             matrix = dec_permut_by_column(matrix, key); break;
    337 
    338                         // Permute by row still to do
    339                         case TranspositionSettings.PermutationMode.byColumn:
    340                             matrix = dec_permut_by_column(matrix, key); break;
    341                         default:
    342                             break;
    343                     }
    344 
    345280                    String decrypted = "";
    346 
    347                     switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
    348                     {
    349                         case TranspositionSettings.ReadInMode.byRow:
    350                             decrypted = read_out_by_row(matrix, key.Length); break;
    351                         case TranspositionSettings.ReadInMode.byColumn:
    352                             decrypted = read_out_by_column(matrix, key.Length); break;
    353                         default:
    354                             break;
     281                    if (((TranspositionSettings.PermutationMode)settings.Permutation).Equals(TranspositionSettings.PermutationMode.byRow))
     282                    {
     283                        switch ((TranspositionSettings.ReadOutMode)settings.ReadOut)
     284                        {
     285                            case TranspositionSettings.ReadOutMode.byRow:
     286                                matrix = dec_read_in_by_row_if_row_perm(input, key); break;
     287                            case TranspositionSettings.ReadOutMode.byColumn:
     288                                matrix = dec_read_in_by_column_if_row_perm(input, key); break;
     289                            default:
     290                                break;
     291                        }
     292
     293                        matrix = dec_permut_by_row(matrix, key);
     294
     295                        switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
     296                        {
     297                            case TranspositionSettings.ReadInMode.byRow:
     298                                decrypted = read_out_by_row_if_row_perm(matrix, key.Length); break;
     299                            case TranspositionSettings.ReadInMode.byColumn:
     300                                decrypted = read_out_by_column_if_row_perm(matrix, key.Length); break;
     301                            default:
     302                                break;
     303                        }
     304                    }
     305
     306                    // permute by column:
     307                    else
     308                    {
     309                        switch ((TranspositionSettings.ReadOutMode)settings.ReadOut)
     310                        {
     311                            case TranspositionSettings.ReadOutMode.byRow:
     312                                matrix = dec_read_in_by_row(input, key); break;
     313                            case TranspositionSettings.ReadOutMode.byColumn:
     314                                matrix = dec_read_in_by_column(input, key); break;
     315                            default:
     316                                break;
     317                        }
     318                       
     319                        matrix = dec_permut_by_column(matrix, key);
     320
     321                        switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
     322                        {
     323                            case TranspositionSettings.ReadInMode.byRow:
     324                                decrypted = read_out_by_row(matrix, key.Length); break;
     325                            case TranspositionSettings.ReadInMode.byColumn:
     326                                decrypted = read_out_by_column(matrix, key.Length); break;
     327                            default:
     328                                break;
     329                        }
    355330                    }
    356331
     
    428403        }
    429404
    430         private char[,] dec_read_in_by_row(String input, int[] keyword)
     405        private char[,] enc_read_in_by_row_if_row_perm(String input, int keyword_length)
     406        {
     407            int height = keyword_length;
     408            int length = input.Length / keyword_length;
     409            int offs = input.Length % keyword_length;
     410            if (offs != 0)
     411            {
     412                length++;
     413            }
     414
     415            char[,] matrix = new char[length, height];
     416            int pos = 0;
     417
     418            for (int i = 0; i < height; i++)
     419            {
     420                for (int j = 0; j < length; j++)
     421                {
     422                    if (pos < input.Length)
     423                    {
     424                        if (j.Equals(length - 1) && offs != 0)
     425                        {
     426                            if (i < offs)
     427                            {
     428                                matrix[j, i] = input[pos];
     429                                pos++;
     430                            }
     431                        }
     432
     433                        else
     434                        {
     435                            matrix[j, i] = input[pos];
     436                            pos++;
     437                        }
     438                    }
     439                }
     440            }
     441
     442            return matrix;
     443        }
     444
     445        private char[,] enc_read_in_by_column_if_row_perm(String input, int keyword_length)
     446        {
     447            int height = keyword_length;
     448            int length = input.Length / keyword_length;
     449            int offs = input.Length % keyword_length;
     450            if (offs != 0)
     451            {
     452                length++;
     453            }
     454
     455            char[,] matrix = new char[length, height];
     456            int pos = 0;
     457
     458            for (int i = 0; i < length; i++)
     459            {
     460                for (int j = 0; j < height; j++)
     461                {
     462                    if (pos < input.Length)
     463                    {
     464                        matrix[i, j] = input[pos];
     465                        pos++;
     466                    }
     467                }
     468            }
     469
     470            return matrix;
     471        }
     472
     473        private char[,] dec_read_in_by_column(String input, int[] keyword)
    431474        {
    432475            int size = input.Length / keyword.Length;
     
    479522        }
    480523
    481         private char[,] dec_read_in_by_column(String input, int[] keyword)
     524        private char[,] dec_read_in_by_column_if_row_perm(String input, int[] keyword)
    482525        {
    483526            int size = input.Length / keyword.Length;
     
    489532            }
    490533
    491             char[,] matrix = new char[keyword.Length, size];
     534            char[,] matrix = new char[size, keyword.Length];
    492535            int pos = 0;
    493536
     
    512555                            if (ok)
    513556                            {
     557                                matrix[i, j] = input[pos];
     558                                pos++;
     559                            }
     560
     561                        }
     562                        else
     563                        {
     564                            matrix[i, j] = input[pos];
     565                            pos++;
     566                        }
     567                    }
     568                }
     569            }
     570
     571
     572            return matrix;
     573        }
     574
     575        private char[,] dec_read_in_by_row(String input, int[] keyword)
     576        {
     577            int size = input.Length / keyword.Length;
     578
     579            int offs = input.Length % keyword.Length;
     580            if (offs != 0)
     581            {
     582                size++;
     583            }
     584
     585            char[,] matrix = new char[keyword.Length, size];
     586            int pos = 0;
     587
     588            for (int i = 0; i < size; i++)
     589            {
     590                for (int j = 0; j < keyword.Length; j++)
     591                {
     592                    if (pos < input.Length)
     593                    {
     594                        if ((!offs.Equals(0)) && i.Equals(size - 1))
     595                        {
     596                            bool ok = false;
     597
     598                            for (int k = 0; k < offs; k++)
     599                            {
     600                                if ((keyword[k] - 1).Equals(j))
     601                                {
     602                                    ok = true;
     603                                }
     604                            }
     605
     606                            if (ok)
     607                            {
    514608                                matrix[j, i] = input[pos];
    515609                                pos++;
     
    530624        }
    531625
     626        private char[,] dec_read_in_by_row_if_row_perm(String input, int[] keyword)
     627        {
     628            int size = input.Length / keyword.Length;
     629
     630            int offs = input.Length % keyword.Length;
     631            if (offs != 0)
     632            {
     633                size++;
     634            }
     635
     636            char[,] matrix = new char[size, keyword.Length];
     637            int pos = 0;
     638
     639            for (int i = 0; i < keyword.Length; i++)
     640            {
     641                for (int j = 0; j < size; j++)
     642                {
     643                    if (pos < input.Length)
     644                    {
     645                        if ((!offs.Equals(0)) && j.Equals(size - 1))
     646                        {
     647                            bool ok = false;
     648
     649                            for (int k = 0; k < offs; k++)
     650                            {
     651                                if ((keyword[k] - 1).Equals(i))
     652                                {
     653                                    ok = true;
     654                                }
     655                            }
     656
     657                            if (ok)
     658                            {
     659                                matrix[j, i] = input[pos];
     660                                pos++;
     661                            }
     662
     663                        }
     664                        else
     665                        {
     666                            matrix[j, i] = input[pos];
     667                            pos++;
     668                        }
     669                    }
     670                }
     671            }
     672
     673
     674            return matrix;
     675        }
     676
    532677        private char[,] enc_permut_by_column(char[,] readin_matrix, int[] keyword)
    533678        {
     
    558703        }
    559704
     705        private char[,] enc_permute_by_row(char[,] readin_matrix, int[] keyword)
     706        {
     707            int y = keyword.Length;
     708            int x = readin_matrix.Length / keyword.Length;
     709
     710            char[,] matrix = new char[x, y];
     711
     712            int pos = 0;
     713
     714            for (int i = 1; i <= y; i++)
     715            {
     716                for (int j = 0; j < keyword.Length; j++)
     717                {
     718                    if (keyword[j].Equals(i))
     719                    {
     720                        pos = j;
     721                    }
     722                }
     723
     724                for (int j = 0; j < x; j++)
     725                {
     726                    matrix[j, i - 1] = readin_matrix[j, pos];
     727                }
     728            }
     729
     730            return matrix;
     731        }
     732
    560733        private char[,] dec_permut_by_column(char[,] readin_matrix, int[] keyword)
    561734        {
     
    576749        }
    577750
     751        private static char[,] dec_permut_by_row(char[,] readin_matrix, int[] keyword)
     752        {
     753            int x = keyword.Length;
     754            int y = readin_matrix.Length / keyword.Length;
     755
     756            char[,] matrix = new char[y, x];
     757
     758
     759            for (int i = 0; i < x; i++)
     760            {
     761                for (int j = 0; j < y; j++)
     762                {
     763                    matrix[j, i] = readin_matrix[j, keyword[i] - 1];
     764                }
     765            }
     766
     767            return matrix;
     768        }
     769
    578770        private String read_out_by_row(char[,] matrix, int keyword_length)
    579771        {
     
    599791        }
    600792
     793        private String read_out_by_row_if_row_perm(char[,] matrix, int keyword_length)
     794        {
     795            int y = keyword_length;
     796            int x = matrix.Length / keyword_length;
     797
     798            String enc = "";
     799            char empty_char = new char();
     800
     801            for (int i = 0; i < y; i++)
     802            {
     803                for (int j = 0; j < x; j++)
     804                {
     805                    char tmp = matrix[j, i];
     806                    if (!tmp.Equals(empty_char))
     807                    {
     808                        enc += tmp;
     809                    }
     810                }
     811            }
     812
     813            return enc;
     814        }
     815
    601816        private String read_out_by_column(char[,] matrix, int keyword_length)
    602817        {
    603818            int x = keyword_length;
    604819            int y = matrix.Length / keyword_length;
     820
     821            String enc = "";
     822            char empty_char = new char();
     823
     824            for (int i = 0; i < x; i++)
     825            {
     826                for (int j = 0; j < y; j++)
     827                {
     828                    char tmp = matrix[i, j];
     829                    if (!tmp.Equals(empty_char))
     830                    {
     831                        enc += tmp;
     832                    }
     833                }
     834            }
     835
     836            return enc;
     837        }
     838
     839        private String read_out_by_column_if_row_perm(char[,] matrix, int keyword_length)
     840        {
     841            int y = keyword_length;
     842            int x = matrix.Length / keyword_length;
    605843
    606844            String enc = "";
     
    694932            return true;
    695933        }
    696                
    697                 public int[] sortKey(String input)
     934
     935        public int[] sortKey(String input)
    698936        {
    699937            if (input != null && !input.Equals(""))
     
    721959
    722960        }
    723      
     961
    724962        # endregion
    725963    }
  • trunk/CrypPlugins/Transposition/TranspositionSettings.cs

    r782 r796  
    1313
    1414        private Boolean hasChanges = false;
    15         private Boolean doubleTransposition = false;
    1615        private int selectedAction = 0;
    1716
     
    9998        }
    10099
    101         [PropertySaveOrder(5)]
    102         [ContextMenu("Double Transposition", "Select this, if u want to compute the double transposition.", 5, DisplayLevel.Beginner, ContextMenuControlType.CheckBox, null, "Double Transposition")]
    103         [TaskPane("Double Transposition", "Select this, if u want to compute the double transposition.", null, 5, false, DisplayLevel.Expert, ControlType.CheckBox, "")]
    104         public bool DoubleTransposition
    105         {
    106             get { return this.doubleTransposition; }
    107             set
    108             {
    109                 if (value != this.doubleTransposition) HasChanges = true;
    110                 this.doubleTransposition = value;
    111                 OnPropertyChanged("DoubleTransposition");
    112             }
    113         }
    114 
    115100
    116101        protected void OnPropertyChanged(string name)
Note: See TracChangeset for help on using the changeset viewer.