Changeset 859


Ignore:
Timestamp:
Nov 17, 2009, 12:10:10 PM (12 years ago)
Author:
kohnen
Message:
  • Transposition Analyser (Beta) added (+ Sample)
  • Costfunction updated

-

Location:
trunk
Files:
9 added
4 edited

Legend:

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

    r852 r859  
    4040        private IControlCost controlSlave;
    4141        private String bigramInput;
    42                
     42        private double[,] bigramMatrix;
     43        private IDictionary<string, double[]> corpusGrams;
    4344
    4445
     
    195196                        this.Value = calculateNGrams(bigramInput,2,1);
    196197                        break;
     198                    case 5: // alternative Bigram
     199                        this.Value = relativeBigramFrequency(bigramInput);
     200                        break;
    197201                    default:
    198202                        this.Value = -1;
     
    206210           
    207211        }//end Execute
    208 
     212       
     213       
    209214        public void PostExecution()
    210215        {
     
    375380            this.statistics = new Dictionary<int, IDictionary<string, double[]>>();
    376381            double score = 0;
    377             IDictionary<string, double[]> corpusGrams = GetStatistics(length);
     382            if (corpusGrams == null)
     383            { corpusGrams = GetStatistics(length); }
    378384            input = input.ToUpper();
    379385            // FIXME: case handling?
     
    402408            if (!statistics.ContainsKey(gramLength))
    403409            {
    404                 GuiLogMessage("Trying to load default statistics for " + gramLength + "-grams", NotificationLevel.Info);
     410                //GuiLogMessage("Trying to load default statistics for " + gramLength + "-grams", NotificationLevel.Info);
    405411                statistics[gramLength] = LoadDefaultStatistics(gramLength);               
    406412            }
     
    409415        }
    410416
     417
     418        public double relativeBigramFrequency(string input)
     419        {
     420            string text = input.ToUpper();
     421            if (bigramMatrix == null)
     422            {
     423                bigramMatrix = getBiGramMatrix();
     424            }
     425            double sum = 0.0;
     426            double count = 0.0;
     427
     428            for (int i = 0; i < input.Length - 1; i++)
     429            {
     430                char a = text[i];
     431                char b = text[i + 1];
     432
     433                if (isInAlphabet(a) && isInAlphabet(b))
     434                {
     435                    int x = (int)a - 65;
     436                    int y = (int)b - 65;
     437                    sum += bigramMatrix[x, y];
     438                    count++;
     439                }
     440            }
     441            return (sum/count);
     442        }
     443
     444        private double[,] getBiGramMatrix()
     445        {
     446            double[,] matrix = new double[26, 26];
     447            StreamReader reader = new StreamReader(Path.Combine(PluginResource.directoryPath, "CostFunctionDeutsch.txt"));
     448           
     449                   
     450            String text;
     451
     452            while ((text = reader.ReadLine()) != null)
     453            {
     454                text = text.ToUpper();
     455                for (int i = 0; i < text.Length - 1; i++)
     456                {
     457                    char a = text[i];
     458                    char b = text[i + 1];
     459
     460                    if (isInAlphabet(a) && isInAlphabet(b))
     461                    {
     462                        int x = (int)a - 65;
     463                        int y = (int)b - 65;
     464                        matrix[x, y] = matrix[x, y] + 1;
     465                    }
     466                }
     467
     468            }
     469
     470            for (int i = 0; i < 26; i++)
     471            {
     472                double count = 0;
     473                for (int j = 0; j < 26; j++)
     474                {
     475                    count = count + matrix[i, j];
     476
     477                }
     478
     479                for (int j = 0; j < 26; j++)
     480                {
     481                    matrix[i, j] = matrix[i, j] / (count / 100);
     482                }
     483            }
     484            return matrix;
     485        }
     486
     487        private bool isInAlphabet(char c)
     488        {
     489            int val = (int)(c);
     490            int test = val - 65;
     491            if (test >= 0 && test <= 25)
     492            {
     493                return true;
     494            }
     495            return false;
     496        }
    411497
    412498        private IDictionary<string, double[]> LoadDefaultStatistics(int length)
     
    431517
    432518            double sum = grams.Values.Sum(item => item[ABSOLUTE]);
    433             GuiLogMessage("Sum of all n-gram counts is: " + sum, NotificationLevel.Debug);
     519            //GuiLogMessage("Sum of all n-gram counts is: " + sum, NotificationLevel.Debug);
    434520
    435521            // calculate scaled values
     
    516602                    return RelationOperator.LessThen;
    517603                case 2: // Bigrams: log 2
     604                    return RelationOperator.LessThen;
     605                case 3: // Sinkov
     606                    return RelationOperator.LargerThen;
     607                case 4: // percentage
     608                    return RelationOperator.LargerThen;
     609                case 5: // alternative bigrams
    518610                    return RelationOperator.LargerThen;
    519611                default:
     
    556648                case 4: // Bigrams: Percentaged
    557649                    return plugin.calculateNGrams(plugin.ByteArrayToString(text), 2, 1);
     650                case 5: // alternative Bigram
     651                    return plugin.relativeBigramFrequency(plugin.ByteArrayToString(text));
     652
    558653                default:
    559654                    throw new NotImplementedException("The value " + ((CostFunctionSettings)this.plugin.Settings).FunctionType + " is not implemented.");
  • trunk/CrypPlugins/CostFunction/CostFunction.csproj

    r848 r859  
    8686    </None>
    8787  </ItemGroup>
     88  <ItemGroup>
     89    <None Include="CostFunctionDeutsch.txt">
     90      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     91    </None>
     92  </ItemGroup>
    8893  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
    8994  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
  • trunk/CrypPlugins/CostFunction/CostFunctionSettings.cs

    r848 r859  
    3333        #endregion
    3434       
    35         [TaskPane("FunctionType", "Select the type of function", null, 1, false, DisplayLevel.Beginner, ControlType.ComboBox, new string[] { "Index of coincidence", "Entropy", "Bigrams: log 2", "Bigrams: Sinkov", "Bigrams: Percentaged" })]
     35        [TaskPane("FunctionType", "Select the type of function", null, 1, false, DisplayLevel.Beginner, ControlType.ComboBox, new string[] { "Index of coincidence", "Entropy", "Bigrams: log 2", "Bigrams: Sinkov", "Bigrams: Percentaged", "Relative Bigram Frequency" })]
    3636        public int FunctionType
    3737        {
  • trunk/CrypPlugins/Transposition/Transposition.cs

    r846 r859  
    1010using Cryptool.PluginBase.Cryptography;
    1111using Cryptool.PluginBase.Miscellaneous;
     12using Cryptool.PluginBase.Control;
    1213
    1314namespace Transposition
     
    102103            }
    103104        }
    104 
     105       
    105106        [PropertyInfo(Direction.InputData, "Keyword", "keyword", "Keyword used for encryption", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
    106107        public string Keyword
     
    153154        public void Execute()
    154155        {
     156            Transposition_LogMessage("execute tr", NotificationLevel.Debug);
    155157            ProcessTransposition();
    156             //myPresentation.main(Read_in_matrix,Permuted_matrix,key,Keyword,Input,Output,this.settings.Permutation,this.settings.ReadIn,this.settings.ReadOut);
    157            
     158            if (controlSlave is object && Input is object)
     159            {
     160                ((TranspositionControl)controlSlave).onStatusChanged();
     161            }
     162            //myPresentation.main(Read_in_matrix,Permuted_matrix,key,Keyword,Input,Output,this.settings.Permutation,this.settings.ReadIn,this.settings.ReadOut);   
    158163        }
    159164
     
    318323        }
    319324
    320         private byte[] decrypt(byte[] input, int[] key)
    321         {
    322             if (key != null && input != null && key.Length > 0)
    323             {
    324                 if (is_Valid_Keyword(key))
     325        public byte[] decrypt(byte[] input, int[] new_key)
     326        {
     327            //Transposition_LogMessage("hier normales decrypt: " + new_key[0] + " / " +input[0], NotificationLevel.Debug);
     328
     329            if (new_key != null && input != null && new_key.Length > 0)
     330            {
     331                if (is_Valid_Keyword(new_key))
    325332                {
    326333                    byte[] decrypted= null ;
     
    330337                        {
    331338                            case TranspositionSettings.ReadOutMode.byRow:
    332                                 read_in_matrix = dec_read_in_by_row_if_row_perm(input, key); break;
     339                                read_in_matrix = dec_read_in_by_row_if_row_perm(input, new_key); break;
    333340                            case TranspositionSettings.ReadOutMode.byColumn:
    334                                 read_in_matrix = dec_read_in_by_column_if_row_perm(input, key); break;
     341                                read_in_matrix = dec_read_in_by_column_if_row_perm(input, new_key); break;
    335342                            default:
    336343                                break;
    337344                        }
    338345
    339                         permuted_matrix = dec_permut_by_row(read_in_matrix, key);
     346                        permuted_matrix = dec_permut_by_row(read_in_matrix, new_key);
    340347
    341348                        switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
    342349                        {
    343350                            case TranspositionSettings.ReadInMode.byRow:
    344                                 decrypted = read_out_by_row_if_row_perm(permuted_matrix, key.Length); break;
     351                                decrypted = read_out_by_row_if_row_perm(permuted_matrix, new_key.Length); break;
    345352                            case TranspositionSettings.ReadInMode.byColumn:
    346                                 decrypted = read_out_by_column_if_row_perm(permuted_matrix, key.Length); break;
     353                                decrypted = read_out_by_column_if_row_perm(permuted_matrix, new_key.Length); break;
    347354                            default:
    348355                                break;
     
    356363                        {
    357364                            case TranspositionSettings.ReadOutMode.byRow:
    358                                 read_in_matrix = dec_read_in_by_row(input, key); break;
     365                                read_in_matrix = dec_read_in_by_row(input, new_key); break;
    359366                            case TranspositionSettings.ReadOutMode.byColumn:
    360                                 read_in_matrix = dec_read_in_by_column(input, key); break;
     367                                read_in_matrix = dec_read_in_by_column(input, new_key); break;
    361368                            default:
    362369                                break;
    363370                        }
    364371
    365                         permuted_matrix = dec_permut_by_column(read_in_matrix, key);
     372                        permuted_matrix = dec_permut_by_column(read_in_matrix, new_key);
    366373
    367374                        switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
    368375                        {
    369376                            case TranspositionSettings.ReadInMode.byRow:
    370                                 decrypted = read_out_by_row(permuted_matrix, key.Length); break;
     377                                decrypted = read_out_by_row(permuted_matrix, new_key.Length); break;
    371378                            case TranspositionSettings.ReadInMode.byColumn:
    372                                 decrypted = read_out_by_column(permuted_matrix, key.Length); break;
     379                                decrypted = read_out_by_column(permuted_matrix, new_key.Length); break;
    373380                            default:
    374381                                break;
     
    10221029        }
    10231030
    1024         private void Transposition_LogMessage(string msg, NotificationLevel loglevel)
     1031        public void Transposition_LogMessage(string msg, NotificationLevel loglevel)
    10251032        {
    10261033            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(msg, this, loglevel));
     
    10281035
    10291036        # endregion
     1037
     1038        private IControlEncryption controlSlave;
     1039        [PropertyInfo(Direction.ControlSlave, "Transposition Slave", "Transposition Slave", "", DisplayLevel.Experienced)]
     1040        public IControlEncryption ControlSlave
     1041        {
     1042            get
     1043            {
     1044                if (controlSlave == null)
     1045                    controlSlave = new TranspositionControl(this);
     1046                return controlSlave;
     1047            }
     1048        }
     1049    }
     1050
     1051    public class TranspositionControl : IControlEncryption
     1052    {
     1053        private Transposition plugin;
     1054
     1055
     1056        public TranspositionControl(Transposition plugin)
     1057        {
     1058            this.plugin = plugin;
     1059        }
     1060
     1061        #region IControlEncryption Member
     1062
     1063        public byte[] Decrypt(byte[] key, int blocksize)
     1064        {
     1065            int[] k = new int[key.Length];
     1066            for(int i=0; i<key.Length; i++)
     1067            {
     1068                k[i] = key[i];
     1069            }
     1070
     1071            //plugin.Transposition_LogMessage("hier decrypt von control: " + k[0] + " / " +plugin.Input[0], NotificationLevel.Debug);
     1072            return plugin.decrypt(plugin.Input, k);
     1073        }
     1074
     1075        public byte[] Encrypt(byte[] key, int blocksize)
     1076        {
     1077            return null;
     1078        }
     1079
     1080        public IControlEncryption clone()
     1081        {
     1082            return null;
     1083        }
     1084
     1085        public byte[] getKeyFromString(string key)
     1086        {
     1087            return null;
     1088        }
     1089
     1090        public string getKeyPattern()
     1091        {
     1092            return null;
     1093        }
     1094
     1095        public void onStatusChanged()
     1096        {
     1097            if (OnStatusChanged != null)
     1098                OnStatusChanged(this, true);
     1099        }
     1100
     1101        public event KeyPatternChanged keyPatternChanged;
     1102
     1103        #endregion
     1104
     1105        #region IControl Member
     1106
     1107        public event IControlStatusChangedEventHandler OnStatusChanged;
     1108
     1109        #endregion
     1110
     1111        #region IDisposable Member
     1112
     1113        public void Dispose()
     1114        {
     1115           
     1116        }
     1117
     1118        #endregion
    10301119    }
    10311120}
Note: See TracChangeset for help on using the changeset viewer.