Changeset 2086


Ignore:
Timestamp:
Nov 14, 2010, 5:32:51 PM (11 years ago)
Author:
Sven Rech
Message:

KeySearcher OpenCL implementation

Location:
trunk
Files:
2 added
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPluginBase/Control/KeyTranslator.cs

    r2061 r2086  
    2424    public interface IKeyTranslator
    2525    {
     26        /// <summary>
     27        /// This method returns the byte array key which is represented by the given parameter string.
     28        /// This method is completely stateless.
     29        /// </summary>
     30        /// <param name="representation"></param>
     31        /// <returns></returns>
     32        byte[] GetKeyFromRepresentation(string representation);
     33
    2634        /// <summary>
    2735        /// The parameter "keys" determines the keys this KeyTranslator should iterate over.
  • trunk/CrypPlugins/AES/AES.csproj

    r2061 r2086  
    172172  </ItemGroup>
    173173  <ItemGroup>
    174     <None Include="OpenCL\AESOpenCL.cl" />
     174    <Resource Include="OpenCL\AESOpenCL.cl" />
    175175  </ItemGroup>
    176176  <ItemGroup>
  • trunk/CrypPlugins/AES/OpenCL/AESOpenCL.cl

    r2061 r2086  
    620620
    621621        rk[0] = GETU32(userKey     );
    622         rk[0] += $$ADDKEYBYTE0$$ | ($$ADDKEYBYTE1$$ << 8) | ($$ADDKEYBYTE2$$ << 16) |($$ADDKEYBYTE3$$ << 24);
     622        rk[0] += $$ADDKEYBYTE3$$ | ($$ADDKEYBYTE2$$ << 8) | ($$ADDKEYBYTE1$$ << 16) |($$ADDKEYBYTE0$$ << 24);
    623623        rk[1] = GETU32(userKey +  4);
    624         rk[1] += $$ADDKEYBYTE4$$ | ($$ADDKEYBYTE5$$ << 8) | ($$ADDKEYBYTE6$$ << 16) |($$ADDKEYBYTE7$$ << 24);
     624        rk[1] += $$ADDKEYBYTE7$$ | ($$ADDKEYBYTE6$$ << 8) | ($$ADDKEYBYTE5$$ << 16) |($$ADDKEYBYTE4$$ << 24);
    625625        rk[2] = GETU32(userKey +  8);
    626         rk[2] += $$ADDKEYBYTE8$$ | ($$ADDKEYBYTE9$$ << 8) | ($$ADDKEYBYTE10$$ << 16) |($$ADDKEYBYTE11$$ << 24);
     626        rk[2] += $$ADDKEYBYTE11$$ | ($$ADDKEYBYTE10$$ << 8) | ($$ADDKEYBYTE9$$ << 16) |($$ADDKEYBYTE8$$ << 24);
    627627        rk[3] = GETU32(userKey + 12);
    628         rk[3] += $$ADDKEYBYTE12$$ | ($$ADDKEYBYTE13$$ << 8) | ($$ADDKEYBYTE14$$ << 16) |($$ADDKEYBYTE15$$ << 24);
     628        rk[3] += $$ADDKEYBYTE15$$ | ($$ADDKEYBYTE14$$ << 8) | ($$ADDKEYBYTE13$$ << 16) |($$ADDKEYBYTE12$$ << 24);
    629629        if (bits == 128) {
    630630                while (1) {
     
    646646        }
    647647        rk[4] = GETU32(userKey + 16);
    648         rk[4] += $$ADDKEYBYTE16$$ | ($$ADDKEYBYTE17$$ << 8) | ($$ADDKEYBYTE18$$ << 16) |($$ADDKEYBYTE19$$ << 24);
     648        rk[4] += $$ADDKEYBYTE19$$ | ($$ADDKEYBYTE18$$ << 8) | ($$ADDKEYBYTE17$$ << 16) |($$ADDKEYBYTE16$$ << 24);
    649649        rk[5] = GETU32(userKey + 20);
    650         rk[5] += $$ADDKEYBYTE20$$ | ($$ADDKEYBYTE21$$ << 8) | ($$ADDKEYBYTE22$$ << 16) |($$ADDKEYBYTE23$$ << 24);
     650        rk[5] += $$ADDKEYBYTE23$$ | ($$ADDKEYBYTE22$$ << 8) | ($$ADDKEYBYTE21$$ << 16) |($$ADDKEYBYTE20$$ << 24);
    651651        if (bits == 192) {
    652652                while (1) {
     
    670670        }
    671671        rk[6] = GETU32(userKey + 24);
    672         rk[6] += $$ADDKEYBYTE24$$ | ($$ADDKEYBYTE25$$ << 8) | ($$ADDKEYBYTE26$$ << 16) |($$ADDKEYBYTE27$$ << 24);
     672        rk[6] += $$ADDKEYBYTE27$$ | ($$ADDKEYBYTE26$$ << 8) | ($$ADDKEYBYTE25$$ << 16) |($$ADDKEYBYTE24$$ << 24);
    673673        rk[7] = GETU32(userKey + 28);
    674         rk[7] += $$ADDKEYBYTE28$$ | ($$ADDKEYBYTE29$$ << 8) | ($$ADDKEYBYTE30$$ << 16) |($$ADDKEYBYTE31$$ << 24);
     674        rk[7] += $$ADDKEYBYTE31$$ | ($$ADDKEYBYTE30$$ << 8) | ($$ADDKEYBYTE29$$ << 16) |($$ADDKEYBYTE28$$ << 24);
    675675        if (bits == 256) {
    676676                while (1) {
     
    883883kernel void bruteforceKernel(global unsigned char *userKey, global float *results)
    884884{
    885         size_t x = get_global_id(1) * get_global_size(0) + get_global_id(0);   
     885        size_t x = get_global_id(0);
    886886       
    887887        AES_KEY key;   
     
    895895        $$AESDECRYPT$$
    896896       
    897 resultcalculation:
    898897        //calculate result here:
    899898        float result = 0.0f;
  • trunk/CrypPlugins/CostFunction/CostFunction.cs

    r2061 r2086  
    500500
    501501        private int lastUsedSize = -1;
    502         private double[] xlogx;
     502        private float[] xlogx;
    503503        private Mutex prepareMutex = new Mutex();
    504504        private bool testing = false;
     
    506506        private void prepareEntropy(int size)
    507507        {
    508             xlogx = new double[size + 1];
     508            xlogx = new float[size + 1];
    509509            //precomputations for fast entropy calculation     
    510             xlogx[0] = 0.0;
     510            xlogx[0] = 0.0f;
    511511            for (int i = 1; i <= size; i++)
    512                 xlogx[i] = -1.0 * i * Math.Log(i / (double)size) / Math.Log(2.0);
     512                xlogx[i] = (float) (-1.0f * i * Math.Log(i / (double)size) / Math.Log(2.0));
    513513        }
    514514
     
    816816                + "result += xlogx[distr[i++]]; \n "
    817817                + "} \n "
    818                 + string.Format("result /= {0}f;", bytesToUse));
     818                + string.Format("result /= {0}.0f;", bytesToUse));
    819819
    820820            return code;
  • trunk/CrypPlugins/CostFunction/RegEx.cs

    r2061 r2086  
    9090            {
    9191                //return false:
    92                 return code.Replace("$$COSTFUNCTIONDECLARATIONS$$", "").Replace("$$COSTFUNCTIONINITIALIZE$$", "goto resultcalculation;")
    93                     .Replace("$$COSTFUNCTIONCALCULATE$$", "").Replace("$$COSTFUNCTIONRESULTCALCULATION$$", "result = -1;");
     92                return code.Replace("$$COSTFUNCTIONDECLARATIONS$$", "").Replace("$$COSTFUNCTIONINITIALIZE$$", "results[x] = -1.0f; return;")
     93                    .Replace("$$COSTFUNCTIONCALCULATE$$", "").Replace("$$COSTFUNCTIONRESULTCALCULATION$$", "result = -1.0f;");
    9494            }
    9595
     
    113113
    114114            //calculation code:
    115             code = code.Replace("$$COSTFUNCTIONCALCULATE$$", "int absState = state >= 0 ? state : ~state; \n"
     115            code = code.Replace("$$COSTFUNCTIONCALCULATE$$", "int absState = ((state >= 0) ? state : ~state); \n"
    116116                + "state = transitionMatrix[absState*256+c]; \n"
    117                 + "if (state == NOTRANSITION) goto resultcalculation; \n");
     117                + "if (state == NOTRANSITION) { results[x] = -1.0f; return;} \n");
    118118
    119119            //result calculation code:
    120             code = code.Replace("$$COSTFUNCTIONRESULTCALCULATION$$", "if (state < 0) result = 1.0; else result = -1.0;");
     120            code = code.Replace("$$COSTFUNCTIONRESULTCALCULATION$$", "if (state < 0) result = 1.0f; else result = -1.0f;");
    121121
    122122            return code;
  • trunk/CrypPlugins/KeySearcher/KeySearcher.cs

    r2061 r2086  
    1717using System;
    1818using System.Diagnostics;
     19using System.IO;
    1920using System.Linq;
    2021using System.Text;
     
    238239            {
    239240                oclManager = new OpenCLManager();
     241                oclManager.AttemptUseBinaries = false;
     242                oclManager.AttemptUseSource = true;
     243                oclManager.RequireImageSupport = false;
     244                oclManager.BuildOptions = "";
    240245                oclManager.CreateDefaultContext(0, DeviceType.ALL);
    241246            }
     
    361366            int bytesToUse = (int)parameters[6];
    362367            Stack threadStack = (Stack)parameters[7];
    363 
    364             KeyPattern.KeyPattern pattern = patterns[threadid];
    365            
     368            bool useOpenCL = (bool)parameters[8];
     369
     370            KeySearcherOpenCLCode keySearcherOpenCLCode = null;
     371            if (useOpenCL)
     372                keySearcherOpenCLCode = new KeySearcherOpenCLCode(encryptedData, sender, CostMaster, 256 * 64);
     373
    366374            try
    367375            {
    368                 while (pattern != null)
    369                 {
    370                     BigInteger size = pattern.size();
     376                while (patterns[threadid] != null)
     377                {
     378                    BigInteger size = patterns[threadid].size();
    371379                    keysLeft[threadid] = size;
    372 
     380                   
    373381                    IKeyTranslator keyTranslator = ControlMaster.getKeyTranslator();
    374                     keyTranslator.SetKeys(pattern);
     382                    keyTranslator.SetKeys(patterns[threadid]);
    375383
    376384                    bool finish = false;
     
    379387                    {
    380388                        //if we are the thread with most keys left, we have to share them:
    381                         if (maxThread == threadid && threadStack.Count != 0)
     389                        keyTranslator = ShareKeys(patterns, threadid, keysLeft, keyTranslator, threadStack);
     390
     391                        if (!useOpenCL)         //CPU
     392                        {
     393                            finish = BruteforceCPU(keyTranslator, sender, bytesToUse);
     394                        }
     395                        else                    //OpenCL
    382396                        {
    383397                            try
    384398                            {
    385                                 maxThreadMutex.WaitOne();
    386                                 if (maxThread == threadid && threadStack.Count != 0)
    387                                 {
    388                                     KeyPattern.KeyPattern[] split = pattern.split();
    389                                     if (split != null)
    390                                     {
    391                                         patterns[threadid] = split[0];
    392                                         pattern = split[0];
    393                                         keyTranslator = ControlMaster.getKeyTranslator();
    394                                         keyTranslator.SetKeys(pattern);
    395 
    396                                         ThreadStackElement elem = (ThreadStackElement)threadStack.Pop();
    397                                         patterns[elem.threadid] = split[1];
    398                                         elem.ev.Set();    //wake the other thread up                                   
    399                                         size = pattern.size();
    400                                         keysLeft[threadid] = size;
    401                                     }
    402                                     maxThread = -1;
    403                                 }
     399                                finish = BruteforceOpenCL(keySearcherOpenCLCode, keyTranslator, sender, bytesToUse);
    404400                            }
    405                             finally
     401                            catch (Exception)
    406402                            {
    407                                 maxThreadMutex.ReleaseMutex();
     403                                useOpenCL = false;
     404                                continue;
    408405                            }
    409406                        }
    410 
    411                         for (int count = 0; count < 256 * 256; count++)
    412                         {
    413                             byte[] keya = keyTranslator.GetKey();
    414 
    415                             if (!decryptAndCalculate(sender, bytesToUse, keya, keyTranslator))
    416                                 return;
    417 
    418                             finish = !keyTranslator.NextKey();
    419                             if (finish)
    420                                 break;
    421                         }
     407                       
    422408                        int progress = keyTranslator.GetProgress();
    423409
     
    432418
    433419                    //Let's wait until another thread is willing to share with us:
    434                     pattern = null;
    435                     ThreadStackElement el = new ThreadStackElement();
    436                     el.ev = new AutoResetEvent(false);
    437                     el.threadid = threadid;
    438                     patterns[threadid] = null;
    439                     threadStack.Push(el);
    440                     GuiLogMessage("Thread waiting for new keys.", NotificationLevel.Debug);
    441                     el.ev.WaitOne();
    442                     if (!stop)
     420                    WaitForNewPattern(patterns, threadid, threadStack);
     421                }
     422            }
     423            finally
     424            {
     425                sender.Dispose();
     426            }
     427        }
     428
     429        private unsafe bool BruteforceOpenCL(KeySearcherOpenCLCode keySearcherOpenCLCode, IKeyTranslator keyTranslator, IControlEncryption sender, int bytesToUse)
     430        {
     431            float[] costArray = new float[keySearcherOpenCLCode.GetBruteforceBlock()];
     432            try
     433            {
     434                Kernel bruteforceKernel = keySearcherOpenCLCode.GetBruteforceKernel(oclManager, keyTranslator);
     435                int deviceIndex = settings.OpenCLDevice;
     436               
     437                Mem costs = oclManager.Context.CreateBuffer(MemFlags.READ_ONLY, costArray.Length * 4);
     438                IntPtr[] globalWorkSize = { (IntPtr)keySearcherOpenCLCode.GetBruteforceBlock() };
     439
     440                Mem userKey;
     441                var key = keyTranslator.GetKey();
     442                fixed (byte* ukp = key)
     443                    userKey = oclManager.Context.CreateBuffer(MemFlags.USE_HOST_PTR, key.Length, new IntPtr((void*)ukp));
     444
     445                bruteforceKernel.SetArg(0, userKey);
     446                bruteforceKernel.SetArg(1, costs);
     447
     448                oclManager.CQ[deviceIndex].EnqueueNDRangeKernel(bruteforceKernel, 1, null, globalWorkSize, null);
     449                oclManager.CQ[deviceIndex].EnqueueBarrier();
     450
     451                Event e;
     452                fixed (float* costa = costArray)
     453                    oclManager.CQ[deviceIndex].EnqueueReadBuffer(costs, true, 0, costArray.Length * 4, new IntPtr((void*)costa), 0, null, out e);
     454
     455                e.Wait();
     456                costs.Dispose();
     457            }
     458            catch (Exception ex)
     459            {
     460                GuiLogMessage(ex.Message, NotificationLevel.Error);
     461                GuiLogMessage("Bruteforcing with OpenCL failed! Using CPU instead.", NotificationLevel.Error);
     462                throw new Exception("Bruteforcing with OpenCL failed!");
     463            }
     464
     465            //Check results:
     466            var op = this.costMaster.getRelationOperator();
     467            for (int i = 0; i < costArray.Length; i++)
     468            {
     469                float cost = costArray[i];
     470                if (((op == RelationOperator.LargerThen) && (cost > value_threshold))
     471                    || (op == RelationOperator.LessThen) && (cost < value_threshold))
     472                {
     473                    ValueKey valueKey = new ValueKey {value = cost, key = keyTranslator.GetKeyRepresentation(i)};
     474                    valueKey.keya = keyTranslator.GetKeyFromRepresentation(valueKey.key);
     475                    valueKey.decryption = sender.Decrypt(this.encryptedData, valueKey.keya, InitVector, bytesToUse);
     476                    valuequeue.Enqueue(valueKey);
     477                }
     478            }
     479
     480            return !keyTranslator.NextOpenCLBatch();
     481        }
     482
     483        private bool BruteforceCPU(IKeyTranslator keyTranslator, IControlEncryption sender, int bytesToUse)
     484        {
     485            bool finish = false;
     486            for (int count = 0; count < 256 * 256; count++)
     487            {
     488                byte[] keya = keyTranslator.GetKey();
     489
     490                if (!decryptAndCalculate(sender, bytesToUse, keya, keyTranslator))
     491                    throw new Exception("Bruteforcing not possible!");
     492
     493                finish = !keyTranslator.NextKey();
     494                if (finish)
     495                    break;
     496            }
     497            return finish;
     498        }
     499
     500        private IKeyTranslator ShareKeys(KeyPattern.KeyPattern[] patterns, int threadid, BigInteger[] keysLeft, IKeyTranslator keyTranslator, Stack threadStack)
     501        {
     502            BigInteger size;
     503            if (maxThread == threadid && threadStack.Count != 0)
     504            {
     505                try
     506                {
     507                    maxThreadMutex.WaitOne();
     508                    if (maxThread == threadid && threadStack.Count != 0)
    443509                    {
    444                         GuiLogMessage("Thread waking up with new keys.", NotificationLevel.Debug);
    445                         pattern = patterns[threadid];
     510                        KeyPattern.KeyPattern[] split = patterns[threadid].split();
     511                        if (split != null)
     512                        {
     513                            patterns[threadid] = split[0];
     514                            keyTranslator = ControlMaster.getKeyTranslator();
     515                            keyTranslator.SetKeys(patterns[threadid]);
     516
     517                            ThreadStackElement elem = (ThreadStackElement)threadStack.Pop();
     518                            patterns[elem.threadid] = split[1];
     519                            elem.ev.Set();    //wake the other thread up                                   
     520                            size = patterns[threadid].size();
     521                            keysLeft[threadid] = size;
     522                        }
     523                        maxThread = -1;
    446524                    }
    447525                }
    448             }
    449             finally
    450             {
    451                 sender.Dispose();
     526                finally
     527                {
     528                    maxThreadMutex.ReleaseMutex();
     529                }
     530            }
     531            return keyTranslator;
     532        }
     533
     534        private void WaitForNewPattern(KeyPattern.KeyPattern[] patterns, int threadid, Stack threadStack)
     535        {
     536            ThreadStackElement el = new ThreadStackElement();
     537            el.ev = new AutoResetEvent(false);
     538            el.threadid = threadid;
     539            patterns[threadid] = null;
     540            threadStack.Push(el);
     541            GuiLogMessage("Thread waiting for new keys.", NotificationLevel.Debug);
     542            el.ev.WaitOne();
     543            if (!stop)
     544            {
     545                GuiLogMessage("Thread waking up with new keys.", NotificationLevel.Debug);
    452546            }
    453547        }
     
    600694            BigInteger size = pattern.size();
    601695            KeyPattern.KeyPattern[] patterns = splitPatternForThreads(pattern);
     696            if (patterns == null || patterns.Length == 0)
     697            {
     698                GuiLogMessage("No ressources to BruteForce available. Check the KeySearcher settings!", NotificationLevel.Error);
     699                throw new Exception("No ressources to BruteForce available. Check the KeySearcher settings!");
     700            }
    602701
    603702            BigInteger[] doneKeysA = new BigInteger[patterns.Length];
     
    605704            BigInteger[] keysleft = new BigInteger[patterns.Length];
    606705            Stack threadStack = Stack.Synchronized(new Stack());
    607             startThreads(sender, bytesToUse, patterns, doneKeysA, keycounters, keysleft, threadStack);
     706            StartThreads(sender, bytesToUse, patterns, doneKeysA, keycounters, keysleft, threadStack);
    608707
    609708            DateTime lastTime = DateTime.Now;
     
    711810        }
    712811
    713         private string CreateOpenCLBruteForceCode(KeyPattern.KeyPattern keyPattern)
    714         {
    715             try
    716             {
    717                 string code = sender.GetOpenCLCode(CostMaster.getBytesToUse());
    718                 if (code == null)
    719                     throw new Exception("OpenCL not supported in this configuration!");
    720 
    721                 //put cost function stuff into code:
    722                 code = costMaster.ModifyOpenCLCode(code);
    723 
    724                 //put input to be bruteforced into code:
    725                 string inputarray = string.Format("__constant unsigned char inn[{0}] = {{ \n", CostMaster.getBytesToUse());
    726                 for (int i = 0; i < CostMaster.getBytesToUse(); i++)
    727                 {
    728                     inputarray += String.Format("0x{0:X2}, ", this.encryptedData[i]);
    729                 }
    730                 inputarray = inputarray.Substring(0, inputarray.Length - 2);
    731                 inputarray += "}; \n";
    732                 code = code.Replace("$$INPUTARRAY$$", inputarray);
    733 
    734                 //put key movement of pattern into code:
    735                 IKeyTranslator keyTranslator = ControlMaster.getKeyTranslator();
    736                 keyTranslator.SetKeys(pattern);
    737                 code = keyTranslator.ModifyOpenCLCode(code, 256*256);
    738 
    739                 return code;
    740             }
    741             catch (Exception ex)
    742             {
    743                 GuiLogMessage("Error trying to generate OpenCL code: " + ex.Message, NotificationLevel.Error);
    744                 return null;
    745             }
    746         }
     812
    747813
    748814        private void SetStartDate()
     
    9451011        #endregion
    9461012
    947         private void startThreads(IControlEncryption sender, int bytesToUse, KeyPattern.KeyPattern[] patterns, BigInteger[] doneKeysA, BigInteger[] keycounters, BigInteger[] keysleft, Stack threadStack)
     1013        private void StartThreads(IControlEncryption sender, int bytesToUse, KeyPattern.KeyPattern[] patterns, BigInteger[] doneKeysA, BigInteger[] keycounters, BigInteger[] keysleft, Stack threadStack)
    9481014        {
    9491015            for (int i = 0; i < patterns.Length; i++)
     
    9521018                doneKeysA[i] = new BigInteger();
    9531019                keycounters[i] = new BigInteger();
    954                 //ThreadPool.QueueUserWorkItem(worker, new object[] { patterns, i, doneKeysA, keycounters, keysleft, sender.clone(), bytesToUse, threadStack });
    955                 ThreadPool.QueueUserWorkItem(worker, new object[] { patterns, i, doneKeysA, keycounters, keysleft, sender, bytesToUse, threadStack });
     1020                bool useOpenCL = false;
     1021
     1022                if (settings.UseOpenCL && (i == patterns.Length - 1))     //Last thread is the OpenCL thread
     1023                    useOpenCL = true;
     1024
     1025                ThreadPool.QueueUserWorkItem(worker, new object[] { patterns, i, doneKeysA, keycounters, keysleft, sender, bytesToUse, threadStack, useOpenCL });
    9561026            }
    9571027        }
     
    9591029        private KeyPattern.KeyPattern[] splitPatternForThreads(KeyPattern.KeyPattern pattern)
    9601030        {
    961             KeyPattern.KeyPattern[] patterns = new KeyPattern.KeyPattern[settings.CoresUsed + 1];
    962             if (settings.CoresUsed > 0)
     1031            int threads = settings.CoresUsed;
     1032            if (settings.UseOpenCL)
     1033                threads++;
     1034
     1035            if (threads < 1)
     1036                return null;
     1037
     1038            KeyPattern.KeyPattern[] patterns = new KeyPattern.KeyPattern[threads];
     1039            if (threads > 1)
    9631040            {
    9641041                KeyPattern.KeyPattern[] patterns2 = pattern.split();
     
    9721049                patterns[1] = patterns2[1];
    9731050                int p = 1;
    974                 int threads = settings.CoresUsed - 1;
     1051                threads -= 2;
     1052
    9751053                while (threads > 0)
    9761054                {
  • trunk/CrypPlugins/KeySearcher/KeySearcher.csproj

    r2040 r2086  
    4242    <Optimize>true</Optimize>
    4343    <DefineConstants>TRACE</DefineConstants>
     44    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
    4445  </PropertyGroup>
    4546  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
     
    5152    <Optimize>true</Optimize>
    5253    <DefineConstants>TRACE</DefineConstants>
     54    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
    5355  </PropertyGroup>
    5456  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
     
    6163    <Optimize>false</Optimize>
    6264    <DefineConstants>DEBUG;TRACE</DefineConstants>
     65    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
    6366  </PropertyGroup>
    6467  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
     
    7174    <Optimize>false</Optimize>
    7275    <DefineConstants>DEBUG;TRACE</DefineConstants>
     76    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
    7377  </PropertyGroup>
    7478  <ItemGroup Condition=" '$(Platform)' == 'x86' " />
     
    117121    <Compile Include="KeySearcher.cs" />
    118122    <Compile Include="KeyTranslators\ByteArrayKeyTranslator.cs" />
     123    <Compile Include="OpenCL\KeySearcherOpenCLCode.cs" />
    119124    <Compile Include="P2P\Helper\ConnectionHelper.cs" />
    120125    <Compile Include="P2P\Helper\DatabaseStatistics.cs" />
  • trunk/CrypPlugins/KeySearcher/KeySearcherSettings.cs

    r2043 r2086  
    2929
    3030            CoresAvailable.Clear();
    31             for (int i = 0; i < Environment.ProcessorCount; i++)
     31            for (int i = -1; i < Environment.ProcessorCount; i++)
    3232                CoresAvailable.Add((i + 1).ToString());
    3333            CoresUsed = Environment.ProcessorCount - 1;
  • trunk/CrypPlugins/KeySearcher/KeyTranslators/ByteArrayKeyTranslator.cs

    r2061 r2086  
    3636        private int[] movementPointers;
    3737        private IKeyMovement[] keyMovements;
    38         private int openCLIndex = -1;
    39         private int openCLSize;
     38        private int openCLIndex;
     39        private int openCLSize = 0;
    4040
    4141        #region KeyTranslator Members
     42
     43        public byte[] GetKeyFromRepresentation(string representation)
     44        {
     45            byte[] bkey = new byte[keya.Length];
     46            for (int i = 0; i < bkey.Length; i++)
     47            {
     48                try
     49                {
     50                    string substr = representation.Substring(i * 3, 2);
     51                    bkey[i] = Convert.ToByte(substr, 16);
     52                }
     53                catch (Exception ex)
     54                {
     55                    return null;
     56                }
     57            }
     58            return bkey;
     59        }
    4260
    4361        public void SetKeys(object keys)
     
    117135        private bool IncrementMovementStatus(int index)
    118136        {
     137            if (index < 0)
     138                return false;
     139
    119140            movementStatus[index]++;
    120141           
     
    269290            //put movement strings in code:
    270291            for (int y = 0; y < movementStrings.Length; y++)
    271                 code = code.Replace(byteReplaceStrings[y], movementStrings[y] ?? "0");
     292                code = code.Replace(byteReplaceStrings[y], movementStrings[y] != null ? ("("+movementStrings[y]+")") : "0");
    272293
    273294            code = code.Replace("$$MOVEMENTDECLARATIONS$$", "");
     
    282303        public bool NextOpenCLBatch()
    283304        {
    284             if (openCLIndex > -1)
     305            if (openCLSize > 0)
    285306            {
    286307                progress += openCLSize;
  • trunk/CrypPlugins/SDES/SDES.cs

    r2061 r2086  
    740740        #region KeyTranslator Members
    741741
    742         public void SetKeys(object keys)
    743         {
    744             if (!(keys is KeyPattern))
    745                 throw new Exception("Something went horribly wrong!");
    746 
    747             pattern = (KeyPattern)keys;
    748         }
    749 
    750         public byte[] GetKey()
    751         {
    752             string key = pattern.getKey();
     742        public byte[] GetKeyFromRepresentation(string representation)
     743        {
    753744            byte[] bkey = new byte[10];
    754745            int count = 0;
    755             foreach (char c in key)
     746            foreach (char c in representation)
    756747                if (c == '0')
    757748                    bkey[count++] = 0;
     
    759750                    bkey[count++] = 1;
    760751            return bkey;
     752        }
     753
     754        public void SetKeys(object keys)
     755        {
     756            if (!(keys is KeyPattern))
     757                throw new Exception("Something went horribly wrong!");
     758
     759            pattern = (KeyPattern)keys;
     760        }
     761
     762        public byte[] GetKey()
     763        {
     764            string key = pattern.getKey();
     765            return GetKeyFromRepresentation(key);
    761766        }
    762767
Note: See TracChangeset for help on using the changeset viewer.