Ignore:
Timestamp:
Oct 7, 2009, 3:39:26 PM (12 years ago)
Author:
Sven Rech
Message:

KeySearcher is now able to try all keys
(only works properly with SDES right now)
(error when trying to save the workspace)

+ a very small QuadraticSieve fix

File:
1 edited

Legend:

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

    r419 r676  
    11using System;
    2 using System.Collections.Generic;
    32using System.Linq;
    43using System.Text;
     
    87using System.ComponentModel;
    98using Cryptool.PluginBase.Control;
     9using System.Collections;
    1010
    1111namespace KeySearcher
    1212{
    13   [Author("Thomas Schmid", "thomas.schmid@cryptool.org", "Uni Siegen", "http://www.uni-siegen.de")]
    14   [PluginInfo(false, "KeySearcher", "Demo plugin shows way to use ControlMaster", null, "KeySearcher/Images/icon.png")]
    15   public class KeySearcher : IAnalysisMisc
    16   {
    17 
    18     #region IPlugin Members
    19 
    20     public event StatusChangedEventHandler OnPluginStatusChanged;
    21 
    22     public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
    23 
    24     public event PluginProgressChangedEventHandler OnPluginProgressChanged;
    25 
    26     private KeySearcherSettings settings = new KeySearcherSettings();
    27     public ISettings Settings
     13    public class KeyPattern
    2814    {
    29       get { return settings; }
     15        private class Wildcard
     16        {
     17            private char[] values = new char[256];
     18            private int length;
     19            private int counter;           
     20
     21            public Wildcard(string valuePattern)
     22            {               
     23                counter = 0;
     24                length = 0;
     25                int i = 1;
     26                while (valuePattern[i] != ']')
     27                {
     28                    if (valuePattern[i + 1] == '-')
     29                    {
     30                        for (char c = valuePattern[i]; c <= valuePattern[i + 2]; c++)
     31                            values[length++] = c;
     32                        i += 2;
     33                    }
     34                    else
     35                        values[length++] = valuePattern[i];
     36                    i++;
     37                }
     38            }
     39
     40            public char getChar()
     41            {               
     42                return (char)values[counter];
     43            }
     44
     45            public bool succ()
     46            {
     47                counter++;
     48                if (counter >= length)
     49                {
     50                    counter = 0;
     51                    return true;
     52                }
     53                return false;
     54            }
     55
     56        }
     57
     58        private string pattern;
     59        private string key;       
     60        private ArrayList wildcardList;
     61
     62        public KeyPattern(string pattern)
     63        {
     64            this.pattern = pattern;
     65        }
     66
     67        public string giveWildcardKey()
     68        {
     69            string res = "";
     70            int i = 0;
     71            while (i < pattern.Length)
     72            {
     73                if (pattern[i] != '[')
     74                    res += pattern[i];
     75                else
     76                {
     77                    res += '*';
     78                    while (pattern[i] != ']')
     79                        i++;
     80                }
     81                i++;
     82            }
     83            return res;
     84        }
     85
     86        public bool testKey(string key)
     87        {
     88            int kcount = 0;
     89            int pcount = 0;
     90            while (kcount < key.Length && pcount < pattern.Length)
     91            {
     92                if (pattern[pcount] != '[')
     93                {
     94                    if (key[kcount] != '*' && pattern[pcount] != key[kcount])
     95                        return false;
     96                    kcount++;
     97                    pcount++;
     98                }
     99                else
     100                {
     101                    bool contains = false;
     102                    pcount++;
     103                    while (pattern[pcount] != ']')
     104                    {
     105                        if (key[kcount] != '*')
     106                        {
     107                            if (pattern[pcount + 1] == '-')
     108                            {
     109                                if (key[kcount] >= pattern[pcount] && key[kcount] <= pattern[pcount + 2])
     110                                    contains = true;
     111                                pcount += 2;
     112                            }
     113                            else
     114                                if (pattern[pcount] == key[kcount])
     115                                    contains = true;
     116                        }
     117                        pcount++;
     118                    }
     119                    if (!contains && !(key[kcount] == '*'))
     120                        return false;
     121                    kcount++;
     122                    pcount++;
     123                }               
     124            }
     125            if (pcount != pattern.Length || kcount != key.Length)
     126                return false;
     127            return true;
     128        }
     129
     130        public void initKeyIteration(string key)
     131        {
     132            this.key = key;
     133            int pcount = 0;
     134            wildcardList = new ArrayList();
     135            for (int i = 0; i < key.Length; i++)
     136            {
     137                if (key[i] == '*')
     138                    wildcardList.Add(new Wildcard(pattern.Substring(pcount, pattern.IndexOf(']', pcount)+1-pcount)));
     139
     140                if (pattern[pcount] == '[')
     141                    while (pattern[pcount] != ']')
     142                        pcount++;
     143                pcount++;
     144            }
     145        }
     146
     147        public bool nextKey()
     148        {
     149            int wildcardCount = 0;
     150            bool overflow = ((Wildcard)wildcardList[0]).succ();
     151            wildcardCount = 1;
     152            while (overflow && (wildcardCount < wildcardList.Count))
     153                overflow = ((Wildcard)wildcardList[wildcardCount++]).succ();
     154            return !overflow;
     155        }
     156
     157        public string getKey()
     158        {
     159            string res = "";
     160            int wildcardCount = 0;
     161            for (int i = 0; i < key.Length; i++)
     162            {
     163                if (key[i] != '*')
     164                    res += key[i];
     165                else
     166                {
     167                    Wildcard wc = (Wildcard)wildcardList[wildcardCount++];
     168                    res += wc.getChar();
     169                }
     170            }
     171            return res;
     172        }
    30173    }
    31 
    32     public UserControl Presentation
     174   
     175    [Author("Thomas Schmid and Sven Rech", "thomas.schmid@cryptool.org and rech@cryptool.org", "Uni Siegen", "http://www.uni-siegen.de")]
     176    [PluginInfo(true, "KeySearcher", "Bruteforces a decryption algorithm.", null, "KeySearcher/Images/icon.png")]
     177    public class KeySearcher : IAnalysisMisc
    33178    {
    34       get { return null; }
     179        private bool stop;
     180
     181        #region IPlugin Members
     182
     183        public event StatusChangedEventHandler OnPluginStatusChanged;
     184
     185        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
     186
     187        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
     188
     189        private KeySearcherSettings settings;       
     190
     191        public KeySearcher()
     192        {
     193            settings = new KeySearcherSettings(this);
     194        }
     195
     196        public ISettings Settings
     197        {
     198            get { return settings; }
     199        }
     200
     201        public UserControl Presentation
     202        {
     203            get { return null; }
     204        }
     205
     206        public UserControl QuickWatchPresentation
     207        {
     208            get { return null; }
     209        }
     210
     211        public void PreExecution()
     212        {
     213        }
     214
     215        public void Execute()
     216        {
     217            if (ControlMaster != null)
     218            {
     219                stop = false;
     220                if (!settings.Pattern.testKey(settings.Key))
     221                {
     222                    GuiLogMessage("Wrong key pattern!", NotificationLevel.Error);
     223                    return;
     224                }
     225                settings.Pattern.initKeyIteration(settings.Key);
     226                string key;
     227                do
     228                {
     229                    key = settings.Pattern.getKey();
     230                    GuiLogMessage("Try key " + key, NotificationLevel.Debug);
     231                    byte[] decryption = ControlMaster.Decrypt(ControlMaster.getKeyFromString(key));
     232                    //TODO: Check cost function here
     233                } while (settings.Pattern.nextKey() && !stop);
     234            }
     235        }
     236
     237        public void PostExecution()
     238        {
     239        }
     240
     241        public void Pause()
     242        {
     243        }
     244
     245        public void Stop()
     246        {
     247            stop = true;
     248        }
     249
     250        public void Initialize()
     251        {
     252        }
     253
     254        public void Dispose()
     255        {
     256        }
     257
     258        #endregion
     259
     260        #region INotifyPropertyChanged Members
     261
     262        public event PropertyChangedEventHandler PropertyChanged;
     263
     264        public void OnPropertyChanged(string name)
     265        {
     266            if (PropertyChanged != null)
     267            {
     268                PropertyChanged(this, new PropertyChangedEventArgs(name));
     269            }
     270        }
     271
     272        #endregion
     273
     274        #region IControlEncryption Members
     275
     276        private IControlEncryption controlMaster;
     277        [PropertyInfo(Direction.ControlMaster, "Control Master", "Used for bruteforcing", "", DisplayLevel.Beginner)]
     278        public IControlEncryption ControlMaster
     279        {
     280            get { return controlMaster; }
     281            set
     282            {
     283                if (value != null)
     284                {
     285                    settings.Pattern = new KeyPattern(value.getKeyPattern());
     286                    controlMaster = value;
     287                    OnPropertyChanged("ControlMaster");
     288                }
     289            }
     290        }
     291
     292        public void GuiLogMessage(string message, NotificationLevel loglevel)
     293        {
     294            if (OnGuiLogNotificationOccured != null)
     295                OnGuiLogNotificationOccured(this, new GuiLogEventArgs(message, this, loglevel));
     296        }
     297
     298        #endregion
    35299    }
    36 
    37     public UserControl QuickWatchPresentation
    38     {
    39       get { return null; }
    40     }
    41 
    42     public void PreExecution()
    43     {
    44     }
    45 
    46     public void Execute()
    47     {
    48     }
    49 
    50     public void PostExecution()
    51     {
    52     }
    53 
    54     public void Pause()
    55     {
    56     }
    57 
    58     public void Stop()
    59     {
    60     }
    61 
    62     public void Initialize()
    63     {
    64     }
    65 
    66     public void Dispose()
    67     {
    68     }
    69 
    70     #endregion
    71 
    72     #region INotifyPropertyChanged Members
    73 
    74     public event PropertyChangedEventHandler PropertyChanged;
    75 
    76     private void NotifyPropertyChanged(string property)
    77     {
    78       if (PropertyChanged != null)
    79         PropertyChanged(this, new PropertyChangedEventArgs(property));
    80     }
    81 
    82     #endregion
    83 
    84     #region IControlEncryption Members
    85 
    86     private IControlEncryption testProperty;
    87     [PropertyInfo(Direction.ControlMaster, "Test IControlEncryption Master", "Tooltip1", "", DisplayLevel.Beginner)]
    88     public IControlEncryption TestProperty
    89     {
    90       get { return testProperty; }
    91       set
    92       {
    93         if (value != null)
    94         {
    95           testProperty = value;
    96           int keySize = 8;
    97           int ivSize = 8;
    98           int end = 255;
    99           string secret = "Hallo Welt!";
    100 
    101           byte[] testKey = new byte[keySize];
    102           byte[] searchKey = new byte[keySize];
    103           byte[] iv = new byte[ivSize];
    104           Random ran = new Random();
    105           for (int i = 0; i < keySize; i++)
    106           {
    107             testKey[i] = (byte)ran.Next(end);
    108             searchKey[i] = testKey[i];
    109             iv[i] = (byte)ran.Next(end);
    110           }
    111 
    112           byte[] testData = Encoding.Default.GetBytes(secret);
    113           byte[] dataEncrypted = testProperty.Encrypt(testKey, testData, iv);
    114 
    115 
    116           for (int i = 0; i < end; i++)
    117           {
    118             searchKey[0] = (byte)i;
    119             byte[] dataDecrypted = testProperty.Decrypt(searchKey, dataEncrypted, iv);
    120             string test = Encoding.Default.GetString(dataDecrypted);
    121             if (test.Contains(secret))
    122             {
    123               GuiLogMessage("Found key: " + i.ToString(), NotificationLevel.Info);
    124               break;
    125             }
    126           }
    127           // key found
    128         }
    129       }
    130     }
    131 
    132     private void GuiLogMessage(string message, NotificationLevel loglevel)
    133     {
    134       if (OnGuiLogNotificationOccured != null)
    135         OnGuiLogNotificationOccured(this, new GuiLogEventArgs(message, this, loglevel));
    136     }
    137 
    138     #endregion
    139   }
    140300}
Note: See TracChangeset for help on using the changeset viewer.