Changeset 2202


Ignore:
Timestamp:
Dec 13, 2010, 8:32:06 PM (11 years ago)
Author:
Sven Rech
Message:

Added code for using keysearcher with external client.

External client not available yet.

Location:
trunk/CrypPlugins/KeySearcher
Files:
5 added
3 edited

Legend:

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

    r2194 r2202  
    1919using System.IO;
    2020using System.Linq;
     21using System.Net;
    2122using System.Text;
    2223using Cryptool.P2P;
     
    3435using System.Numerics;
    3536using KeySearcher.Helper;
     37using KeySearcher.KeyPattern;
    3638using KeySearcher.P2P;
    3739using KeySearcher.P2P.Exceptions;
     
    238240        private AutoResetEvent connectResetEvent;
    239241
     242        #region external client variables
     243        private CryptoolServer cryptoolServer;
     244        private KeySearcherOpenCLCode externalKeySearcherOpenCLCode;
     245        private IKeyTranslator externalKeyTranslator;
     246        private int externalKeysProcessed;
     247        private EndPoint externalClientConnected;
     248        private AutoResetEvent waitForExternalClientToFinish = new AutoResetEvent(false);
     249        #endregion
     250
    240251        public KeySearcher()
    241252        {
     
    331342            IsKeySearcherRunning = false;
    332343            stop = true;
     344            waitForExternalClientToFinish.Set();
    333345        }
    334346
     
    739751            }
    740752
    741             if (settings.UsePeerToPeer)
    742             {
    743                 BruteForceWithPeerToPeerSystem();
    744                 return null;
    745             }
    746 
    747             return BruteForceWithLocalSystem(pattern);
     753            Thread serverThread = null;
     754            try
     755            {
     756                if (settings.UseExternalClient)
     757                {
     758                    GuiLogMessage("Waiting for external client!", NotificationLevel.Info);
     759                    cryptoolServer = new CryptoolServer();
     760                    externalClientConnected = null;
     761                    cryptoolServer.Port = settings.Port;
     762                    cryptoolServer.OnJobCompleted += new CryptoolServer.JobCompletedDelegate(server_OnJobCompleted);
     763                    cryptoolServer.OnClientConnected += new CryptoolServer.ClientConnectedDelegate(server_OnClientConnected);
     764                    cryptoolServer.OnClientDisconnected += new CryptoolServer.ClientDisconnectedDelegate(cryptoolServer_OnClientDisconnected);
     765                    serverThread = new Thread(new ThreadStart(delegate
     766                                                                      {
     767                                                                          cryptoolServer.Run();
     768                                                                      }));
     769                    serverThread.Start();
     770                }
     771
     772                if (settings.UsePeerToPeer)
     773                {
     774                    BruteForceWithPeerToPeerSystem();
     775                    return null;
     776                }
     777
     778                return BruteForceWithLocalSystem(pattern);
     779            }
     780            finally
     781            {
     782                if (stop && serverThread != null)
     783                {
     784                    //stop server here!
     785                }
     786            }
    748787        }
    749788
     
    793832            }
    794833
    795             BigInteger size = pattern.size();
    796             KeyPattern.KeyPattern[] patterns = splitPatternForThreads(pattern);
    797             if (patterns == null || patterns.Length == 0)
    798             {
    799                 GuiLogMessage("No ressources to BruteForce available. Check the KeySearcher settings!", NotificationLevel.Error);
    800                 throw new Exception("No ressources to BruteForce available. Check the KeySearcher settings!");
    801             }
    802 
    803             BigInteger[] doneKeysA = new BigInteger[patterns.Length];
    804             BigInteger[] openCLDoneKeysA = new BigInteger[patterns.Length];
    805             BigInteger[] keycounters = new BigInteger[patterns.Length];
    806             BigInteger[] keysleft = new BigInteger[patterns.Length];
    807             Stack threadStack = Stack.Synchronized(new Stack());
    808             threadsStopEvents = ArrayList.Synchronized(new ArrayList());
    809             StartThreads(sender, bytesToUse, patterns, doneKeysA, openCLDoneKeysA, keycounters, keysleft, threadStack);
    810 
    811             DateTime lastTime = DateTime.Now;
    812 
    813             //update message:
    814             while (!stop)
    815             {
    816                 Thread.Sleep(2000);
    817 
    818                 updateToplist();
    819 
    820                 #region calculate global counters from local counters
    821                 BigInteger keycounter = 0;
    822                 BigInteger doneKeys = 0;
    823                 BigInteger openCLdoneKeys = 0;
    824                 foreach (BigInteger dk in doneKeysA)
    825                     doneKeys += dk;
    826                 foreach (BigInteger dk in openCLDoneKeysA)
    827                     openCLdoneKeys += dk;
    828                 foreach (BigInteger kc in keycounters)
    829                     keycounter += kc;
    830                 #endregion
    831 
    832                 if (keycounter > size)
    833                     GuiLogMessage("There must be an error, because we bruteforced too much keys...", NotificationLevel.Error);
    834 
    835                 #region determination of the thread with most keys
    836                 if (size - keycounter > 1000)
    837                 {
    838                     try
     834            if (settings.UseExternalClient)
     835            {
     836                GuiLogMessage("Only using external client to bruteforce!", NotificationLevel.Info);
     837                lock (this)
     838                {
     839                    externalKeySearcherOpenCLCode = new KeySearcherOpenCLCode(this, encryptedData, sender, CostMaster,
     840                                                                              256*256*256*64);
     841                    externalKeysProcessed = 0;
     842                    externalKeyTranslator = ControlMaster.getKeyTranslator();
     843                    externalKeyTranslator.SetKeys(pattern);
     844                    if (externalClientConnected != null)
     845                        AssignJobToClient(externalClientConnected, externalKeySearcherOpenCLCode.CreateOpenCLBruteForceCode(externalKeyTranslator));
     846                }
     847                waitForExternalClientToFinish.Reset();
     848                waitForExternalClientToFinish.WaitOne();
     849            }
     850            else
     851            {
     852                BigInteger size = pattern.size();
     853                KeyPattern.KeyPattern[] patterns = splitPatternForThreads(pattern);
     854                if (patterns == null || patterns.Length == 0)
     855                {
     856                    GuiLogMessage("No ressources to BruteForce available. Check the KeySearcher settings!", NotificationLevel.Error);
     857                    throw new Exception("No ressources to BruteForce available. Check the KeySearcher settings!");
     858                }
     859
     860                BigInteger[] doneKeysA = new BigInteger[patterns.Length];
     861                BigInteger[] openCLDoneKeysA = new BigInteger[patterns.Length];
     862                BigInteger[] keycounters = new BigInteger[patterns.Length];
     863                BigInteger[] keysleft = new BigInteger[patterns.Length];
     864                Stack threadStack = Stack.Synchronized(new Stack());
     865                threadsStopEvents = ArrayList.Synchronized(new ArrayList());
     866                StartThreads(sender, bytesToUse, patterns, doneKeysA, openCLDoneKeysA, keycounters, keysleft, threadStack);
     867
     868                DateTime lastTime = DateTime.Now;
     869
     870                //update message:
     871                while (!stop)
     872                {
     873                    Thread.Sleep(2000);
     874
     875                    updateToplist();
     876
     877                    #region calculate global counters from local counters
     878                    BigInteger keycounter = 0;
     879                    BigInteger doneKeys = 0;
     880                    BigInteger openCLdoneKeys = 0;
     881                    foreach (BigInteger dk in doneKeysA)
     882                        doneKeys += dk;
     883                    foreach (BigInteger dk in openCLDoneKeysA)
     884                        openCLdoneKeys += dk;
     885                    foreach (BigInteger kc in keycounters)
     886                        keycounter += kc;
     887                    #endregion
     888
     889                    if (keycounter > size)
     890                        GuiLogMessage("There must be an error, because we bruteforced too much keys...", NotificationLevel.Error);
     891
     892                    #region determination of the thread with most keys
     893                    if (size - keycounter > 1000)
    839894                    {
    840                         maxThreadMutex.WaitOne();
    841                         BigInteger max = 0;
    842                         int id = -1;
    843                         for (int i = 0; i < patterns.Length; i++)
    844                             if (keysleft[i] != null && keysleft[i] > max)
    845                             {
    846                                 max = keysleft[i];
    847                                 id = i;
    848                             }
    849                         maxThread = id;
     895                        try
     896                        {
     897                            maxThreadMutex.WaitOne();
     898                            BigInteger max = 0;
     899                            int id = -1;
     900                            for (int i = 0; i < patterns.Length; i++)
     901                                if (keysleft[i] != null && keysleft[i] > max)
     902                                {
     903                                    max = keysleft[i];
     904                                    id = i;
     905                                }
     906                            maxThread = id;
     907                        }
     908                        finally
     909                        {
     910                            maxThreadMutex.ReleaseMutex();
     911                        }
    850912                    }
    851                     finally
     913                    #endregion
     914
     915                    long keysPerSecond = (long)((long)doneKeys / (DateTime.Now - lastTime).TotalSeconds);
     916                    long openCLKeysPerSecond = (long)((long)openCLdoneKeys / (DateTime.Now - lastTime).TotalSeconds);
     917                    lastTime = DateTime.Now;
     918                    if (redirectResultsToStatisticsGenerator)
    852919                    {
    853                         maxThreadMutex.ReleaseMutex();
     920                        distributedBruteForceManager.StatisticsGenerator.ShowProgress(costList, size, keycounter, keysPerSecond);
    854921                    }
    855                 }
    856                 #endregion
    857 
    858                 long keysPerSecond = (long)((long)doneKeys/(DateTime.Now - lastTime).TotalSeconds);
    859                 long openCLKeysPerSecond = (long)((long)openCLdoneKeys / (DateTime.Now - lastTime).TotalSeconds);
    860                 lastTime = DateTime.Now;
    861                 if (redirectResultsToStatisticsGenerator)
    862                 {
    863                     distributedBruteForceManager.StatisticsGenerator.ShowProgress(costList, size, keycounter, keysPerSecond);
    864                 }
    865                 else
    866                 {
    867                     showProgress(costList, size, keycounter, keysPerSecond);
    868                 }
    869 
    870                 //show OpenCL keys/sec:
    871                 var ratio = (double) openCLdoneKeys/(double) doneKeys;
    872                 ((QuickWatch)QuickWatchPresentation).Dispatcher.BeginInvoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    873                 {
    874                     ((QuickWatch)QuickWatchPresentation).OpenCLPresentation.keysPerSecondOpenCL.Content = String.Format("{0:N}", openCLKeysPerSecond);
    875                     ((QuickWatch)QuickWatchPresentation).OpenCLPresentation.keysPerSecondCPU.Content = String.Format("{0:N}", (keysPerSecond - openCLKeysPerSecond));
    876                     ((QuickWatch)QuickWatchPresentation).OpenCLPresentation.ratio.Content = String.Format("{0:P}", ratio);
    877                 }, null);
    878                
    879 
    880                 #region set doneKeys to 0
    881                 doneKeys = 0;
    882                 for (int i = 0; i < doneKeysA.Length; i++)
    883                     doneKeysA[i] = 0;
    884                 openCLdoneKeys = 0;
    885                 for (int i = 0; i < openCLDoneKeysA.Length; i++)
    886                     openCLDoneKeysA[i] = 0;
    887                 #endregion
    888 
    889                 if (keycounter >= size)
    890                     break;
    891             }//end while
    892 
    893             showProgress(costList, 1, 1, 1);
    894 
    895             //wake up all sleeping threads, so they can stop:
    896             while (threadStack.Count != 0)
    897                 ((ThreadStackElement)threadStack.Pop()).ev.Set();
    898 
    899             //wait until all threads finished:
    900             foreach (AutoResetEvent stopEvent in threadsStopEvents)
    901             {
    902                 stopEvent.WaitOne();
    903             }
    904 
    905             if (!stop && !redirectResultsToStatisticsGenerator)
    906                 ProgressChanged(1, 1);
     922                    else
     923                    {
     924                        showProgress(costList, size, keycounter, keysPerSecond);
     925                    }
     926
     927                    //show OpenCL keys/sec:
     928                    var ratio = (double)openCLdoneKeys / (double)doneKeys;
     929                    ((QuickWatch)QuickWatchPresentation).Dispatcher.BeginInvoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     930                    {
     931                        ((QuickWatch)QuickWatchPresentation).OpenCLPresentation.keysPerSecondOpenCL.Content = String.Format("{0:N}", openCLKeysPerSecond);
     932                        ((QuickWatch)QuickWatchPresentation).OpenCLPresentation.keysPerSecondCPU.Content = String.Format("{0:N}", (keysPerSecond - openCLKeysPerSecond));
     933                        ((QuickWatch)QuickWatchPresentation).OpenCLPresentation.ratio.Content = String.Format("{0:P}", ratio);
     934                    }, null);
     935
     936
     937                    #region set doneKeys to 0
     938                    doneKeys = 0;
     939                    for (int i = 0; i < doneKeysA.Length; i++)
     940                        doneKeysA[i] = 0;
     941                    openCLdoneKeys = 0;
     942                    for (int i = 0; i < openCLDoneKeysA.Length; i++)
     943                        openCLDoneKeysA[i] = 0;
     944                    #endregion
     945
     946                    if (keycounter >= size)
     947                        break;
     948                }//end while
     949
     950                showProgress(costList, 1, 1, 1);
     951
     952                //wake up all sleeping threads, so they can stop:
     953                while (threadStack.Count != 0)
     954                    ((ThreadStackElement)threadStack.Pop()).ev.Set();
     955
     956                //wait until all threads finished:
     957                foreach (AutoResetEvent stopEvent in threadsStopEvents)
     958                {
     959                    stopEvent.WaitOne();
     960                }
     961
     962                if (!stop && !redirectResultsToStatisticsGenerator)
     963                    ProgressChanged(1, 1);
     964
     965            }
    907966
    908967            /* BEGIN: For evaluation issues - added by Arnold 2010.03.17 */
     
    935994        }
    936995
    937 
     996        #region External Client
     997
     998        void cryptoolServer_OnClientDisconnected(EndPoint client)
     999        {
     1000            GuiLogMessage("Client disconnected!", NotificationLevel.Info);
     1001            externalClientConnected = null;
     1002        }
     1003
     1004        void server_OnClientConnected(System.Net.EndPoint client, string identification)
     1005        {
     1006            lock (this)
     1007            {
     1008                if (externalClientConnected == null)
     1009                {
     1010                    externalClientConnected = client;
     1011                    GuiLogMessage(string.Format("Client {0} connected!", identification), NotificationLevel.Info);
     1012                    AssignJobToClient(client, externalKeySearcherOpenCLCode.CreateOpenCLBruteForceCode(externalKeyTranslator));
     1013                }
     1014                else
     1015                {
     1016                    GuiLogMessage("Client tried to connect, but only one client allowed!", NotificationLevel.Info);
     1017                }
     1018            }
     1019        }
     1020
     1021        private void AssignJobToClient(EndPoint client, string src)
     1022        {
     1023            JobInput j = new JobInput();
     1024            j.Guid = Guid.NewGuid().ToString();
     1025            j.Src = src;
     1026            var key = externalKeyTranslator.GetKey();
     1027            j.Key = key;
     1028            j.LargerThen = (costMaster.getRelationOperator() == RelationOperator.LargerThen);
     1029            j.Size = externalKeyTranslator.GetOpenCLBatchSize();
     1030            j.ResultSize = 10;
     1031            cryptoolServer.SendJob(j, client);
     1032        }
     1033
     1034        void server_OnJobCompleted(System.Net.EndPoint client, JobResult jr)
     1035        {
     1036            //check:
     1037            var op = this.costMaster.getRelationOperator();
     1038            foreach (var res in jr.ResultList)
     1039            {
     1040                float cost = res.Key;
     1041                if (((op == RelationOperator.LargerThen) && (cost > value_threshold))
     1042                    || (op == RelationOperator.LessThen) && (cost < value_threshold))
     1043                {
     1044                    ValueKey valueKey = new ValueKey { value = cost, key = externalKeyTranslator.GetKeyRepresentation(res.Value) };
     1045                    valueKey.keya = externalKeyTranslator.GetKeyFromRepresentation(valueKey.key);
     1046                    valueKey.decryption = sender.Decrypt(this.encryptedData, valueKey.keya, InitVector, bytesToUse);
     1047                    valuequeue.Enqueue(valueKey);
     1048                }
     1049            }
     1050            updateToplist();
     1051
     1052            //progress:
     1053            externalKeysProcessed += externalKeyTranslator.GetProgress();
     1054            showProgress(costList, pattern.size(), externalKeysProcessed, 1);
     1055
     1056            if (externalKeysProcessed != pattern.size())
     1057            {
     1058                AssignJobToClient(client, null);
     1059            }
     1060            else
     1061            {
     1062                waitForExternalClientToFinish.Set();
     1063            }
     1064        }
     1065
     1066        #endregion
    9381067
    9391068        private void SetStartDate()
  • trunk/CrypPlugins/KeySearcher/KeySearcher.csproj

    r2146 r2202  
    155155    <Compile Include="Properties\AssemblyInfo.cs" />
    156156    <Compile Include="KeyPattern\Wildcard.cs" />
     157    <Compile Include="Server\Job.cs" />
     158    <Compile Include="Server\Opcodes.cs" />
     159    <Compile Include="Server\PlatformIndependentWrapper.cs" />
     160    <Compile Include="Server\Server.cs" />
    157161  </ItemGroup>
    158162  <ItemGroup>
     
    223227    </BootstrapperPackage>
    224228  </ItemGroup>
     229  <ItemGroup>
     230    <Folder Include="Server\.svn\prop-base\" />
     231    <Folder Include="Server\.svn\props\" />
     232    <Folder Include="Server\.svn\text-base\" />
     233    <Folder Include="Server\.svn\tmp\prop-base\" />
     234    <Folder Include="Server\.svn\tmp\props\" />
     235    <Folder Include="Server\.svn\tmp\text-base\" />
     236  </ItemGroup>
    225237  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
    226238  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
  • trunk/CrypPlugins/KeySearcher/OpenCL/KeySearcherOpenCLCode.cs

    r2146 r2202  
    3030        }
    3131
    32         private string CreateOpenCLBruteForceCode(IKeyTranslator keyTranslator)
     32        public string CreateOpenCLBruteForceCode(IKeyTranslator keyTranslator)
    3333        {
    3434            if (keyTranslatorOfCode == keyTranslator)
Note: See TracChangeset for help on using the changeset viewer.