Changeset 1365


Ignore:
Timestamp:
Apr 26, 2010, 10:45:53 PM (12 years ago)
Author:
kohnen
Message:

added genetic analysis to transposition analyser

Location:
trunk
Files:
1 added
2 edited

Legend:

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

    r1284 r1365  
    1919
    2020    [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")]
    21     [PluginInfo(false, "Transposition Analyser", "Bruteforces the columnar transposition.", "TranspositionAnalyser/Description/TADescr.xaml" , "TranspositionAnalyser/Images/icon.png")]
     21    [PluginInfo(false, "Transposition Analyser", "Bruteforces the columnar transposition.", "TranspositionAnalyser/Description/TADescr.xaml", "TranspositionAnalyser/Images/icon.png")]
    2222    public class TranspositionAnalyser : IAnalysisMisc
    2323    {
     
    3030        LinkedList<ValueKey> list1;
    3131        private TranspositionAnalyserQuickWatchPresentation myPresentation;
     32        private Random rd;
    3233
    3334        TranspositionAnalyserSettings settings;
     
    4546                this.input = value;
    4647                OnPropertyChange("Input");
    47                
     48
    4849            }
    4950        }
     
    7778            myPresentation.doppelClick += new EventHandler(this.doppelClick);
    7879        }
    79        
     80
    8081        private void doppelClick(object sender, EventArgs e)
    8182        {
     
    8687
    8788        private IControlEncryption controlMaster;
    88         [PropertyInfo(Direction.ControlMaster, "Control Master", "Used for bruteforcing", "", false, false, DisplayLevel.Beginner,QuickWatchFormat.None,null)]
     89        [PropertyInfo(Direction.ControlMaster, "Control Master", "Used for bruteforcing", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.None, null)]
    8990        public IControlEncryption ControlMaster
    9091        {
    91            
     92
    9293            get { return controlMaster; }
    9394            set
    9495            {
    95                // value.OnStatusChanged += onStatusChanged;
     96                // value.OnStatusChanged += onStatusChanged;
    9697                controlMaster = value;
    9798                OnPropertyChanged("ControlMaster");
    98                
     99
    99100            }
    100101        }
     
    160161        public void PreExecution()
    161162        {
    162            
     163
    163164        }
    164165
    165166        public void Execute()
    166167        {
    167            
     168
    168169
    169170            if (this.input != null)
     
    197198        public void Initialize()
    198199        {
    199             this.settings.Analysis_method = 0;           
     200            this.settings.Analysis_method = 0;
    200201        }
    201202
     
    207208        private void onStatusChanged(IControl sender, bool readyForExecution)
    208209        {
    209            
     210
    210211        }
    211212
     
    231232                    case 0: Output = costfunction_bruteforce(sender); GuiLogMessage("Starting Brute-Force Analysis", NotificationLevel.Info); break;
    232233                    case 1: GuiLogMessage("Starting Analysis with crib", NotificationLevel.Info); cribAnalysis(this.crib, this.input); break;
    233 
     234                    case 2: GuiLogMessage("Starting genetic analysis", NotificationLevel.Info); geneticAnalysis(sender); break;
    234235                }
    235236            }
     
    238239                GuiLogMessage("No Input!", NotificationLevel.Error);
    239240            }
    240            
    241            
     241
     242
    242243        }
    243244
     
    294295                GuiLogMessage("start", NotificationLevel.Info);
    295296                double best = Double.MinValue;
    296                
     297
    297298                if (costMaster.getRelationOperator() == RelationOperator.LessThen)
    298299                {
     
    304305                ArrayList list = null;
    305306
    306 
     307               
    307308                //Just for fractional-calculation:
    308309                PermutationGenerator per = new PermutationGenerator(2);
     
    366367                                {
    367368                                    double val = costMaster.calculateCost(dec);
    368                                     if(val.Equals(new Double()))
     369                                    if (val.Equals(new Double()))
    369370                                    {
    370                                      return new byte[0];   
     371                                        return new byte[0];
    371372                                    }
    372373                                    if (costMaster.getRelationOperator() == RelationOperator.LessThen)
     
    378379                                            foreach (int xyz in key)
    379380                                            {
    380                                                 keyStr += xyz;
     381                                                keyStr += xyz +", ";
    381382                                            }
    382383                                            valkey.decryption = dec;
     
    400401                                            valkey.value = val;
    401402                                            valuequeue.Enqueue(valkey);
    402                                            
    403403                                        }
    404404                                    }
     
    407407                                sum++;
    408408                                if (DateTime.Now >= lastUpdate.AddMilliseconds(1000))
    409                                 {   updateToplist(list1);
     409                                {
     410                                    updateToplist(list1);
    410411                                    showProgress(starttime, size, sum);
    411412                                    ProgressChanged(sum, size);
     
    420421                        foreach (string tmp in list)
    421422                        {
    422                             GuiLogMessage("ENDE (" + i++ + ")" + best + ": " + tmp,NotificationLevel.Info);
     423                            GuiLogMessage("ENDE (" + i++ + ")" + best + ": " + tmp, NotificationLevel.Info);
    423424                        }
    424425                    }
     
    479480                                    Output = vk.decryption;
    480481                                }
    481                                // value_threshold = costList.Last.Value.value;
     482                                // value_threshold = costList.Last.Value.value;
    482483                                break;
    483484                            }
     
    504505                                }
    505506
    506                                // value_threshold = costList.Last.Value.value;
     507                                // value_threshold = costList.Last.Value.value;
    507508                                break;
    508509                            }
     
    531532            }
    532533        }
    533        
     534
    534535        #region cribAnalysis
    535         public void cribAnalysis(byte[] crib, byte[] cipher) 
     536        public void cribAnalysis(byte[] crib, byte[] cipher)
    536537        {
    537538
     
    543544                }
    544545            }
    545             else { GuiLogMessage("Missing crib or input!",NotificationLevel.Info); }
     546            else { GuiLogMessage("Missing crib or input!", NotificationLevel.Info); }
    546547        }
    547548
    548549        #endregion
    549550
    550         #region 
     551        #region
    551552
    552553        public ArrayList getKeyLength(byte[] crib, byte[] cipher)
    553554        {
    554            
     555
    555556            ArrayList keylengths = new ArrayList();
    556557
     
    563564                for (int j = 0; j < analysed.Length; j++)
    564565                {
    565                    
     566
    566567                    if (analysed[j] != 0)
    567568                    {
     
    573574                    else break;
    574575                }
    575                
     576
    576577            }
    577578            return keylengths;
    578            
     579
    579580        }
    580581
     
    687688                                            poscount[x]++;
    688689                                            def[x].Add(b);
    689                                            
     690
    690691                                        }
    691692                                    }
     
    704705
    705706        #endregion
    706        
    707         //hier entsteht eine QUICKWATCH
     707
    708708        private void showProgress(DateTime startTime, long size, long sum)
    709709        {
     
    723723
    724724                long keystodo = (size - sum);
     725               
    725726                long secstodo = keystodo / keysPerSec;
    726                
     727
    727728                //dummy Time
    728                 DateTime endTime = new DateTime(1970,1,1);
     729                DateTime endTime = new DateTime(1970, 1, 1);
    729730                try
    730731                {
     
    742743                    ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).keysPerSecond.Text = "" + keysPerSec;
    743744
    744                     if (endTime != (new DateTime(1970,1,1)))
     745                    if (endTime != (new DateTime(1970, 1, 1)))
    745746                    {
    746747                        ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).timeLeft.Text = "" + endTime.Subtract(DateTime.Now);
     
    754755                        ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).endTime.Text = "in a galaxy far, far away...";
    755756                    }
    756                     linkedListNode = list1.First;
    757                     ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).entries.Clear();
    758                     int i = 0;
    759                     while (linkedListNode != null)
    760                     {
    761                         i++;
    762                         ResultEntry entry = new ResultEntry();
    763                         entry.Ranking =  i.ToString();
    764 
    765 
    766                         String dec = System.Text.Encoding.ASCII.GetString(linkedListNode.Value.decryption);
    767                         if (dec.Length > 2500) // Short strings need not to be cut off
    768                         {
    769                             dec = dec.Substring(0, 2500) ;
    770                         }
    771                         entry.Text = dec;
    772                         entry.Key = linkedListNode.Value.key;
    773                         entry.Value = Math.Round(linkedListNode.Value.value,2)+"";
    774                        
    775 
    776                         ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).entries.Add(entry);
    777                        
    778                         linkedListNode = linkedListNode.Next;
    779                     }
    780                
     757                    if (list1 != null)
     758                    {
     759                        linkedListNode = list1.First;
     760                        ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).entries.Clear();
     761                        int i = 0;
     762                        while (linkedListNode != null)
     763                        {
     764                            i++;
     765                            ResultEntry entry = new ResultEntry();
     766                            entry.Ranking = i.ToString();
     767
     768
     769                            String dec = System.Text.Encoding.ASCII.GetString(linkedListNode.Value.decryption);
     770                            if (dec.Length > 2500) // Short strings need not to be cut off
     771                            {
     772                                dec = dec.Substring(0, 2500);
     773                            }
     774                            entry.Text = dec;
     775                            entry.Key = linkedListNode.Value.key;
     776                            entry.Value = Math.Round(linkedListNode.Value.value, 2) + "";
     777
     778
     779                            ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).entries.Add(entry);
     780
     781                            linkedListNode = linkedListNode.Next;
     782                        }
     783
     784                    }
    781785                }
    782786
    783787
    784788                , null);
    785                
    786             }
    787         }
    788    
     789
     790            }
     791        }
     792
     793        private void geneticAnalysis(IControlEncryption sender)
     794        {
     795            stop = false;
     796
     797            valuequeue = Queue.Synchronized(new Queue());
     798           
     799            int size = settings.Iterations;
     800            int keylength = settings.KeySize;
     801            int repeatings = settings.Repeatings;
     802
     803            if (size < 2 || keylength < 2 || repeatings <1)
     804            {
     805                GuiLogMessage("Check keylength and iterations", NotificationLevel.Error);
     806                return;
     807            }
     808
     809            if (sender == null || costMaster == null || input == null)
     810            {
     811                if (sender == null)
     812                {
     813                    GuiLogMessage("sender == null", NotificationLevel.Error);
     814                }
     815                if (costMaster == null)
     816                {
     817                    GuiLogMessage("costMaster == null", NotificationLevel.Error);
     818                }
     819                if (input == null)
     820                {
     821                    GuiLogMessage("input == null", NotificationLevel.Error);
     822                }
     823                return;
     824            }
     825            DateTime startTime = DateTime.Now;
     826            DateTime lastUpdate = DateTime.Now;
     827
     828            ArrayList bestOf = null;
     829
     830            for (int it = 0; it < repeatings; it++)
     831            {
     832
     833                ArrayList valList = new ArrayList();
     834
     835                for (int i = 0; i < 12; i++)
     836                {
     837                    byte[] rndkey = randomArray(keylength);
     838                    byte[] dec = sender.Decrypt(input, rndkey, null);
     839                    double val = costMaster.calculateCost(dec);
     840
     841                    String keyStr = "";
     842                    foreach (byte tmp in rndkey)
     843                    {
     844                        keyStr += tmp + ", ";
     845                    }
     846
     847
     848                    ValueKey v = new ValueKey();
     849                    v.decryption = dec;
     850                    v.key = keyStr;
     851                    v.keyArray = rndkey;
     852                    v.value = val;
     853                    valList.Add(v);
     854                }
     855
     856                valuequeue = Queue.Synchronized(new Queue());
     857
     858
     859                int iteration = 0;
     860                while (iteration < size && !stop)
     861                {
     862                    //Dummy ValueKey erstellen:
     863                    ValueKey highest = new ValueKey();
     864
     865                    // Schlechtesten 6 Keys löschen
     866                    if (costMaster.getRelationOperator() == RelationOperator.LessThen)
     867                    {
     868                        for (int a = 0; a < 6; a++)
     869                        {
     870                            highest.value = int.MinValue;
     871                            int pos = -1;
     872                            for (int b = 0; b < valList.Count; b++)
     873                            {
     874                                ValueKey v = (ValueKey)valList[b];
     875                                if (v.value > highest.value)
     876                                {
     877                                    highest = v;
     878                                    pos = b;
     879                                }
     880                            }
     881                            if (pos != -1)
     882                            {
     883                                valList.RemoveAt(pos);
     884                            }
     885                        }
     886                    }
     887                    //costmMaster Relation Operator == Larger Than
     888                    else
     889                    {
     890                        for (int a = 0; a < 6; a++)
     891                        {
     892                            highest.value = int.MaxValue;
     893                            int pos = -1;
     894                            for (int b = 0; b < valList.Count; b++)
     895                            {
     896                                ValueKey v = (ValueKey)valList[b];
     897                                if (v.value < highest.value)
     898                                {
     899                                    highest = v;
     900                                    pos = b;
     901                                }
     902                            }
     903                            if (pos != -1)
     904                            {
     905                                valList.RemoveAt(pos);
     906                            }
     907                        }
     908                    }
     909
     910                    //valListe sortieren
     911                    ArrayList tmpList = new ArrayList(6);
     912
     913                    double best = Double.MinValue;
     914                    int bestpos = -1;
     915                    for (int a = 0; a < 6; a++)
     916                    {
     917                        best = Double.MinValue;
     918                        bestpos = -1;
     919
     920                        for (int b = 0; b < valList.Count; b++)
     921                        {
     922                            ValueKey v = (ValueKey)valList[b];
     923
     924                            if (best == Double.MinValue)
     925                            {
     926                                best = v.value;
     927                                bestpos = b;
     928                            }
     929
     930                            if (costMaster.getRelationOperator() == RelationOperator.LessThen)
     931                            {
     932                                if (v.value < best)
     933                                {
     934                                    best = v.value;
     935                                    bestpos = b;
     936                                }
     937                            }
     938                            else
     939                            {
     940                                if (v.value > best)
     941                                {
     942                                    best = v.value;
     943                                    bestpos = b;
     944                                }
     945                            }
     946                        }
     947                        tmpList.Add(valList[bestpos]);
     948                        valList.RemoveAt(bestpos);
     949
     950                    }
     951
     952                    valList = tmpList;
     953
     954
     955                    // Kinder der besten Keys erstellen
     956                    int rndInt = 0;
     957
     958                    int listSize = valList.Count;
     959                    for (int a = 0; a < 6; a++)
     960                    {
     961                        if (a % 2 == 0)
     962                        {
     963                            rndInt = (rd.Next(0, int.MaxValue)) % (keylength);
     964                            while (rndInt == 0)
     965                            {
     966                                rndInt = (rd.Next(0, int.MaxValue)) % (keylength);
     967                            }
     968                        }
     969
     970                        ValueKey parent1 = (ValueKey)valList[a];
     971                        byte[] child = new byte[parent1.keyArray.Length];
     972                        for (int b = 0; b < rndInt; b++)
     973                        {
     974                            child[b] = parent1.keyArray[b];
     975                        }
     976
     977                        int pos = rndInt;
     978                        if (a % 2 == 0)
     979                        {
     980                            ValueKey parent2 = (ValueKey)valList[a + 1];
     981                            for (int b = 0; b < parent2.keyArray.Length; b++)
     982                            {
     983                                for (int c = rndInt; c < parent1.keyArray.Length; c++)
     984                                {
     985                                    if (parent1.keyArray[c] == parent2.keyArray[b])
     986                                    {
     987                                        child[pos] = parent1.keyArray[c];
     988                                        pos++;
     989                                        break;
     990                                    }
     991                                }
     992                            }
     993                        }
     994                        else
     995                        {
     996                            ValueKey parent2 = (ValueKey)valList[a - 1];
     997                            for (int b = 0; b < parent2.keyArray.Length; b++)
     998                            {
     999                                for (int c = rndInt; c < parent1.keyArray.Length; c++)
     1000                                {
     1001                                    if (parent1.keyArray[c] == parent2.keyArray[b])
     1002                                    {
     1003                                        child[pos] = parent1.keyArray[c];
     1004                                        pos++;
     1005                                        break;
     1006                                    }
     1007                                }
     1008                            }
     1009                        }
     1010                        int apos = (rd.Next(0, int.MaxValue)) % keylength;
     1011                        int bpos = (rd.Next(0, int.MaxValue)) % keylength;
     1012                        while (apos == bpos)
     1013                        {
     1014                            apos = (rd.Next(0, int.MaxValue)) % keylength;
     1015                            bpos = (rd.Next(0, int.MaxValue)) % keylength;
     1016                        }
     1017                        byte tmp = child[apos];
     1018                        child[apos] = child[bpos];
     1019                        child[bpos] = tmp;
     1020
     1021                        Boolean eq = false;
     1022                        foreach (ValueKey v in valList)
     1023                        {
     1024
     1025                            if (arrayEquals(v.keyArray, child))
     1026                            {
     1027                                //GuiLogMessage("ZWEI GLEICHE", NotificationLevel.Debug);
     1028                                ValueKey tmpValue = new ValueKey();
     1029                                tmpValue.keyArray = randomArray(keylength);
     1030                                byte[] dec = sender.Decrypt(input, tmpValue.keyArray, null);
     1031                                double val = costMaster.calculateCost(dec);
     1032
     1033                                String keyStr = "";
     1034                                foreach (byte bb in child)
     1035                                {
     1036                                    keyStr += bb + ", ";
     1037                                }
     1038
     1039                                tmpValue.decryption = dec;
     1040                                tmpValue.key = keyStr;
     1041                                tmpValue.value = val;
     1042                                valList.Add(tmpValue);
     1043                                eq = true;
     1044                                break;
     1045                            }
     1046                        }
     1047                        if (!eq && bestOf != null)
     1048                        {
     1049                            foreach (ValueKey v in bestOf)
     1050                            {
     1051
     1052                                if (arrayEquals(v.keyArray, child))
     1053                                {
     1054                                    //GuiLogMessage("ZWEI GLEICHE", NotificationLevel.Debug);
     1055                                    ValueKey tmpValue = new ValueKey();
     1056                                    tmpValue.keyArray = randomArray(keylength);
     1057                                    byte[] dec = sender.Decrypt(input, tmpValue.keyArray, null);
     1058                                    double val = costMaster.calculateCost(dec);
     1059
     1060                                    String keyStr = "";
     1061                                    foreach (byte bb in child)
     1062                                    {
     1063                                        keyStr += bb + ", ";
     1064                                    }
     1065
     1066                                    tmpValue.decryption = dec;
     1067                                    tmpValue.key = keyStr;
     1068                                    tmpValue.value = val;
     1069                                    valList.Add(tmpValue);
     1070                                    eq = true;
     1071                                    break;
     1072                                }
     1073                            }
     1074                        }
     1075                        if (!eq)
     1076                        {
     1077                            ValueKey tmpValue = new ValueKey();
     1078                            byte[] dec = sender.Decrypt(input, child, null);
     1079                            double val = costMaster.calculateCost(dec);
     1080
     1081                            String keyStr = "";
     1082                            foreach (byte bb in child)
     1083                            {
     1084                                keyStr += bb + ", ";
     1085                            }
     1086
     1087                            tmpValue.keyArray = child;
     1088                            tmpValue.decryption = dec;
     1089                            tmpValue.key = keyStr;
     1090                            tmpValue.value = val;
     1091                            valList.Add(tmpValue);
     1092                        }
     1093                    }
     1094
     1095                    if (DateTime.Now >= lastUpdate.AddMilliseconds(1000))
     1096                    {
     1097                        best = Double.MinValue;
     1098
     1099                        if (costMaster.getRelationOperator() == RelationOperator.LessThen)
     1100                        {
     1101                            best = Double.MaxValue;
     1102                        }
     1103
     1104                        list1 = getDummyLinkedList(best);
     1105
     1106                        if (bestOf != null)
     1107                        {
     1108                            foreach (ValueKey v in bestOf)
     1109                            {
     1110                                valuequeue.Enqueue(v);
     1111                            }
     1112                        }
     1113
     1114                        foreach (ValueKey v in valList)
     1115                        {
     1116                            valuequeue.Enqueue(v);
     1117                        }
     1118                        updateToplist(list1);
     1119                        showProgress(startTime, size * repeatings, it * size + iteration);
     1120                        ProgressChanged(it*size+ iteration, size*repeatings);
     1121                        lastUpdate = DateTime.Now;
     1122                    }
     1123                    iteration++;
     1124                }
     1125                foreach (ValueKey v in valList)
     1126                {
     1127                    if (bestOf == null)
     1128                        bestOf = new ArrayList();
     1129                    bestOf.Add(v);
     1130                }
     1131            }
     1132        }
     1133
     1134        private byte[] randomArray(int length)
     1135        {
     1136            int[] src = new int[length];
     1137            for (int i = 0; i < length; i++)
     1138            {
     1139                src[i] = i + 1;
     1140            }
     1141            if (src == null)
     1142            {
     1143                return null;
     1144            }
     1145
     1146            int[] tmp = new int[src.Length];
     1147
     1148            int num = src.Length;
     1149            int index;
     1150
     1151            if (rd == null) rd = new Random(System.DateTime.Now.Millisecond);
     1152
     1153            for (int i = 0; i < src.Length; i++)
     1154            {
     1155                index = (rd.Next(0, int.MaxValue)) % num;
     1156                tmp[i] = src[index];
     1157                src[index] = src[num - 1];
     1158                num--;
     1159            }
     1160
     1161            byte[] output = new byte[length];
     1162            for (int i = 0; i < output.Length; i++)
     1163            {
     1164                output[i] = Convert.ToByte(tmp[i]);
     1165            }
     1166            return output;
     1167        }
     1168
     1169        private Boolean arrayEquals(byte[] a, byte[] b)
     1170        {
     1171            if (a.Length != b.Length)
     1172                return false;
     1173            for (int i = 0; i < a.Length; i++)
     1174            {
     1175                if (a[i] != b[i]) return false;
     1176            }
     1177            return true;
     1178        }
     1179
     1180
    7891181    }
    7901182
    7911183    public struct ValueKey
    7921184    {
     1185        public byte[] keyArray;
    7931186        public double value;
    7941187        public String key;
  • trunk/CrypPlugins/TranspositionAnalyser/TranspositionAnalyserSettings.cs

    r1121 r1365  
    3030                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("ColumnColumnRow", Visibility.Visible)));
    3131                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("ColumnColumnColumn", Visibility.Visible)));
     32                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("KeySize", Visibility.Hidden)));
     33                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("Repeatings", Visibility.Hidden)));
     34                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("Iterations", Visibility.Hidden)));
    3235                        break;
    3336                case 1: TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("MaxLength", Visibility.Hidden)));
     
    3639                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("ColumnColumnRow", Visibility.Hidden)));
    3740                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("ColumnColumnColumn", Visibility.Hidden)));
     41                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("KeySize", Visibility.Hidden)));
     42                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("Repeatings", Visibility.Hidden)));
     43                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("Iterations", Visibility.Hidden)));
    3844                        break;
     45                case 2: TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("MaxLength", Visibility.Hidden)));
     46                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("RowColumnColumn", Visibility.Hidden)));
     47                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("RowColumnRow", Visibility.Hidden)));
     48                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("ColumnColumnRow", Visibility.Hidden)));
     49                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("ColumnColumnColumn", Visibility.Hidden)));
     50                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("KeySize", Visibility.Visible)));
     51                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("Repeatings", Visibility.Visible)));
     52                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("Iterations", Visibility.Visible)));
     53                        break;
    3954            }
    4055        }
    4156        //[PropertySaveOrder(1)]
    42         [TaskPane("Analysis Method", "Select the Analysis Method", null, 1, false, DisplayLevel.Beginner, ControlType.ComboBox, new string[] { "Bruteforce Analysis", "Analysis with Crib" })]
     57        [TaskPane("Analysis Method", "Select the Analysis Method", null, 1, false, DisplayLevel.Beginner, ControlType.ComboBox, new string[] { "Bruteforce Analysis", "Analysis with Crib", "Genetic algorithm" })]
    4358        public int Analysis_method
    4459        {
     
    5974
    6075        // FIX: REGEX
    61         private int bruteforce_length = 8;
     76        private int bruteforce_length = 12;
    6277        [PropertySaveOrder(2)]
    6378        [TaskPaneAttribute("Transposition Bruteforce length", "Enter the max length to be bruteforced (max: 20)", null, 2, true, DisplayLevel.Beginner, ControlType.TextBox, ValidationType.RegEx, "[0-9]{1,2}")]
     
    7287        }
    7388
     89        private int keysize = 8;
     90        [PropertySaveOrder(3)]
     91        [TaskPaneAttribute("Keysize for genetic analysis.", "Enter the keysize to be searched", null, 2, true, DisplayLevel.Beginner, ControlType.TextBox, ValidationType.RegEx, "[0-9]{1,2}")]
     92        public int KeySize
     93        {
     94            get { return keysize; }
     95            set
     96            {
     97                keysize = value;
     98
     99            }
     100        }
     101
    74102        private Boolean row_colum_column = true;
    75         [PropertySaveOrder(3)]
     103        [PropertySaveOrder(4)]
    76104        [ContextMenu("R-C-C", "Bruteforce this transposition settings: Read in by row. Permute by column. Read out by Column", 4, DisplayLevel.Beginner, ContextMenuControlType.CheckBox, null, "Row-Column-Column")]
    77105        [TaskPane("R-C-C", "Bruteforce this transposition settings: Read in by row. Permute by column. Read out by Column", null, 4, false, DisplayLevel.Expert, ControlType.CheckBox, "")]
     
    88116
    89117        private Boolean row_colum_row = true;
    90         [PropertySaveOrder(4)]
     118        [PropertySaveOrder(5)]
    91119        [ContextMenu("R-C-R", "Bruteforce this transposition settings: Read in by row. Permute by column. Read out by Row", 4, DisplayLevel.Beginner, ContextMenuControlType.CheckBox, null, "Row-Column-Column")]
    92120        [TaskPane("R-C-R", "Bruteforce this transposition settings: Read in by row. Permute by column. Read out by Row", null, 4, false, DisplayLevel.Expert, ControlType.CheckBox, "")]
     
    104132
    105133        private Boolean column_colum_row = true;
    106         [PropertySaveOrder(5)]
     134        [PropertySaveOrder(6)]
    107135        [ContextMenu("C-C-R", "Bruteforce this transposition settings: Read in by column. Permute by column. Read out by Row", 4, DisplayLevel.Beginner, ContextMenuControlType.CheckBox, null, "Row-Column-Column")]
    108136        [TaskPane("C-C-R", "Bruteforce this transposition settings: Read in by column. Permute by column. Read out by Row", null, 4, false, DisplayLevel.Expert, ControlType.CheckBox, "")]
     
    119147
    120148        private Boolean column_colum_column = true;
    121         [PropertySaveOrder(6)]
     149        [PropertySaveOrder(7)]
    122150        [ContextMenu("C-C-C", "Bruteforce this transposition settings: Read in by column. Permute by column. Read out by column", 4, DisplayLevel.Beginner, ContextMenuControlType.CheckBox, null, "Row-Column-Column")]
    123151        [TaskPane("C-C-C", "Bruteforce this transposition settings: Read in by column. Permute by column. Read out by column", null, 4, false, DisplayLevel.Expert, ControlType.CheckBox, "")]
     
    133161        }
    134162
    135      
     163        private int repeatings = 10;
     164        [PropertySaveOrder(8)]
     165        [TaskPaneAttribute("Numbers of repeatings for genetic analysis.", "Enter the maximum number of repeations of iterations for genetic analysis.", null, 2, true, DisplayLevel.Beginner, ControlType.TextBox, ValidationType.RegEx, "[0-9]{1,2}")]
     166        public int Repeatings
     167        {
     168            get { return repeatings; }
     169            set
     170            {
     171                if (value != this.repeatings) HasChanges = true;
     172                repeatings= value;
     173                OnPropertyChanged("Repeatings");
     174            }
     175        }
     176
     177        private int iterations = 5000;
     178        [PropertySaveOrder(9)]
     179        [TaskPaneAttribute("Numbers of iterations for genetic analysis.", "Enter the maximum number of iterations for genetic analysis.", null, 2, true, DisplayLevel.Beginner, ControlType.TextBox, ValidationType.RegEx, "[0-9]{1,2}")]
     180        public int Iterations
     181        {
     182            get { return iterations; }
     183            set
     184            {
     185                if (value != this.iterations) HasChanges = true;
     186                iterations = value;
     187                OnPropertyChanged("Iterations");
     188            }
     189        }
     190
    136191
    137192        public bool HasChanges
Note: See TracChangeset for help on using the changeset viewer.