source: trunk/CrypPlugins/KeySearcher/KeyPatternPool.cs @ 1168

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

KeyPatternPool: Little Bug fixed for Sven Rech
P2P-Manager-Bruteforce Sample: removed initialization vector input

File size: 6.5 KB
Line 
1using System;
2using System.Collections.Generic;
3using System.Linq;
4using System.Text;
5using Cryptool.PluginBase.Miscellaneous;
6using System.Collections;
7using Cryptool.Plugins.PeerToPeer.Jobs;
8
9namespace KeySearcher
10{
11    /**
12     * This class is able to split a KeyPattern into several disjunct parts, which are guaranteed to have equal size.
13     * It tries to split the pattern in such a way, that the parts have nearly the given partsize.
14     **/
15    public class KeyPatternPool
16    {
17        private BigInteger partsize;
18        private BigInteger counter = 0;
19        private KeyPattern pattern;
20        private Stack<KeyPattern> stack = new Stack<KeyPattern>();
21        private int[] splittingQuotient;
22        private int[] splittingCounter;
23        private bool end = false;
24
25        private void CalculateSplitting()
26        {
27            for (int c = pattern.wildcardList.Count - 1; c >= 0; c--)
28                splittingQuotient[c] = 1;
29
30            BigInteger bestSize = GetPartSize();
31
32            for (int c = pattern.wildcardList.Count - 1; c >= 0; c--)
33            {
34                //for (int k = 1; k <= c; k++)
35                for (int k = 1; k <= ((Wildcard)pattern.wildcardList[c]).size(); k++) 
36                {
37                    int d = ((Wildcard)pattern.wildcardList[c]).size();
38                    if (d % k == 0)
39                    {
40                        int tmp = splittingQuotient[c];
41                        splittingQuotient[c] = d;
42                        BigInteger size = GetPartSize();
43                        if ((size - partsize).abs() < (bestSize - partsize).abs())                       
44                            bestSize = size;                       
45                        else
46                            splittingQuotient[c] = tmp;
47                    }
48                }
49            }
50        }
51               
52        private bool SuccCounter()
53        {
54            for (int k = pattern.wildcardList.Count-1; k >= 0; k--)
55            {
56                Wildcard wc = ((Wildcard)pattern.wildcardList[k]);
57                splittingCounter[k]++;
58                if (splittingCounter[k] >= splittingQuotient[k])
59                    splittingCounter[k] = 0;
60                else
61                    return true;
62            }
63            return false;
64        }
65
66        // added by Arnie - 2010.02.04
67        public bool Contains(byte[] serializedJob)
68        {
69            KeyPattern deserializedPattern = new KeyPattern(serializedJob);
70            return Contains(deserializedPattern);
71        }
72
73        public bool Contains(KeyPattern pattern)
74        {
75            if (pattern.wildcardList.Count != this.pattern.wildcardList.Count)
76                return false;
77            if (pattern.GetPattern() != this.pattern.GetPattern())
78                return false;
79
80            bool equal = true;
81            for (int k = 0; k < pattern.wildcardList.Count; k++)
82            {
83                Wildcard wc = ((Wildcard)pattern.wildcardList[k]);
84                Wildcard thiswc = ((Wildcard)this.pattern.wildcardList[k]);
85                if (wc.size() != (thiswc.size() / splittingQuotient[k]))
86                    return false;
87               
88                bool bolContains2 = true;
89                int begin = equal ? splittingCounter[k] : 0;
90                for (int j = begin; j < splittingQuotient[k]; j++)
91                {
92                    bool bolContains = true;
93                    for (int i = 0; i < wc.size(); i++)
94                    {
95                        if (wc.getChar(i - wc.count()) != thiswc.getChar(i + j * wc.size()))
96                        {
97                            bolContains = false;
98                            break;
99                        }
100                    }
101                    if (bolContains)
102                    {                       
103                        equal = (j == splittingCounter[k]);
104                        bolContains2 = true;
105                        break;
106                    }
107                }
108                if (!bolContains2)
109                    return false;
110
111            }
112            return !equal;
113        }
114
115        public void Push(KeyPattern pattern)
116        {
117            counter--;
118            if (!Contains(pattern))
119                stack.Push(pattern);
120            else
121                throw new Exception("Pattern already given.");
122        }
123
124        public KeyPattern Pop()
125        {
126            if (stack.Count != 0)
127            {
128                counter++;
129                return (KeyPattern)stack.Pop();
130            }
131
132            if (end)
133                return null;           
134
135            KeyPattern part = new KeyPattern(pattern.GetPattern());
136            part.wildcardList = new ArrayList();
137            for (int k = 0; k < pattern.wildcardList.Count; k++)
138            {               
139                Wildcard wc = ((Wildcard)pattern.wildcardList[k]);
140                char[] values = new char[256];
141                int length = wc.size() / splittingQuotient[k];
142                for (int i = 0; i < length; i++)
143                    values[i] = wc.getChar(i + splittingCounter[k] * length);
144                Wildcard newwc = new Wildcard(values, length);
145                part.wildcardList.Add(newwc);
146            }
147
148            if (!SuccCounter())
149                end = true;
150
151            counter++;
152            return part;
153        }
154
155        public BigInteger GetPartSize()
156        {
157            BigInteger res = 1;
158            for (int k = 0; k < pattern.wildcardList.Count; k++)
159            {
160                Wildcard wc = ((Wildcard)pattern.wildcardList[k]);
161                res *= wc.size() / splittingQuotient[k];
162            }
163            return res;
164        }
165
166        public long Count()
167        {
168            return (TotalAmount() + stack.Count - counter).LongValue();
169        }
170
171        public BigInteger TotalAmount()
172        {
173            BigInteger res = 1;
174            for (int k = 0; k < pattern.wildcardList.Count; k++)
175            {
176                Wildcard wc = ((Wildcard)pattern.wildcardList[k]);
177                res *= splittingQuotient[k];
178            }
179            return res;
180        }
181
182        public KeyPatternPool(KeyPattern pattern, BigInteger partsize)
183        {
184            this.partsize = partsize;
185            this.pattern = pattern;
186            splittingQuotient = new int[pattern.wildcardList.Count];
187            CalculateSplitting();
188            splittingCounter = new int[pattern.wildcardList.Count];
189        }
190    }
191}
Note: See TracBrowser for help on using the repository browser.