Changeset 778


Ignore:
Timestamp:
Oct 25, 2009, 5:40:05 PM (12 years ago)
Author:
kohnen
Message:

settings added

Location:
trunk/CrypPlugins/Transposition
Files:
3 edited

Legend:

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

    r776 r778  
    1111using Cryptool.PluginBase.Miscellaneous;
    1212
    13 
    1413namespace Transposition
    1514{
    16 
    17     [Author("Daniel Kohnen", "kohnen@cryptool.org", "Uni Duisburg-Essen", "http://www.uni-due.de")]
    18     [PluginInfo(false, "Transposition", "", "", "Transposition/icon.png")]
     15    [Author("Daniel Kohnen, Julian Weyers, Simon Malischewski, Armin Wiefels", "kohnen@cryptool.org, weyers@cryptool.org, malischewski@cryptool.org, wiefels@cryptool.org", "Universität Duisburg-Essen", "http://www.uni-due.de")]
     16    [PluginInfo(false, "Transposition", "", "", "Transposition/Images/icon.png", "Transposition/Images/encrypt.png", "Transposition/Images/decrypt.png")]
    1917    [EncryptionType(EncryptionType.Classic)]
    2018    public class Transposition : IEncryption
     
    4543        # region Properties
    4644
    47         [PropertyInfo(Direction.InputData, "Input", "input", "", DisplayLevel.Beginner)]
     45        [PropertyInfo(Direction.InputData, "Input", "input", "Text to be encrypted.", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
    4846        public string Input
    4947        {
     
    6058        }
    6159
    62         [PropertyInfo(Direction.InputData, "Keyword", "keyword", "", DisplayLevel.Beginner)]
     60        [PropertyInfo(Direction.InputData, "Keyword", "keyword", "Keyword used for encryption", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
    6361        public string Keyword
    6462        {
     
    166164        private void ProcessTransposition()
    167165        {
    168 
    169             Output = encrypt_text(input, keyword);
     166            switch (settings.Action)
     167            {
     168                case 0:
     169                    Output = encrypt();
     170                    break;
     171                case 1:
     172                    Output = decrypt();
     173                    break;
     174                default:
     175                    break;
     176            }
     177
    170178
    171179            ProgressChanged(1, 1);
    172180        }
    173        
    174         // old function
    175         private String encrypt_text(String input, String keyword)
    176         {
    177             int[] keys = new int[keyword.Length];
    178 
    179             for (int i = 1; i <= keyword.Length; i++)
    180             {
    181                 for (int j = 0; j < keyword.Length; j++)
    182                 {
    183                     if ((int)Char.GetNumericValue(keyword[j]) == i)
    184                     {
    185                         keys[i - 1] = j;
    186                     }
    187                 }
    188             }
    189 
    190             String enc = "";
    191 
    192             for (int j = 0; j < keyword.Length; j++)
    193             {
    194                 for (int i = 0; i <= input.Length / keyword.Length; i++)
    195                 {
    196                     int tmp = keys[j] + i * keyword.Length;
    197 
    198                     if (tmp < input.Length)
    199                     {
    200                         enc += input[tmp];
    201                     }
    202                 }
    203             }
    204 
    205             return enc;
    206         }
    207 
    208         // old function
    209         private String decrypt_text(String input, String keyword)
    210         {
    211             int input_pos = 0;
    212 
    213             int breite = keyword.Length;
    214             int hoehe = input.Length / keyword.Length;
    215             int offs = input.Length % keyword.Length;
    216             if (offs != 0) { hoehe++; }
    217 
    218             char[,] matrix = new char[breite, hoehe];
    219 
    220             for (int i = 1; i <= keyword.Length; i++)
    221             {
    222                 int pos = -1;
    223 
    224                 for (int j = 0; j < keyword.Length; j++)
    225                 {
    226                     if (i == (int)Char.GetNumericValue(keyword[j]))
    227                     {
    228                         pos = j;
    229                     }
    230                 }
    231 
    232 
    233                 if (offs != 0)
    234                 {
    235                     if (pos < offs)
    236                     {
    237                         for (int j = 0; j < hoehe; j++)
    238                         {
    239                             matrix[pos, j] = input[input_pos];
    240                             input_pos++;
    241                         }
    242                     }
    243                     else
    244                     {
    245                         for (int j = 0; j < hoehe - 1; j++)
    246                         {
    247                             matrix[pos, j] = input[input_pos];
    248                             input_pos++;
    249                         }
    250                     }
    251                 }
    252 
     181
     182        private String encrypt()
     183        {
     184            int[] key = get_Keyword_Array(keyword);
     185            if (key != null && input != null)
     186            {
     187                if (is_Valid_Keyword(key))
     188                {
     189                    char[,] matrix = null;
     190
     191                    switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
     192                    {
     193                        case TranspositionSettings.ReadInMode.byRow:
     194                            matrix = enc_read_in_by_row(input, key.Length); break;
     195                        case TranspositionSettings.ReadInMode.byColumn:
     196                            matrix = enc_read_in_by_column(input, key.Length); break;
     197                        default:
     198                            break;
     199                    }
     200
     201                    switch ((TranspositionSettings.PermutationMode)settings.Permutation)
     202                    {
     203                        case TranspositionSettings.PermutationMode.byColumn:
     204                            matrix = enc_permut_by_column(matrix, key); break;
     205
     206                        // Permute by row still to do
     207                        case TranspositionSettings.PermutationMode.byRow:
     208                            matrix = enc_permut_by_column(matrix, key); break;
     209                        default:
     210                            break;
     211                    }
     212
     213                    String encrypted = "";
     214
     215                    switch ((TranspositionSettings.ReadOutMode)settings.ReadOut)
     216                    {
     217                        case TranspositionSettings.ReadOutMode.byRow:
     218                            encrypted = read_out_by_row(matrix, key.Length); break;
     219                        case TranspositionSettings.ReadOutMode.byColumn:
     220                            encrypted = read_out_by_column(matrix, key.Length); break;
     221                        default:
     222                            break;
     223                    }
     224
     225                    return encrypted;
     226                }
    253227                else
    254228                {
    255                     for (int j = 0; j < hoehe; j++)
    256                     {
    257                         matrix[pos, j] = input[input_pos];
    258                         input_pos++;
    259                     }
    260                 }
    261             }
    262             String dec = "";
    263 
    264             // Spaltenweise auslesen
    265             // Read by line
    266             for (int j = 0; j < hoehe; j++)
    267             {
    268                 for (int i = 0; i < breite; i++)
    269                 {
    270                     dec += matrix[i, j];
    271                 }
    272             }
    273             // Ende Spaltenweise auslesen
    274             return dec;
     229                    Transposition_LogMessage("Keyword is not valid", NotificationLevel.Error);
     230                    return "";
     231                }
     232            }
     233            else
     234            {
     235                // 2do: Anzeige "Kein gültiges Keyword
     236                return "";
     237            }
     238        }
     239
     240        private String decrypt()
     241        {
     242            int[] key = get_Keyword_Array(keyword);
     243            if (key != null && input != null)
     244            {
     245                if (is_Valid_Keyword(key))
     246                {
     247                    char[,] matrix = null;
     248
     249                    switch ((TranspositionSettings.ReadOutMode)settings.ReadOut)
     250                    {
     251                        case TranspositionSettings.ReadOutMode.byRow:
     252                            matrix = dec_read_in_by_column(input, key); break;
     253                        case TranspositionSettings.ReadOutMode.byColumn:
     254                            matrix = dec_read_in_by_row(input, key); break;
     255                        default:
     256                            break;
     257                    }
     258
     259                    switch ((TranspositionSettings.PermutationMode)settings.Permutation)
     260                    {
     261                        case TranspositionSettings.PermutationMode.byRow:
     262                            matrix = dec_permut_by_column(matrix, key); break;
     263
     264                        // Permute by row still to do
     265                        case TranspositionSettings.PermutationMode.byColumn:
     266                            matrix = dec_permut_by_column(matrix, key); break;
     267                        default:
     268                            break;
     269                    }
     270
     271                    String decrypted = "";
     272
     273                    switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
     274                    {
     275                        case TranspositionSettings.ReadInMode.byRow:
     276                            decrypted = read_out_by_row(matrix, key.Length); break;
     277                        case TranspositionSettings.ReadInMode.byColumn:
     278                            decrypted = read_out_by_column(matrix, key.Length); break;
     279                        default:
     280                            break;
     281                    }
     282
     283                    return decrypted;
     284                }
     285                else
     286                {
     287                    Transposition_LogMessage("Keyword is not valid", NotificationLevel.Error);
     288                    return "";
     289                }
     290            }
     291            else
     292            {
     293                // 2do: Anzeige "Kein gültiges Keyword
     294                return "";
     295            }
    275296        }
    276297
     
    295316                        matrix[j, i] = input[pos];
    296317                        pos++;
    297                     }                   
     318                    }
    298319                }
    299320            }
     
    357378
    358379                            for (int k = 0; k < offs; k++)
    359                             {                               
    360                                 if((keyword[k]-1).Equals(i))
     380                            {
     381                                if ((keyword[k] - 1).Equals(i))
    361382                                {
    362383                                    ok = true;
     
    440461            int y = readin_matrix.Length / keyword.Length;
    441462
    442             char[,] matrix = new char[x,y];
     463            char[,] matrix = new char[x, y];
    443464
    444465            int pos = 0;
     
    448469                for (int j = 0; j < keyword.Length; j++)
    449470                {
    450                     if(i.Equals(keyword[j]))
     471                    if (i.Equals(keyword[j]))
    451472                    {
    452473                        pos = j;
     
    468489            int y = readin_matrix.Length / keyword.Length;
    469490
    470             char[,] matrix = new char[x,y];
     491            char[,] matrix = new char[x, y];
    471492
    472493            for (int i = 0; i < x; i++)
     
    474495                for (int j = 0; j < y; j++)
    475496                {
    476                     matrix[i, j] = readin_matrix[keyword[i]-1, j];
     497                    matrix[i, j] = readin_matrix[keyword[i] - 1, j];
    477498                }
    478499            }
     
    494515                {
    495516                    char tmp = matrix[j, i];
    496                     if (! tmp.Equals(empty_char))
     517                    if (!tmp.Equals(empty_char))
    497518                    {
    498519                        enc += tmp;
     
    529550        private int[] get_Keyword_Array(String keyword)
    530551        {
    531             int length = keyword.Length/2 + 1;
    532             int[] keys = new int[length];
    533 
    534             for (int i = 0; i < keyword.Length; i = i + 2)
    535             {
    536                 keys[i / 2] = (int)Char.GetNumericValue(keyword[i]);
    537             }
    538 
    539             return keys;
     552            try
     553            {
     554                int length = 1;
     555                char komma = ',';
     556
     557                for (int i = 0; i < keyword.Length; i++)
     558                {
     559                    if (keyword[i].Equals(komma))
     560                    {
     561                        length++;
     562                    }
     563                }
     564
     565                int[] keys = new int[length];
     566
     567                String tmp = "";
     568                int pos = 0;
     569                for (int i = 0; i < keyword.Length; i++)
     570                {
     571                    if (i.Equals(keyword.Length - 1))
     572                    {
     573                        tmp += keyword[i];
     574                        keys[pos] = Convert.ToInt32(tmp);
     575                    }
     576
     577                    else
     578                    {
     579                        if (keyword[i].Equals(komma))
     580                        {
     581                            keys[pos] = Convert.ToInt32(tmp);
     582                            tmp = "";
     583                            pos++;
     584                        }
     585                        else
     586                        {
     587                            tmp += keyword[i];
     588                        }
     589                    }
     590                }
     591
     592                return keys;
     593            }
     594            catch (FormatException)
     595            {
     596                return null;
     597            }
    540598        }
    541599
     
    562620            return true;
    563621        }
    564    
     622
     623        private void Transposition_LogMessage(string msg, NotificationLevel loglevel)
     624        {
     625            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(msg, this, loglevel));
     626
     627        }
     628     
    565629        # endregion
    566630    }
  • trunk/CrypPlugins/Transposition/Transposition.csproj

    r776 r778  
    6464  </ItemGroup>
    6565  <ItemGroup>
    66     <Resource Include="icon.png" />
     66    <Resource Include="Images\icon.png" />
     67  </ItemGroup>
     68  <ItemGroup>
     69    <Resource Include="Images\decrypt.png" />
     70  </ItemGroup>
     71  <ItemGroup>
     72    <Resource Include="Images\encrypt.png" />
    6773  </ItemGroup>
    6874  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  • trunk/CrypPlugins/Transposition/TranspositionSettings.cs

    r776 r778  
    44using System.Text;
    55using Cryptool.PluginBase;
     6using System.ComponentModel;
    67
    78namespace Transposition
    89{
    910    class TranspositionSettings : ISettings
     11    {
     12        # region private variables
    1013
    11     {
    1214        private Boolean hasChanges = false;
     15        private int selectedAction = 0;
     16
     17        private ReadInMode selectedReadIn = ReadInMode.byRow;
     18        private PermutationMode selectedPermutation = PermutationMode.byColumn;
     19        private ReadOutMode selectedReadOut = ReadOutMode.byColumn;
     20       
     21        # endregion
     22
     23        #region public enums
     24
     25        public enum ReadInMode { byRow = 0, byColumn = 1};
     26        public enum PermutationMode { byRow = 0, byColumn = 1 };
     27        public enum ReadOutMode { byRow = 0, byColumn = 1 };
     28
     29        # endregion
    1330
    1431        #region ISettings Member
    1532
     33        [PropertySaveOrder(0)]
    1634        public bool HasChanges
    1735        {
    18             get
    19             {
    20                 return hasChanges;
    21             }
     36            get { return hasChanges; }
     37            set { this.hasChanges = value; }
     38        }
     39
     40        # endregion
     41
     42        # region Settings
     43
     44        [PropertySaveOrder(1)]
     45        [ContextMenu("Action", "Select the Algorithm action", 1, DisplayLevel.Beginner, ContextMenuControlType.ComboBox, new int[] { 1, 2 }, "Encrypt", "Decrypt")]
     46        [TaskPane("Action", "Select the Algorithm action", null, 1, false, DisplayLevel.Beginner, ControlType.ComboBox, new string[] { "Encrypt", "Decrypt" })]
     47        public int Action
     48        {
     49            get { return this.selectedAction; }
    2250            set
    2351            {
    24                 this.hasChanges = value;
     52                if (value != selectedAction) HasChanges = true;
     53                this.selectedAction = value;
     54                OnPropertyChanged("Action");
    2555            }
    2656        }
    2757
     58        [PropertySaveOrder(2)]
     59        [ContextMenu("Read in", "Select read in mode", 2, DisplayLevel.Expert, ContextMenuControlType.ComboBox, null, new string[] { "by row", "by column"})]
     60        [TaskPane("Read in", "Select read in mode", null, 2, false, DisplayLevel.Expert, ControlType.ComboBox, new string[] { "by row", "by column" })]
     61        public int ReadIn
     62        {
     63            get { return (int) this.selectedReadIn; }
     64            set
     65            {
     66                if ((ReadInMode)value != selectedReadIn) HasChanges = true;
     67                this.selectedReadIn = (ReadInMode)value;
     68                OnPropertyChanged("ReadIn");
     69            }
     70        }
     71
     72        [PropertySaveOrder(3)]
     73        [ContextMenu("Permutation", "Select permutation type", 3, DisplayLevel.Expert, ContextMenuControlType.ComboBox, null, new string[] { "by row", "by column" })]
     74        [TaskPane("Permutation", "Select permutation type", null, 3, false,DisplayLevel.Expert, ControlType.ComboBox, new string[] { "by row", "by column" })]
     75        public int Permutation
     76        {
     77            get { return (int)this.selectedPermutation; }
     78            set
     79            {
     80                if ((PermutationMode)value != selectedPermutation) HasChanges = true;
     81                this.selectedPermutation= (PermutationMode)value;
     82                OnPropertyChanged("Permutation");
     83            }
     84        }
     85
     86        [PropertySaveOrder(4)]
     87        [ContextMenu("Read out", "Select read out type", 4, DisplayLevel.Expert, ContextMenuControlType.ComboBox, null, new string[] { "by row", "by column" })]
     88        [TaskPane("Read out", "Select read out type", null, 4, false, DisplayLevel.Expert, ControlType.ComboBox, new string[] { "by row", "by column" })]
     89        public int ReadOut
     90        {
     91            get { return (int)this.selectedReadOut; }
     92            set
     93            {
     94                if ((ReadOutMode)value != selectedReadOut) HasChanges = true;
     95                this.selectedReadOut= (ReadOutMode)value;
     96                OnPropertyChanged("ReadOut");
     97            }
     98        }
     99       
     100        protected void OnPropertyChanged(string name)
     101        {
     102            if (PropertyChanged != null)
     103            {
     104                PropertyChanged(this, new PropertyChangedEventArgs(name));
     105            }
     106        }
    28107        #endregion
    29108
Note: See TracChangeset for help on using the changeset viewer.