Changeset 332


Ignore:
Timestamp:
May 29, 2009, 4:16:01 PM (13 years ago)
Author:
angelov
Message:

Breaks Substitution Cypher. A bit Slow. Could be fixed. Also Buggy. But it works.

Location:
trunk
Files:
1 added
1 edited

Legend:

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

    r325 r332  
    3737    {
    3838        private string stringOutput = "";
    39         private string statisticTextInput;
    40         private string letterFrequencyInput;
    41        
    42        
    43        // private int[] arrayOutput;
    44 
    45         // public static DataSource Data = new DataSource();
     39        private string statisticTextFrequencyInput_Monograms="";
     40        private string statisticTextFrequencyInput_Digrams="";
     41        private string cypherTextFrequencyInput_Monograms="";
     42        private string decypherAttempt_Digrams=""; //After the initial alphabet is proposed and decrypt from substitution plug-in is generated, the result is analysed with Frequencytest concerning digrams and fed back to MonoalphabeticAnalysis as input.
     43        public string GoodAlphabet = null;
     44        public string NextAlphabet = null;
     45        private double alphabetGoodnes = 0;
     46        public int AlphabetCounterA = 1;
     47        public int AlphabetcounterB = 1;
     48       
    4649
    4750
     
    4952        #region Properties (Inputs/Outputs)
    5053
    51         [PropertyInfo(Direction.Input, "Statistic text used for analysis", "Statistic Text Input", "", true, true, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
    52         public string StatisticTextInput
     54        [PropertyInfo(Direction.Input, "StatisticTextFrequencyInput_Monograms", "StatisticTextFrequencyInput_Monograms", "", false, true, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
     55        public string StatisticTextFrequencyInput_Monograms
    5356        {
    5457            get
    5558            {
    56                 return statisticTextInput;
    57             }
    58             set { statisticTextInput = value; OnPropertyChanged("StatisticTextInput"); }
    59         }
    60 
    61 
    62 
    63         [PropertyInfo(Direction.Input, "Letter Frequency From FrequencyTest Plug-in", "Letter Frequency Input", "", true, true, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
    64         public string LetterFrequencyInput
     59                return statisticTextFrequencyInput_Monograms;
     60            }
     61            set { statisticTextFrequencyInput_Monograms = value; OnPropertyChanged("StatisticTextFrequencyInput_Monograms"); }
     62        }
     63
     64
     65        [PropertyInfo(Direction.Input, "StatisticTextFrequencyInput_Digrams", "StatisticTextFrequencyInput_Digrams", "", false, true, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
     66        public string StatisticTextFrequencyInput_Digrams
    6567        {
    6668            get
    6769            {
    68                 return letterFrequencyInput;
    69             }
    70             set { letterFrequencyInput = value; OnPropertyChanged("LetterFrequencyInput"); }
     70                return statisticTextFrequencyInput_Digrams;
     71            }
     72            set { statisticTextFrequencyInput_Digrams = value; OnPropertyChanged("StatisticTextFrequencyInput_Digrams"); }
     73        }
     74
     75
     76        [PropertyInfo(Direction.Input, "CypherTextFrequencyInput_Monograms", "CypherTextFrequencyInput_Monograms", "", true, true, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
     77        public string CypherTextFrequencyInput_Monograms
     78        {
     79            get
     80            {
     81                return cypherTextFrequencyInput_Monograms;
     82            }
     83            set { cypherTextFrequencyInput_Monograms = value; OnPropertyChanged("CypherTextFrequencyInput_Monograms"); }
     84        }
     85
     86        [PropertyInfo(Direction.Input, "DecypherAttempt_Digrams", "DecypherAttempt_Digrams", "", false, true, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
     87        public string DecypherAttempt_Digrams
     88        {
     89            get
     90            {
     91                return decypherAttempt_Digrams;
     92            }
     93            set { decypherAttempt_Digrams = value; OnPropertyChanged("DecypherAttempt_Digrams"); }
    7194        }
    7295
     
    83106            }
    84107        }
     108
     109
     110
     111        [PropertyInfo(Direction.Output, "Alphabet goodness", "Alphabet goodness", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
     112        public string AlphabetGoodness
     113        {
     114            get { return alphabetGoodnes.ToString(); }
     115            set
     116            {
     117                StringOutput = value;
     118                OnPropertyChanged("Alphabetgoodness");
     119
     120            }
     121        }
     122       
     123       
     124       
     125       
    85126        #endregion
     127
     128
    86129
    87130
     
    117160            //throw new NotImplementedException();
    118161        }
    119 
     162       
     163       
     164       
     165        //////////////
     166        //EXECUTE!!!//
     167        //////////////
     168     
    120169        public void Execute()
    121170        {
    122             if (letterFrequencyInput != null)
    123             {
    124 
    125 
    126                 string alphabet = "";
     171           
     172
     173            if (cypherTextFrequencyInput_Monograms != "")
     174            {
     175                   //if Optional Statistical input not used -> use variables from pre-analysed Text (James Clavel's Shogun) 
     176                 if (statisticTextFrequencyInput_Monograms == "") statisticTextFrequencyInput_Monograms = ShogunStatistics.ShogunMonograms;
     177
     178
     179                 if (GoodAlphabet == null)
     180                 {
     181                    //decypherAttempt_Digrams equals null means initial alphabet should be generated
     182                    string alphabet = "";
     183                    ArrayList mapping1 = InitialMapping(cypherTextFrequencyInput_Monograms, statisticTextFrequencyInput_Monograms);
     184
     185                    alphabet = AlphabetFromMapping(mapping1);
     186
     187                    GoodAlphabet = alphabet;
     188                    stringOutput = alphabet;
     189                    OnPropertyChanged("StringOutput");
     190
     191                 }
     192
     193
     194
     195                 if (GoodAlphabet != null && decypherAttempt_Digrams!="")
     196                 {
     197
     198                     double goodness = ReturnAlphabetGoodness();
     199                     if (alphabetGoodnes == 0) //secondpass
     200                     {
     201                         alphabetGoodnes = goodness;
     202                     }
     203                     if (alphabetGoodnes > goodness) //third pass and on if condition applies
     204                     {
     205                         GoodAlphabet = NextAlphabet;
     206                         alphabetGoodnes = goodness;
     207                     }
     208
     209                     string alphabet1 = GenerateNextAlphabet();
     210                     NextAlphabet = alphabet1;
     211                     stringOutput = NextAlphabet;
     212                     OnPropertyChanged("StringOutput");
     213
     214
     215
     216
     217                 }
     218
     219
     220
     221            }
     222
     223           
     224           
    127225               
    128                 ArrayList mapping1 = InitialMapping(LetterFrequencyInput, statisticTextInput);
    129 
    130                 for (int i = 0; i < mapping1.Count; i++)
     226
     227        }
     228
     229
     230
     231        public void PostExecution()
     232        {
     233           
     234            //throw new NotImplementedException();
     235        }
     236
     237        public void Pause()
     238        {
     239            //throw new NotImplementedException();
     240        }
     241
     242        public void Stop()
     243        {
     244            //statisticTextFrequencyInput_Monograms = "";
     245            //OnPropertyChanged("StatisticTextFrequencyInput_Monograms");
     246           // statisticTextFrequencyInput_Digrams = "";
     247            //OnPropertyChanged("StatisticTextFrequencyInput_Digrams");
     248           
     249            //throw new NotImplementedException();
     250        }
     251
     252        public void Initialize()
     253        {
     254            //throw new NotImplementedException();
     255        }
     256
     257        public void Dispose()
     258        {
     259            //throw new NotImplementedException();
     260        }
     261
     262
     263        #endregion
     264
     265        #region INotifyPropertyChanged Members
     266
     267        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
     268
     269        protected void OnPropertyChanged(string name)
     270        {
     271            if (PropertyChanged != null)
     272            {
     273                PropertyChanged(this, new PropertyChangedEventArgs(name));
     274            }
     275        }
     276
     277        #endregion
     278
     279
     280        #region CUSTOM METHODS
     281
     282
     283
     284
     285        //RETURN SORTED LIST//  // The Method returns a sorted list from the FrequenscyTest string output.
     286       
     287        public ArrayList ReturnSortedList(string str,SortElements.SortElemetsBy sort_type)       
     288        {
     289           
     290            str = str.Replace(Environment.NewLine, ":");
     291
     292            char[] splitter = { ':' };
     293
     294           
     295            string[] splitFrequencies = str.Split(splitter);
     296           
     297
     298            ArrayList sortingFrequencyList = new ArrayList();
     299
     300                       
     301                for (int i = 0; i < splitFrequencies.Length - 1; i = i + 3)
    131302                {
    132                     CollectionElement a1 = (CollectionElement)mapping1[i];
    133                     alphabet += a1.Mapping;
    134                 }
    135 
    136                 alphabet=alphabet.ToUpper();
    137 
    138                stringOutput = alphabet;
    139 
    140                              
    141 
    142             }
    143 
    144 
    145         }
    146 
    147 
    148 
    149         public void PostExecution()
    150         {
    151             //throw new NotImplementedException();
    152         }
    153 
    154         public void Pause()
    155         {
    156             //throw new NotImplementedException();
    157         }
    158 
    159         public void Stop()
    160         {
    161             //throw new NotImplementedException();
    162         }
    163 
    164         public void Initialize()
    165         {
    166             //throw new NotImplementedException();
    167         }
    168 
    169         public void Dispose()
    170         {
    171             //throw new NotImplementedException();
    172         }
    173 
    174 
    175         #endregion
    176 
    177         #region INotifyPropertyChanged Members
    178 
    179         public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
    180 
    181         protected void OnPropertyChanged(string name)
    182         {
    183             if (PropertyChanged != null)
    184             {
    185                 PropertyChanged(this, new PropertyChangedEventArgs(name));
    186             }
    187         }
    188 
    189         #endregion
    190 
    191 
    192         #region CUSTOM METHODS
    193 
    194         public ArrayList ReturnSortedList(string str,SortElements.SortElemetsBy sort_type)        // The Method returns a sorted list from the FrequenscyTest string output.
    195         {
    196            
    197             str = str.Replace(Environment.NewLine, ":");
    198 
    199             char[] splitter = { ':' };
    200 
    201            
    202             string[] splitfrequencies = str.Split(splitter);
    203             // splitfrequencies.
    204 
    205             ArrayList sortingfrequencyList = new ArrayList();
    206 
    207                        
    208                 for (int i = 0; i < splitfrequencies.Length - 1; i = i + 3)
    209                 {
    210                     CollectionElement row = new CollectionElement(splitfrequencies[i], System.Convert.ToDouble(splitfrequencies[i + 2]),"");
    211                     sortingfrequencyList.Add(row);
     303                    CollectionElement row = new CollectionElement(splitFrequencies[i], System.Convert.ToDouble(splitFrequencies[i + 2]),"");
     304                    sortingFrequencyList.Add(row);
    212305                }
    213306             
     
    215308
    216309            SortElements mySortingType = new SortElements(sort_type);
    217             sortingfrequencyList.Sort(mySortingType);
    218 
    219             return sortingfrequencyList;
    220         }
    221 
    222 
    223         ArrayList InitialMapping(string cyString, string statString)
    224         {
    225 
     310            sortingFrequencyList.Sort(mySortingType);
     311
     312            return sortingFrequencyList;
     313        }
     314
     315
     316
     317        //INITIAL MAPPING//
     318
     319       public ArrayList InitialMapping(string cyString, string statString)
     320        {
     321            if (statisticTextFrequencyInput_Monograms == "") statisticTextFrequencyInput_Monograms = ShogunStatistics.ShogunMonograms;
    226322            ArrayList cypherTextFrequencies = ReturnSortedList(cyString, SortElements.SortElemetsBy.byFrequency);
    227             ArrayList shogunFrequencies = ReturnSortedList(statString, SortElements.SortElemetsBy.byFrequency);
     323            ArrayList statisticFrequencies = ReturnSortedList(statString, SortElements.SortElemetsBy.byFrequency);
    228324
    229325            ArrayList mappings = new ArrayList();
    230326
    231             if (cypherTextFrequencies.Count == shogunFrequencies.Count)
     327            if (cypherTextFrequencies.Count == statisticFrequencies.Count)
    232328            {
    233329                for (int i = 0; i < cypherTextFrequencies.Count ; i++)
    234330                {
    235331                    CollectionElement a1 = (CollectionElement)cypherTextFrequencies[i];
    236                     CollectionElement a2 = (CollectionElement)shogunFrequencies[i];
     332                    CollectionElement a2 = (CollectionElement)statisticFrequencies[i];
    237333                    double frequencyDifference = Math.Abs(a1.Frequency - a2.Frequency);
    238334                    CollectionElement row = new CollectionElement(a1.Caption, frequencyDifference, a2.Caption);
     
    248344            return mappings;
    249345        }
    250        
     346
     347
     348
     349
     350        //ALPHABET FROM MAPPING//
     351
     352      public string AlphabetFromMapping(ArrayList mapping)
     353        {
     354            string alphabet = "";
     355           
     356            for (int i = 0; i < mapping.Count; i++)
     357            {
     358                CollectionElement a1 = (CollectionElement)mapping[i];
     359                alphabet += a1.Mapping;
     360            }
     361
     362            alphabet = alphabet.ToUpper();
     363           
     364            return alphabet;
     365 
     366        }
     367
     368     
     369       //RETURN ALPHABET GOODNESS// Revision Needed!!!
     370       
     371      public double ReturnAlphabetGoodness()
     372      {
     373          if (statisticTextFrequencyInput_Digrams == "") StatisticTextFrequencyInput_Digrams = ShogunStatistics.ShogunDigrams;//if Optional Statistical input not used -> use variables from pre-analysed Text (James Clavel's Shogun)
     374
     375          double[,] statisticDigramSquare = GetDigramFrequencySquare(StatisticTextFrequencyInput_Digrams);
     376          double[,] decypherAttemptDigrams = GetDigramFrequencySquare(DecypherAttempt_Digrams);
     377         // double[,] digramFrequencyDifferences = new double[GoodAlphabet.Length, GoodAlphabet.Length];
     378          double goodness=new double();
     379
     380
     381          for (int i = 0; i < GoodAlphabet.Length; i++)
     382          {
     383              for (int n = 0; n < GoodAlphabet.Length; n++)
     384              {
     385                  goodness +=Math.Abs( statisticDigramSquare[i, n] - decypherAttemptDigrams[i, n]);
     386              }
     387          }
     388
     389
     390          return goodness;
     391
     392
     393
     394
     395
     396         /* ArrayList statisticList_Digrams = ReturnSortedList(statisticTextFrequencyInput_Digrams, SortElements.SortElemetsBy.byFrequency);
     397
     398          ArrayList decypherAttemptList_Digrams = ReturnSortedList(digramsFrequencies, SortElements.SortElemetsBy.byFrequency);
     399
     400          ArrayList digramFrequencyDifference = statisticList_Digrams;
     401
     402          for (int i = 0; i < decypherAttemptList_Digrams.Count; i++)
     403          {
     404              CollectionElement a1 = (CollectionElement)decypherAttemptList_Digrams[i];
     405              string name1 = a1.Caption;
     406
     407              for (int n = 0; n < statisticList_Digrams.Count; n++)
     408              {
     409                  CollectionElement a2 = (CollectionElement)statisticList_Digrams[n];
     410                  string name2 = a2.Caption;
     411                  if (name1 == name2)
     412                  {
     413                      double difference = a2.Frequency - a1.Frequency;
     414                      CollectionElement row = new CollectionElement(name1, difference, "");
     415                      digramFrequencyDifference[n] = (Object)row;
     416                  }
     417                  if (name1[0] != name2[0]) break;
     418              }
     419
     420
     421          }
     422          double sumOfDigramFrequencyDifferences = 0;
     423
     424          for (int m = 0; m < digramFrequencyDifference.Count; m++)
     425          {
     426              CollectionElement z = (CollectionElement)digramFrequencyDifference[m];
     427              sumOfDigramFrequencyDifferences = sumOfDigramFrequencyDifferences + z.Frequency;
     428          }
     429
     430          return Math.Abs(sumOfDigramFrequencyDifferences); */
     431
     432         /* decypherAttemptList_Digrams.Reverse();
     433          statisticList_Digrams.Reverse();
     434          int hits=0;
     435
     436          //CollectionElement[,] darray = new CollectionElement[GoodAlphabet.Length,GoodAlphabet.Length];
     437          for (int i = 0; i < 30; i++)
     438          {
     439              CollectionElement a1 = (CollectionElement)decypherAttemptList_Digrams[i];
     440              CollectionElement a2 = (CollectionElement)statisticList_Digrams[i];
     441
     442
     443
     444              if (a1.Caption == a2.Caption) hits += GoodAlphabet.Length * GoodAlphabet.Length - i * GoodAlphabet.Length;
     445          }
     446
     447          return hits; */
     448
     449      }
     450
     451
     452       //GENERATE NEXT ALPHABET//
     453
     454      public string GenerateNextAlphabet ()
     455      {
     456          //string alphabet = GoodAlphabet;
     457         
     458          if (AlphabetcounterB != GoodAlphabet.Length)  //TO DO:OTHER WAY TO REALY EXIT
     459          {
     460              char[] alphabet=GoodAlphabet.ToCharArray();
     461
     462              char holder = alphabet[AlphabetCounterA - 1];
     463              alphabet[AlphabetCounterA - 1] = alphabet[AlphabetCounterA + AlphabetcounterB - 1];
     464              alphabet[AlphabetCounterA + AlphabetcounterB - 1] = holder;
     465              AlphabetCounterA++;
     466              if (AlphabetCounterA + AlphabetcounterB > alphabet.Length)
     467              {
     468                  AlphabetCounterA = 1;
     469                  AlphabetcounterB++;
     470              }
     471
     472              string alphabet1=null;
     473              alphabet1 = new string(alphabet);
     474              return alphabet1;
     475          }
     476          else { return GoodAlphabet; } //TO DO: OTHER WAY TO REALY EXIT
     477
     478      }
     479
     480
     481     
     482       
     483        //GET DIGRAM FREQUENCY SQUARE//
     484
     485     
     486       
     487      public double[,] GetDigramFrequencySquare(string digrams)
     488      {
     489          double[,] digramFrequencySquare = new double[GoodAlphabet.Length, GoodAlphabet.Length];
     490          char[] alphabetCharacters = GoodAlphabet.ToCharArray();
     491          ArrayList digramfrequencyList = ReturnSortedList(digrams,SortElements.SortElemetsBy.byString);
     492         
     493         
     494          Array.Sort(alphabetCharacters);
     495
     496          foreach (CollectionElement item in digramfrequencyList)
     497          {
     498              int firstLetterIndex = Array.IndexOf(alphabetCharacters,item.Caption.ToUpper()[0]);
     499              int secondLetterIndex = Array.IndexOf(alphabetCharacters, item.Caption.ToUpper()[1]);
     500              digramFrequencySquare[firstLetterIndex,secondLetterIndex]=item.Frequency;     
     501             
     502          }
     503
     504
     505          return digramFrequencySquare;
     506                 
     507      }
     508
     509
    251510        #endregion CUSTOM METHODS
    252511
Note: See TracChangeset for help on using the changeset viewer.