source: trunk/CrypPlugins/KeySearcher/KeyPattern/Wildcard.cs @ 2010

Last change on this file since 2010 was 2010, checked in by Sven Rech, 11 years ago

new key finding algorithm for KeySearcher

This update is really huge.

File size: 6.1 KB
Line 
1/*                             
2   Copyright 2009 Sven Rech (svenrech at googlemail dot com), 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
17namespace KeySearcher.KeyPattern
18{
19    internal class Wildcard
20    {
21        private char[] values = new char[256];
22        private int length;
23        private int counter;
24        public bool isSplit
25        {
26            get;
27            private set;
28        }
29
30        public Wildcard(string valuePattern)
31        {
32            isSplit = false;
33            counter = 0;
34            if (valuePattern.Length == 1)
35            {
36                length = 1;
37                values[0] = valuePattern[0];
38            }
39            else
40            {
41                length = 0;
42                int i = 1;
43                while (valuePattern[i] != ']')
44                {
45                    if (valuePattern[i + 1] == '-')
46                    {
47                        for (char c = valuePattern[i]; c <= valuePattern[i + 2]; c++)
48                            values[length++] = c;
49                        i += 2;
50                    }
51                    else
52                        values[length++] = valuePattern[i];
53                    i++;
54                }
55            }
56        }
57
58        public Wildcard(Wildcard wc)
59        {
60            isSplit = wc.isSplit;
61            length = wc.length;
62            counter = wc.counter;
63            for (int i = 0; i < 256; i++)
64                values[i] = wc.values[i];
65        }
66
67        public Wildcard(char[] values, int length)
68        {
69            isSplit = false;
70            this.length = length;
71            this.values = values;
72            this.counter = 0;
73        }
74
75        private Wildcard()
76        {
77        }
78
79        public Wildcard[] split()
80        {
81            if (length <= 1)
82                return null;
83            int length1 = this.length - this.counter;
84            Wildcard[] wcs = new Wildcard[2];
85            wcs[0] = new Wildcard();
86            wcs[0].counter = 0;
87            wcs[0].length = length1 / 2;
88            wcs[1] = new Wildcard();
89            wcs[1].counter = 0;
90            wcs[1].length = length1 - wcs[0].length;
91            for (int i = 0; i < wcs[0].length; i++)
92                wcs[0].values[i] = values[this.counter + i];
93            for (int i = 0; i < wcs[1].length; i++)
94                wcs[1].values[i] = values[i + this.counter + wcs[0].length];
95            wcs[0].isSplit = true;
96            wcs[1].isSplit = true;
97            return wcs;
98        }
99
100        public char getChar()
101        {
102            return values[counter];
103        }
104
105        public char getChar(int add)
106        {
107            return values[(counter + add) % length];
108        }
109
110        public bool succ()
111        {
112            counter++;
113            if (counter >= length)
114            {
115                counter = 0;
116                return true;
117            }
118            return false;
119        }
120
121        /// <summary>
122        /// Adds "add" to the counter and returns the carry.
123        /// </summary>
124        /// <param name="add">The carry</param>
125        /// <returns></returns>
126        public int add(int add)
127        {
128            counter += add;
129            if (counter >= length)
130            {
131                int result = counter / length;
132                counter %= length;
133                return result;
134            }
135            return 0;
136        }
137
138        public int size()
139        {
140            return length;
141        }
142
143        public int count()
144        {
145            return counter;
146        }
147
148        public void resetCounter()
149        {
150            counter = 0;
151        }
152
153        public string getRepresentationString()
154        {
155            if (length == 1)
156                return "" + values[0];
157            string res = "[";
158            int begin = 0;
159            for (int i = 1; i < length; i++)
160            {
161                if (values[i - 1] != values[i] - 1)
162                {
163                    if (begin == i - 1)
164                        res += values[begin];
165                    else
166                    {
167                        if (i - 1 - begin == 1)
168                            res += values[begin] + "" + values[i - 1];
169                        else
170                            res += values[begin] + "-" + values[i - 1];
171                    }
172                    begin = i;
173                }
174            }
175            if (begin == length - 1)
176                res += values[begin];
177            else
178            {
179                if (length - 1 - begin == 1)
180                    res += values[begin] + "" + values[length - 1];
181                else
182                    res += values[begin] + "-" + values[length - 1];
183            }
184
185            res += "]";
186            return res;
187        }
188
189        public bool contains(Wildcard wc)
190        {
191            if (wc == null)
192                return false;
193            for (int i = 0; i < wc.length; i++)
194            {
195                bool contains = false;
196                for (int j = 0; j < this.length; j++)
197                {
198                    if (this.values[j] == wc.values[i])
199                    {
200                        contains = true;
201                        break;
202                    }
203                }
204                if (!contains)
205                    return false;
206            }
207            return true;
208        }
209
210        internal int getLength()
211        {
212            return length;
213        }
214
215        internal char[] getChars()
216        {
217            return values;
218        }
219    }
220}
Note: See TracBrowser for help on using the repository browser.