source: trunk/CrypPlugins/KeySearcher/KeyPattern.cs @ 1182

Last change on this file since 1182 was 1182, checked in by arnold, 12 years ago

Fixed serialization bug in KeyPattern, so AES bruteforcing will be possible now
Fixed AES Bruteforce Sample (there were wrong Modi settings)

File size: 20.4 KB
Line 
1/*                             
2   Copyright 2009 Team CrypTool (Sven Rech,Dennis Nolte,Raoul Falk,Nils Kopal), Uni Duisburg-Essen
3
4   Licensed under the Apache License, Version 2.0 (the "License");
5   you may not use this file except in compliance with the License.
6   You may obtain a copy of the License at
7
8       http://www.apache.org/licenses/LICENSE-2.0
9
10   Unless required by applicable law or agreed to in writing, software
11   distributed under the License is distributed on an "AS IS" BASIS,
12   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   See the License for the specific language governing permissions and
14   limitations under the License.
15*/
16
17using System;
18using System.Collections.Generic;
19using System.Linq;
20using System.Text;
21using Cryptool.PluginBase.Miscellaneous;
22using System.Collections;
23using Cryptool.Plugins.PeerToPeer.Jobs;
24using System.IO;
25
26namespace KeySearcher
27{
28    public class KeyPattern
29    {       
30        private string pattern;
31        internal ArrayList wildcardList;
32
33        /// <summary>
34        /// Property for the WildCardKey. Could return null, if the KeyPattern isn't initialized correctly.
35        /// </summary>
36        public string WildcardKey
37        {
38            get
39            {
40                return getWildcardKey();
41            }
42            set
43            {
44                if (!testWildcardKey(value))
45                    throw new Exception("Invalid wildcard key!");
46                setWildcardKey(value);
47            }
48        }
49
50        public KeyPattern(string pattern)
51        {
52            if (!testPattern(pattern))
53                throw new Exception("Invalid pattern!");
54            this.pattern = pattern;
55        }       
56
57        public KeyPattern[] split()
58        {
59            KeyPattern[] patterns = new KeyPattern[2];
60            for (int i = 0; i < 2; i++)
61            {
62                patterns[i] = new KeyPattern(pattern);               
63                patterns[i].wildcardList = new ArrayList();
64            }
65            bool s = false;
66            for (int i = 0; i < wildcardList.Count; i++)
67            {
68                Wildcard wc = ((Wildcard)wildcardList[i]);
69                if (!s && (wc.size() - wc.count()) > 1)
70                {
71                    Wildcard[] wcs = wc.split();
72                    patterns[0].wildcardList.Add(wcs[0]);
73                    patterns[1].wildcardList.Add(wcs[1]);                   
74                    s = true;
75                }
76                else
77                {
78                    patterns[0].wildcardList.Add(new Wildcard(wc));
79                    Wildcard copy = new Wildcard(wc);
80                    if (s)
81                        copy.resetCounter();
82                    patterns[1].wildcardList.Add(copy);
83                }
84            }
85            if (!s)
86                return null;
87            return patterns;
88        }
89
90        public string giveInputPattern()
91        {
92            string res = "";
93            int i = 0;
94            while (i < pattern.Length)
95            {
96                if (pattern[i] != '[')
97                    res += pattern[i];
98                else
99                {
100                    res += '*';
101                    while (pattern[i] != ']')
102                        i++;
103                }
104                i++;
105            }
106            return res;
107        }
108
109        /**
110         * tests, if 'pattern' is a valid pattern.
111         **/
112        public static bool testPattern(string pattern)
113        {
114            int i = 0;
115            while (i < pattern.Length)
116            {
117                if (pattern[i] == '[')
118                {
119                    i++;
120                    while (pattern[i] != ']')
121                    {
122                        if (specialChar(pattern[i]))
123                            return false;
124                        if (pattern[i + 1] == '-')
125                        {
126                            if (specialChar(pattern[i]) || specialChar(pattern[i + 2]))
127                                return false;
128                            i += 2;
129                        }
130                        i++;
131                    }
132                }
133                i++;
134            }
135            return true;
136        }
137
138        private static bool specialChar(char p)
139        {
140            if (p == '-' || p == '[' || p == ']' || p == '*')
141                return true;
142            return false;
143        }
144
145        /**
146         * tests, if 'wildcardKey' matches 'pattern'.
147         **/
148        public static bool testWildcardKey(string wildcardKey, string pattern)
149        {
150            try
151            {
152                int kcount = 0;
153                int pcount = 0;
154                while (kcount < wildcardKey.Length && pcount < pattern.Length)
155                {
156                    if (pattern[pcount] != '[')
157                    {
158                        if (pattern[pcount] != wildcardKey[kcount])
159                            return false;
160                        kcount++;
161                        pcount++;
162                    }
163                    else
164                    {
165                        Wildcard wc1 = new Wildcard(pattern.Substring(pcount, pattern.IndexOf(']', pcount) + 1 - pcount));
166                        while (pattern[pcount++] != ']') ;
167                        Wildcard wc2 = null;
168                        if (wildcardKey[kcount] == '[')
169                        {
170                            wc2 = new Wildcard(wildcardKey.Substring(kcount, wildcardKey.IndexOf(']', kcount) + 1 - kcount));
171                            while (wildcardKey[++kcount] != ']') ;
172                        }
173                        else if (wildcardKey[kcount] != '*')
174                            wc2 = new Wildcard("" + wildcardKey[kcount]);
175
176                        if (!wc1.contains(wc2) && !(wildcardKey[kcount] == '*'))
177                            return false;
178                        kcount++;
179                    }
180                }
181                if (pcount != pattern.Length || kcount != wildcardKey.Length)
182                    return false;
183                return true;
184            }
185            catch (Exception)
186            {
187                return false;
188            }
189        }
190
191        public bool testWildcardKey(string wildcardKey)
192        {
193            return testWildcardKey(wildcardKey, pattern);
194        }
195
196        private void setWildcardKey(string wildcardKey)
197        {         
198            int pcount = 0;
199            wildcardList = new ArrayList();
200            int i = 0;
201            while (i < wildcardKey.Length)           
202            {
203                if (pattern[pcount] == '[')
204                {
205                    if (wildcardKey[i] == '*')
206                    {
207                        Wildcard wc = new Wildcard(pattern.Substring(pcount, pattern.IndexOf(']', pcount) + 1 - pcount));
208                        wildcardList.Add(wc);
209                      }
210                    else if (wildcardKey[i] == '[')
211                    {
212                        Wildcard wc = new Wildcard(wildcardKey.Substring(i, wildcardKey.IndexOf(']', i) + 1 - i));
213                        wildcardList.Add(wc);
214                        while (wildcardKey[++i] != ']') ;
215                    }
216                    else
217                    {
218                        Wildcard wc = new Wildcard("" + wildcardKey[i]);
219                        wildcardList.Add(wc);
220                    }
221                    while (pattern[++pcount] != ']') ;
222                }
223                pcount++;
224                i++;
225            }
226        }
227
228        private string getWildcardKey()
229        {
230            string res = "";
231            int pcount = 0;
232            int wccount = 0;
233
234            // error handling
235            if (wildcardList != null)
236            {
237                while (pcount < pattern.Length)
238                {
239                    if (pattern[pcount] != '[')
240                        res += pattern[pcount];
241                    else
242                    {
243                        res += ((Wildcard)wildcardList[wccount++]).getRepresentationString();
244                        while (pattern[++pcount] != ']') ;
245                    }
246                    pcount++;
247                }
248                return res;
249            }
250            else
251                return null;
252        }
253
254        public BigInteger size()
255        {
256            if (wildcardList == null)
257                return 0;
258            BigInteger counter = 1;
259            foreach (Wildcard wc in wildcardList)
260                counter *= wc.size();
261            return counter;
262        }
263
264        /** used to jump to the next Key.         
265         * if nextWildcard == -1, we return false
266         * if nextWildcard == -2, we return true
267         * if nextWildcard == -3, we increase the rightmost wildcard
268         * if nextWildcard >= 0, we increase the wildcard on the position 'nextWildcard'
269         * returns false if there is no key left.
270         */
271        public bool nextKey(int nextWildcard)
272        {
273            if (nextWildcard == -2)
274                return true;
275            if (nextWildcard == -1)
276                return false;
277
278            int wildcardCount;
279            if (nextWildcard == -3)
280                wildcardCount = wildcardList.Count - 1;
281            else
282                wildcardCount = nextWildcard;
283            bool overflow = ((Wildcard)wildcardList[wildcardCount--]).succ();           
284            while (overflow && (wildcardCount >= 0))
285                overflow = ((Wildcard)wildcardList[wildcardCount--]).succ();
286            return !overflow;
287        }
288
289        public string getKey()
290        {
291            string res = "";
292            int wildcardCount = 0;
293            int i = 0;
294            while (i < pattern.Length)           
295            {
296                if (pattern[i] != '[')
297                    res += pattern[i++];
298                else
299                {
300                    Wildcard wc = (Wildcard)wildcardList[wildcardCount++];
301                    res += wc.getChar();
302                    while (pattern[i++] != ']') ;
303                }               
304            }
305            return res;
306        }
307
308        public string getKey(int add)
309        {
310            string res = "";
311            int div = 1;
312            int wildcardCount = wildcardList.Count - 1;
313            int i = pattern.Length - 1;
314            while (i >= 0)           
315            {
316                if (pattern[i] != ']')
317                    res += pattern[i--];
318                else
319                {
320                    Wildcard wc = (Wildcard)wildcardList[wildcardCount--];
321                    if (add < div)
322                        res += wc.getChar();
323                    else
324                    {
325                        res += wc.getChar((add / div) % wc.size());
326                        div *= wc.size();
327                    }
328                    while (pattern[i--] != '[') ;
329                }
330            }
331            char[] r = res.ToCharArray();
332            Array.Reverse(r);
333            return new string(r);
334        }
335
336        public string getKeyBlock(ref int blocksize, ref int nextWildcard)
337        {
338            const int MAXSIZE = 65536;
339            //find out how many wildcards we can group together:
340            blocksize = 1;
341            int pointer;
342            for (pointer = wildcardList.Count - 1; pointer >= 0; pointer--)
343            {
344                Wildcard wc = (Wildcard)wildcardList[pointer];
345                if (wc.isSplit || wc.count() != 0 || blocksize * wc.size() > MAXSIZE)
346                    break;
347                else
348                    blocksize *= wc.size();
349            }
350
351            if (pointer >= wildcardList.Count)
352                return null;
353
354            nextWildcard = pointer;
355
356            //generate key:
357            string res = "";
358            int wildcardCount = 0;
359            int i = 0;
360            while (i < pattern.Length)
361            {
362                if (pattern[i] != '[')
363                    res += pattern[i++];
364                else
365                {
366                    if (pointer < wildcardCount)
367                        res += "*";
368                    else
369                    {
370                        Wildcard wc = (Wildcard)wildcardList[wildcardCount++];
371                        res += wc.getChar();
372                    }
373                    while (pattern[i++] != ']') ;
374                }
375            }
376            return res;
377        }       
378
379         /*
380         * ARNIES SANDKASTEN - ALLE FOLGENDEN METHODEN SIND FÜR DIE VERTEILTE VERWENDUNG
381         * DES KEYPATTERNS NOTWENDIG ODER ABER EINFACH UM DAS KEYPATTERN SCHÖN ALS
382         * GUILOGMESSAGE AUSGEBEN ZU KÖNNEN ;-)
383         */
384
385        // Added by Arnold - 2010.02.04
386        public KeyPattern(byte[] serializedPattern)
387        {
388            KeyPattern deserializedPattern = Deserialize(serializedPattern);
389            // set deserialized Pattern to actual pattern
390            this.pattern = deserializedPattern.pattern;
391            this.WildcardKey = deserializedPattern.WildcardKey;
392            //this.wildcardList = deserializedPattern.wildcardList;
393            if (deserializedPattern == null)
394                throw new Exception("Invalid byte[] representation of KeyPattern!");
395        }
396
397        //added by Christian Arnold - 2009.12.02
398        /// <summary>
399        /// returns type, key and pattern. If you want to get only the pattern for processing use GetPattern-method!
400        /// </summary>
401        /// <returns></returns>
402        public override string ToString()
403        {
404            if(this.WildcardKey != null)
405                return "Type: KeySearcher.KeyPattern. WildcardKey: '" + this.WildcardKey + "', Pattern: '" + this.pattern + "'";
406            else
407                return "Type: KeySearcher.KeyPattern. KeyPattern isn't initialized correctly, Pattern: '" + this.pattern + "'";
408        }
409
410        //added by Christian Arnold - 2009.12.03
411        /// <summary>
412        /// returns ONLY the pattern as a string!
413        /// </summary>
414        /// <returns></returns>
415        public string GetPattern()
416        {
417            return this.pattern;
418        }
419
420        #region Serialization methods and auxiliary variables
421
422        /* Serialization information:
423         * 1st byte: Byte-Length of the WildCardKey
424         * 2nd - wildcardLen: WildCardKey Byte representation
425         * wildcardLen + 1: Byte-Length of the Pattern
426         * wildcardLen + 2 - wildcardLen+2+patternLen: Pattern Byte representation
427         *  -------------------------------------------------------------
428         * | wildcardkey length | wildcardkey | pattern length | pattern |
429         *  -------------------------------------------------------------  */
430        private Encoding encoder = UTF8Encoding.UTF8;
431
432        /// <summary>
433        /// Serialize all needful information to rebuild the existing pattern elsewhere
434        /// </summary>
435        /// <returns>byte representation of all the needful information of the actual KeyPattern</returns>
436        public byte[] Serialize()
437        {
438            byte[] retByte;
439            string wildcardKey = this.WildcardKey;
440            if (wildcardKey != null && this.pattern != null)
441            {
442                if (testWildcardKey(wildcardKey))
443                {
444                    byte[] byteWildCard = encoder.GetBytes(wildcardKey);
445                    byte[] bytePattern = encoder.GetBytes(pattern);
446                    byte[] byteWildCardLen = BitConverter.GetBytes(byteWildCard.Length);
447                    byte[] bytePatternLen = BitConverter.GetBytes(bytePattern.Length);
448                    MemoryStream memStream = new MemoryStream();
449                    try
450                    {
451                        memStream.Write(byteWildCardLen, 0, byteWildCardLen.Length);
452                        memStream.Write(byteWildCard, 0, byteWildCard.Length);
453                        memStream.Write(bytePatternLen, 0, bytePatternLen.Length);
454                        memStream.Write(bytePattern, 0, bytePattern.Length);
455                        retByte = memStream.ToArray();
456                    }
457                    catch (Exception ex)
458                    {
459                        throw ex;
460                    }
461                    finally
462                    {
463                        memStream.Flush();
464                        memStream.Close();
465                        memStream.Dispose();
466                    }
467                    //retByte = new byte[byteWildCardLen.Length + byteWildCard.Length + bytePatternLen.Length + bytePattern.Length];
468                    //Buffer.BlockCopy(byteWildCardLen, 0, retByte, 0, byteWildCardLen.Length);
469                    //Buffer.BlockCopy(byteWildCard, 0, retByte, byteWildCard.Length, byteWildCard.Length);
470                    //retByte[byteWildCard.Length + 1] = (byte)bytePattern.Length;
471                    //Buffer.BlockCopy(bytePattern, 0, retByte, byteWildCard.Length + 2, bytePattern.Length);
472                }
473                else
474                {
475                    throw (new Exception("Serializing KeyPattern canceled, because WildcardKey and/or Pattern aren't valid. "
476                        + "WildcardKey: '" + wildcardKey + "', Pattern: '" + pattern + "'.\n"));
477                }
478            }
479            else
480            {
481                throw (new Exception("Serializing KeyPattern canceled, because Key and/or Pattern are NULL. WildcardKey: '" + wildcardKey + "'. Pattern: '" + pattern + "'."));
482            }
483            return retByte;
484        }
485
486        /// <summary>
487        /// Deserialize a byte-representation of an KeyPattern object. Returns a full-initialized KeyPattern object.
488        /// </summary>
489        /// <param name="serializedPattern">byte-representation of an keypattern object</param>
490        /// <returns>a full-initialized KeyPattern object</returns>
491        public KeyPattern Deserialize(byte[] serializedPattern)
492        {
493            KeyPattern keyPatternToReturn;
494            string wildcardKey_temp;
495            string pattern_temp;
496
497            MemoryStream memStream = new MemoryStream(serializedPattern);
498            try
499            {
500                /* So i always have the same byte length for int32 values */
501                int iTest = 500;
502                int int32ByteLen = BitConverter.GetBytes(iTest).Length;
503
504                // Wildcard length and value
505                byte[] byteLen = new byte[int32ByteLen];
506                memStream.Read(byteLen, 0, byteLen.Length);
507                byte[] byteWildcard = new byte[BitConverter.ToInt32(byteLen, 0)];
508                memStream.Read(byteWildcard, 0, byteWildcard.Length);
509
510                wildcardKey_temp = encoder.GetString(byteWildcard, 0, byteWildcard.Length);
511
512
513                // Pattern length and value
514                memStream.Read(byteLen, 0, byteLen.Length);
515                byte[] bytePattern = new byte[BitConverter.ToInt32(byteLen, 0)];
516                memStream.Read(bytePattern, 0, bytePattern.Length);
517
518                pattern_temp = encoder.GetString(bytePattern, 0, bytePattern.Length);
519
520            }
521            catch (Exception ex)
522            {
523                throw ex;
524            }
525            finally
526            {
527                memStream.Flush();
528                memStream.Close();
529                memStream.Dispose();
530            }
531
532            //int iWildCardLen = serializedPattern[0];
533            //wildcardKey_temp = encoder.GetString(serializedPattern, 1, iWildCardLen);
534            //int iPatternLen = serializedPattern[iWildCardLen + 1];
535            //pattern_temp = encoder.GetString(serializedPattern, iWildCardLen + 2, iPatternLen);
536
537            keyPatternToReturn = new KeyPattern(pattern_temp);
538            // test extracted pattern and wildcardKey!
539            if (keyPatternToReturn.testWildcardKey(wildcardKey_temp))
540            {
541                keyPatternToReturn.WildcardKey = wildcardKey_temp;
542                return keyPatternToReturn;
543            }
544            else
545            {
546                throw (new Exception("Deserializing KeyPattern canceled, because WildcardKey or Pattern aren't valid. "
547                    + "WildcardKey: '" + wildcardKey_temp + "', Pattern: '" + pattern_temp + "'.\n"));
548            }
549        }
550
551        #endregion
552
553    }
554}
Note: See TracBrowser for help on using the repository browser.