Changeset 1135


Ignore:
Timestamp:
Feb 8, 2010, 11:08:46 PM (12 years ago)
Author:
Sven Rech
Message:

fixed KeyPattern stuff

Location:
trunk/CrypPlugins/KeySearcher
Files:
2 edited

Legend:

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

    r1129 r1135  
    8383            }
    8484            if (!s)
    85                 throw new Exception("Can't be split!");
     85                return null;
    8686            return patterns;
    8787        }
     
    374374            }
    375375            return res;
    376         }
    377 
    378         private Stack<KeyPattern> makeKeySearcherPool(BigInteger partsize, Stack<KeyPattern> stack)
    379         {
    380             if (stack == null)
    381                 stack = new Stack<KeyPattern>();
    382 
    383             if (size() > partsize)
    384             {
    385                 KeyPattern[] patterns = split();
    386                 stack.Push(patterns[1]);
    387                 return patterns[0].makeKeySearcherPool(partsize, stack);
    388             }
    389             else
    390             {
    391                 stack.Push(this);
    392                 return stack;
    393             }
    394         }
    395 
    396         /**
    397          * Creates a pool of splitted parts of this pattern.
    398          * The parts shouldn't be larger than 'partsize'.
    399          * Do not call this before initializing the key.
    400          * You have to get the single parts of this pool by calling the 'getNextPatternPart' method
    401          * with the returning stack as parameter.
    402          **/
    403         public Stack<KeyPattern> makeKeySearcherPool(BigInteger partsize)
    404         {
    405             return makeKeySearcherPool(partsize, null);
    406         }
    407 
    408         public Stack<KeyPattern> makeKeySearcherPool(long partsize)
    409         {
    410             return makeKeySearcherPool(new BigInteger(partsize), null);
    411         }
    412        
    413         /**
    414          * Gets the next KeyPattern from the created pool.
    415          * Returns 'null' if there are no parts left.
    416          **/
    417         public static KeyPattern getNextPatternPartFromPool(BigInteger partsize, Stack<KeyPattern> stack)
    418         {
    419             if (stack.Count == 0)
    420                 return null;
    421             KeyPattern top = stack.Pop();
    422             if (top.size() > partsize)
    423             {
    424                 KeyPattern[] patterns = top.split();
    425                 stack.Push(patterns[1]);
    426                 stack.Push(patterns[0]);
    427                 return getNextPatternPartFromPool(partsize, stack);
    428             }
    429             else           
    430                 return top;           
    431         }
     376        }       
    432377
    433378         /*
  • trunk/CrypPlugins/KeySearcher/KeySearcher.cs

    r1089 r1135  
    281281            KeyPattern pattern = patterns[threadid];
    282282
    283             bool useKeyblocks = true;
     283            bool useKeyblocks = false;
    284284
    285285            try
     
    298298                            maxThreadMutex.WaitOne();
    299299                            if (maxThread == threadid && threadStack.Count != 0)
    300                             {
    301                                 try
     300                            {                               
     301                                KeyPattern[] split = pattern.split();
     302                                if (split != null)
    302303                                {
    303                                     KeyPattern[] split = pattern.split();
    304304                                    patterns[threadid] = split[0];
    305305                                    pattern = split[0];
     
    309309                                    size = pattern.size();
    310310                                    keysLeft[threadid] = size;
    311                                 }
    312                                 catch (Exception e)
    313                                 {
    314                                     //pattern can't be split? who cares :)
    315                                 }
     311                                }                           
    316312                                maxThread = -1;
    317313                            }
     
    783779            {
    784780                KeyPattern[] patterns2 = pattern.split();
     781                if (patterns2 == null)
     782                {
     783                    patterns2 = new KeyPattern[1];
     784                    patterns2[0] = pattern;
     785                    return patterns2;
     786                }
    785787                patterns[0] = patterns2[0];
    786788                patterns[1] = patterns2[1];
     
    798800                        }
    799801                    KeyPattern[] patterns3 = patterns[maxPattern].split();
     802                    if (patterns3 == null)
     803                    {
     804                        patterns3 = new KeyPattern[p+1];
     805                        for (int i = 0; i <= p; i++)
     806                            patterns3[i] = patterns[i];
     807                        return patterns3;
     808                    }
    800809                    patterns[maxPattern] = patterns3[0];
    801810                    patterns[++p] = patterns3[1];
Note: See TracChangeset for help on using the changeset viewer.