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

Last change on this file since 1448 was 1448, checked in by Sven Rech, 12 years ago

replaced all BigInteger stuff with the new BigInteger class from .net 4.0

But there are still problems with some plugins (Keysearcher, BigInteger Operations...)

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;
8using System.Numerics;
9
10namespace KeySearcher
11{
12    /**
13     * This class is able to split a KeyPattern into several disjunct parts, which are guaranteed to have equal size.
14     * It tries to split the pattern in such a way, that the parts have nearly the given partsize.
15     **/
16    public class KeyPatternPool
17    {
18        private BigInteger partsize;
19        private BigInteger counter = 0;
20        private KeyPattern pattern;
21        private Stack<KeyPattern> stack = new Stack<KeyPattern>();
22        private int[] splittingQuotient;
23        private int[] splittingCounter;
24        private bool end = false;
25
26        private void CalculateSplitting()
27        {
28            for (int c = pattern.wildcardList.Count - 1; c >= 0; c--)
29                splittingQuotient[c] = 1;
30
31            BigInteger bestSize = GetPartSize();
32
33            for (int c = pattern.wildcardList.Count - 1; c >= 0; c--)
34            {
35                int d = ((Wildcard)pattern.wildcardList[c]).size();
36                for (int k = 1; k <= d; k++)
37                {                   
38                    if (d % k == 0)
39                    {
40                        int tmp = splittingQuotient[c];
41                        splittingQuotient[c] = k;
42                        BigInteger size = GetPartSize();
43                        if (BigInteger.Abs((size - partsize)) < BigInteger.Abs(bestSize - partsize))
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 (long)(TotalAmount() + stack.Count - counter);
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.