Changeset 2061


Ignore:
Timestamp:
Nov 7, 2010, 10:24:18 AM (11 years ago)
Author:
Sven Rech
Message:

Added code to generate openCL bruteforce code in KeySearcher.
Not used yet, so don't try it

Location:
trunk
Files:
5 added
16 edited

Legend:

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

    r947 r2061  
    4646      double calculateCost(byte[] text);
    4747
     48      /// <summary>
     49      /// This method modifies the given OpenCL code, so that the returning code includes
     50      /// the costfunction calculations.
     51      /// </summary>
     52      /// <param name="code"></param>
     53      /// <returns></returns>
     54      string ModifyOpenCLCode(string code);
     55
    4856      int getBytesToUse();
    4957  }
  • trunk/CrypPluginBase/Control/IControlEncryption.cs

    r2010 r2061  
    2828        byte[] Decrypt(byte[] ciphertext, byte[] key, byte[] IV);
    2929        string getKeyPattern();
    30         KeyTranslator getKeyTranslator();
     30        IKeyTranslator getKeyTranslator();
     31        string GetOpenCLCode(int decryptionLength);
    3132
    3233        void changeSettings(string setting, object value);
  • trunk/CrypPluginBase/Control/KeyTranslator.cs

    r2010 r2061  
    2222namespace Cryptool.PluginBase.Control
    2323{
    24     public interface KeyTranslator
     24    public interface IKeyTranslator
    2525    {
    2626        /// <summary>
     
    4949        string GetKeyRepresentation();
    5050
     51        string GetKeyRepresentation(int add);
     52
    5153        /// <summary>
    5254        /// Returns the amount of keys that where given by the "nextKey()" method after "getProgress()" was called last time.
     
    5759        int GetProgress();
    5860
    59         //TODO: Add OpenCL stuff here
     61        /// <summary>
     62        /// This method modifies the given OpenCL code, so that the returning code includes
     63        /// the key movement stuff.
     64        /// </summary>
     65        /// <param name="code"></param>
     66        /// <param name="maxKeys"></param>
     67        /// <returns></returns>
     68        string ModifyOpenCLCode(string code, int maxKeys);
     69
     70        /// <summary>
     71        /// Like "NextKey()", but jumps over a whole key batch that can be processed by the generated OpenCL code
     72        /// in one step.
     73        /// </summary>
     74        /// <returns></returns>
     75        bool NextOpenCLBatch();
    6076    }
    6177}
  • trunk/CrypPlugins/AES/AES.cs

    r2010 r2061  
    570570        }
    571571
     572        public string GetOpenCLCode(int decryptionLength)
     573        {
     574            string opencl = Properties.Resources.AESOpenCL;
     575
     576            int bits = -1;
     577            switch (((AESSettings)plugin.Settings).Keysize)
     578            {
     579                case 0:
     580                    bits = 16 * 8;
     581                    break;
     582                case 1:
     583                    bits = 24 * 8;
     584                    break;
     585                case 2:
     586                    bits = 32 * 8;
     587                    break;
     588            }
     589            if (bits == -1)
     590                return null;
     591
     592            opencl = opencl.Replace("$$BITS$$", "" + bits);
     593
     594            string decryptionCode = "";
     595            int blocks = decryptionLength / 16;
     596            if (blocks >= 1)
     597            {
     598                decryptionCode = AddOpenCLBlockDecryption(decryptionCode, 16);
     599
     600                if (blocks > 1)
     601                {
     602                    decryptionCode += string.Format("for (int b = 1; b < {0}; b++) \n {{ \n ", blocks);
     603                    decryptionCode = AddOpenCLBlockDecryptionWithMode(decryptionCode, 16, "b");
     604                    decryptionCode += "}\n";
     605                }
     606            }
     607
     608            if (decryptionLength % 16 != 0)
     609            {
     610                if (blocks == 0)
     611                    decryptionCode = AddOpenCLBlockDecryption(decryptionCode, decryptionLength % 16);
     612                else
     613                    decryptionCode = AddOpenCLBlockDecryptionWithMode(decryptionCode, decryptionLength % 16, ""+blocks);
     614            }
     615
     616            opencl = opencl.Replace("$$AESDECRYPT$$", decryptionCode);
     617
     618            return opencl;
     619        }
     620
     621        private string AddOpenCLBlockDecryption(string decryptionCode, int size)
     622        {
     623            decryptionCode += "AES_decrypt(inn, block, &(key)); \n " + string.Format("for (int i = 0; i < {0}; i++) \n ", size)
     624                              + "{ \n unsigned char c = block[i]; \n "
     625                              + "$$COSTFUNCTIONCALCULATE$$ \n } \n";
     626            return decryptionCode;
     627        }
     628
     629        private string AddOpenCLBlockDecryptionWithMode(string decryptionCode, int size, string block)
     630        {
     631            decryptionCode += string.Format("AES_decrypt((inn+{0}*16), block, &(key)); \n ", block)
     632                              + string.Format("for (int i = 0; i < {0}; i++) \n {{ \n ", size);
     633            switch (((AESSettings) plugin.Settings).Mode)
     634            {
     635                case 0: //ECB
     636                    decryptionCode += "unsigned char c = block[i]; \n";
     637                    break;
     638                case 1: //CBC
     639                    decryptionCode += string.Format("unsigned char c = block[i] ^ (inn+({0}-1)*16)[i]; \n", block);
     640                    break;
     641                case 2: //CFB
     642                    throw new NotImplementedException("CFB for OpenCL is not implemented!"); //not supported
     643            }
     644            decryptionCode += "$$COSTFUNCTIONCALCULATE$$ \n } \n";
     645            return decryptionCode;
     646        }
     647
    572648        public void changeSettings(string setting, object value)
    573649        {
    574650        }
    575651
    576         public KeyTranslator getKeyTranslator()
     652        public IKeyTranslator getKeyTranslator()
    577653        {
    578654            return new KeySearcher.KeyTranslators.ByteArrayKeyTranslator();
  • trunk/CrypPlugins/AES/AES.csproj

    r2033 r2061  
    115115    <Compile Include="AESSettings.cs" />
    116116    <Compile Include="Properties\AssemblyInfo.cs" />
     117    <Compile Include="Properties\Resources.Designer.cs">
     118      <AutoGen>True</AutoGen>
     119      <DesignTime>True</DesignTime>
     120      <DependentUpon>Resources.resx</DependentUpon>
     121    </Compile>
    117122  </ItemGroup>
    118123  <ItemGroup>
     
    166171    </BootstrapperPackage>
    167172  </ItemGroup>
     173  <ItemGroup>
     174    <None Include="OpenCL\AESOpenCL.cl" />
     175  </ItemGroup>
     176  <ItemGroup>
     177    <EmbeddedResource Include="Properties\Resources.resx">
     178      <Generator>ResXFileCodeGenerator</Generator>
     179      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
     180    </EmbeddedResource>
     181  </ItemGroup>
    168182  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
    169183  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
  • trunk/CrypPlugins/CostFunction/CostFunction.cs

    r2042 r2061  
    752752        {
    753753            this.plugin = plugin;
     754        }
     755
     756        public string ModifyOpenCLCode(string code)
     757        {
     758            int bytesToUse = 0;
     759            try
     760            {
     761                bytesToUse = ((CostFunctionSettings)this.plugin.Settings).BytesToUseInteger;
     762            }
     763            catch (Exception ex)
     764            {
     765                throw new Exception("Entered bytesToUse is not an integer: " + ex.Message);
     766            }
     767
     768            switch (((CostFunctionSettings)this.plugin.Settings).FunctionType)
     769            {
     770                case 0: //Index of coincidence
     771                    return ModifyOpenCLCodeIndexOfCoincidence(code, bytesToUse);
     772                case 1: //Entropy
     773                    return ModifyOpenCLCodeEntropy(code, bytesToUse);
     774                case 5: // Regular Expression
     775                    var regex = new RegEx(((CostFunctionSettings)this.plugin.Settings).RegEx, ((CostFunctionSettings)this.plugin.Settings).CaseInsensitiv);
     776                    return regex.ModifyOpenCLCode(code, bytesToUse);
     777                default:
     778                    throw new NotImplementedException("The value " + ((CostFunctionSettings)this.plugin.Settings).FunctionType + " is not implemented for OpenCL.");
     779            }//end switch
     780        }
     781
     782        private string ModifyOpenCLCodeEntropy(string code, int bytesToUse)
     783        {
     784            //declaration code:
     785            float[] xlogx = new float[bytesToUse + 1];
     786            xlogx[0] = 0.0f;
     787            for (int i = 1; i <= bytesToUse; i++)
     788                xlogx[i] = (float) (-1.0f * i * Math.Log(i / (float)bytesToUse) / Math.Log(2.0));
     789
     790            string declaration = string.Format("__constant float xlogx[{0}] = {{ \n", bytesToUse + 1);
     791            foreach (float xlx in xlogx)
     792            {
     793                declaration += xlx.ToString(System.Globalization.CultureInfo.InvariantCulture) + ", ";
     794            }
     795            declaration = declaration.Substring(0, declaration.Length - 2);
     796            declaration += " }; \n";
     797
     798            code = code.Replace("$$COSTFUNCTIONDECLARATIONS$$", declaration);
     799
     800            //initialization code:
     801            code = code.Replace("$$COSTFUNCTIONINITIALIZE$$", "unsigned char distr[256]; \n for (int c = 0; c < 256; c++) \n distr[c]=0; \n");
     802
     803            //calculation code:
     804            code = code.Replace("$$COSTFUNCTIONCALCULATE$$", "distr[c]++;");
     805
     806            //result calculation code:
     807            code = code.Replace("$$COSTFUNCTIONRESULTCALCULATION$$", "int i = 0; \n "
     808                + "while (i<256) { \n "
     809                + "result += xlogx[distr[i++]]; \n "
     810                + "result += xlogx[distr[i++]]; \n "
     811                + "result += xlogx[distr[i++]]; \n "
     812                + "result += xlogx[distr[i++]]; \n "
     813                + "result += xlogx[distr[i++]]; \n "
     814                + "result += xlogx[distr[i++]]; \n "
     815                + "result += xlogx[distr[i++]]; \n "
     816                + "result += xlogx[distr[i++]]; \n "
     817                + "} \n "
     818                + string.Format("result /= {0}f;", bytesToUse));
     819
     820            return code;
     821        }
     822
     823        private string ModifyOpenCLCodeIndexOfCoincidence(string code, int bytesToUse)
     824        {
     825            throw new NotImplementedException("Index of coincidence is not implemented for OpenCL yet (will follow soon).");
    754826        }
    755827
  • trunk/CrypPlugins/CostFunction/RegEx.cs

    r2042 r2061  
    7676                }
    7777            }
     78        }
     79
     80        /// <summary>
     81        /// This method modifies the given OpenCL code, so that the returning code includes
     82        /// the costfunction RegEx calculations.
     83        /// </summary>
     84        /// <param name="code"></param>
     85        /// <param name="bytesToUse"></param>
     86        /// <returns></returns>
     87        public string ModifyOpenCLCode(string code, int bytesToUse)
     88        {
     89            if (transitionMatrix == null)
     90            {
     91                //return false:
     92                return code.Replace("$$COSTFUNCTIONDECLARATIONS$$", "").Replace("$$COSTFUNCTIONINITIALIZE$$", "goto resultcalculation;")
     93                    .Replace("$$COSTFUNCTIONCALCULATE$$", "").Replace("$$COSTFUNCTIONRESULTCALCULATION$$", "result = -1;");
     94            }
     95
     96            //declaration code:
     97            string declaration = string.Format("__constant int transitionMatrix[{0}] = {{ \n", transitionMatrix.Length * 256);
     98            foreach (var row in transitionMatrix)
     99            {
     100                foreach (var i in row)
     101                {
     102                    declaration += i + ", ";
     103                }
     104            }
     105            declaration = declaration.Substring(0, declaration.Length - 2);
     106            declaration += " }; \n";
     107            declaration += string.Format("__constant int NOTRANSITION = {0}; \n", int.MaxValue);
     108
     109            code = code.Replace("$$COSTFUNCTIONDECLARATIONS$$", declaration);
     110
     111            //initialization code:
     112            code = code.Replace("$$COSTFUNCTIONINITIALIZE$$", string.Format("int state = {0}; \n", startIndex));
     113
     114            //calculation code:
     115            code = code.Replace("$$COSTFUNCTIONCALCULATE$$", "int absState = state >= 0 ? state : ~state; \n"
     116                + "state = transitionMatrix[absState*256+c]; \n"
     117                + "if (state == NOTRANSITION) goto resultcalculation; \n");
     118
     119            //result calculation code:
     120            code = code.Replace("$$COSTFUNCTIONRESULTCALCULATION$$", "if (state < 0) result = 1.0; else result = -1.0;");
     121
     122            return code;
    78123        }
    79124
  • trunk/CrypPlugins/DES/DES.cs

    r2010 r2061  
    574574        }
    575575
     576        public string GetOpenCLCode(int decryptionLength)
     577        {
     578            return null;
     579        }
     580
    576581        public void changeSettings(string setting, object value)
    577582        {
     
    579584        }
    580585
    581         public KeyTranslator getKeyTranslator()
     586        public IKeyTranslator getKeyTranslator()
    582587        {
    583588            return new KeySearcher.KeyTranslators.ByteArrayKeyTranslator();
  • trunk/CrypPlugins/KeySearcher/KeyPattern/IntervalKeyMovement.cs

    r2010 r2061  
    2222namespace KeySearcher.KeyPattern
    2323{
    24     public class IntervalKeyMovement : KeyMovement
     24    public class IntervalKeyMovement : IKeyMovement
    2525    {
    2626        public List<int> IntervalList
     
    3535        }
    3636
     37        public int Count()
     38        {
     39            return IntervalList.Count;
     40        }
    3741    }
    3842}
  • trunk/CrypPlugins/KeySearcher/KeyPattern/KeyMovement.cs

    r2010 r2061  
    2222namespace KeySearcher.KeyPattern
    2323{
    24     public interface KeyMovement
     24    public interface IKeyMovement
    2525    {
    26 
     26        int Count();
    2727    }
    2828}
  • trunk/CrypPlugins/KeySearcher/KeyPattern/KeyPattern.cs

    r2010 r2061  
    387387        /// </summary>
    388388        /// <returns></returns>
    389         public KeyMovement[] getKeyMovements()
     389        public IKeyMovement[] getKeyMovements()
    390390        {
    391391            KeyPattern fullKeyPattern = new KeyPattern(pattern);
     
    397397                    arraySize++;
    398398
    399             KeyMovement[] result = new KeyMovement[arraySize];
     399            IKeyMovement[] result = new IKeyMovement[arraySize];
    400400
    401401            int c = 0;
     
    418418        /// <param name="fullwildcard"></param>
    419419        /// <returns>The movements</returns>
    420         private KeyMovement getWildcardMovement(Wildcard wildcard, Wildcard fullwildcard)
     420        private IKeyMovement getWildcardMovement(Wildcard wildcard, Wildcard fullwildcard)
    421421        {
    422422            //check if linear:
  • trunk/CrypPlugins/KeySearcher/KeyPattern/LinearKeyMovement.cs

    r2010 r2061  
    2525    /// This class represents key movements which can be described by A*x+B
    2626    /// </summary>
    27     public class LinearKeyMovement : KeyMovement
     27    public class LinearKeyMovement : IKeyMovement
    2828    {
    2929        public int A
     
    5151            this.UpperBound = upperBound;
    5252        }
     53
     54        public int Count()
     55        {
     56            return UpperBound;
     57        }
    5358    }
    5459}
  • trunk/CrypPlugins/KeySearcher/KeySearcher.cs

    r2042 r2061  
    371371                    keysLeft[threadid] = size;
    372372
    373                     KeyTranslator keyTranslator = ControlMaster.getKeyTranslator();
     373                    IKeyTranslator keyTranslator = ControlMaster.getKeyTranslator();
    374374                    keyTranslator.SetKeys(pattern);
    375375
     
    455455        #region bruteforce methods
    456456
    457         private bool decryptAndCalculate(IControlEncryption sender, int bytesToUse, byte[] keya, KeyTranslator keyTranslator)
     457        private bool decryptAndCalculate(IControlEncryption sender, int bytesToUse, byte[] keya, IKeyTranslator keyTranslator)
    458458        {
    459459            ValueKey valueKey;
     
    709709
    710710            return costList;
     711        }
     712
     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            }
    711746        }
    712747
  • trunk/CrypPlugins/KeySearcher/KeyTranslators/ByteArrayKeyTranslator.cs

    r2010 r2061  
    2828    /// Is used by AES and DES.
    2929    /// </summary>
    30     public class ByteArrayKeyTranslator : KeyTranslator
     30    public class ByteArrayKeyTranslator : IKeyTranslator
    3131    {
    3232        private int progress = 0;
     
    3535        private byte[] keya;
    3636        private int[] movementPointers;
    37         private KeyMovement[] keyMovements;
     37        private IKeyMovement[] keyMovements;
     38        private int openCLIndex = -1;
     39        private int openCLSize;
    3840
    3941        #region KeyTranslator Members
     
    98100
    99101            for (int x = 0; x < movementStatus.Length - 1; x++)
    100                 setWildcard(x);
     102                SetWildcard(x);
    101103        }
    102104
     
    109111        {
    110112            int i = movementStatus.Length - 1;
    111 
    112             movementStatus[i]++;
     113            progress++;
     114            return IncrementMovementStatus(i);
     115        }
     116
     117        private bool IncrementMovementStatus(int index)
     118        {
     119            movementStatus[index]++;
    113120           
    114             while (i >= 0 && !wildcardInRange(i))
     121            while (index >= 0 && !WildcardInRange(index))
    115122            {               
    116                 movementStatus[i] = 0;
    117                 setWildcard(i);
    118 
    119                 i--;
    120                 if (i >= 0)
    121                     movementStatus[i]++;         
    122             }
    123 
    124             if (i >= 0)
    125                 setWildcard(i);
    126 
    127             progress++;
    128 
    129             return i >= 0;
     123                movementStatus[index] = 0;
     124                SetWildcard(index);
     125
     126                index--;
     127                if (index >= 0)
     128                    movementStatus[index]++;         
     129            }
     130
     131            if (index >= 0)
     132                SetWildcard(index);
     133
     134            return index >= 0;
    130135        }
    131136
     
    133138        {
    134139            return pattern.getKey(progress);
     140        }
     141
     142        public string GetKeyRepresentation(int add)
     143        {
     144            return pattern.getKey(add);
    135145        }
    136146
     
    139149        /// </summary>
    140150        /// <param name="i">the wildcard index</param>
    141         private void setWildcard(int i)
     151        private void SetWildcard(int i)
    142152        {
    143153            int index = movementPointers[i] / 2;
     
    155165            }
    156166
    157             keya[index] = (byte)((keya[index] & mask) | (calcWildcard(i) << shift));
    158         }
    159 
    160         private int calcWildcard(int i)
    161         {
    162             KeyMovement mov = keyMovements[i];
     167            keya[index] = (byte)((keya[index] & mask) | (CalcWildcard(i) << shift));
     168        }
     169
     170        private int CalcWildcard(int i)
     171        {
     172            IKeyMovement mov = keyMovements[i];
    163173            if (mov is LinearKeyMovement)
    164174            {
     
    173183        }
    174184
    175         private bool wildcardInRange(int i)
    176         {
    177             KeyMovement mov = keyMovements[i];
     185        private bool WildcardInRange(int i)
     186        {
     187            IKeyMovement mov = keyMovements[i];
    178188            if (mov is LinearKeyMovement)
    179189            {
     
    197207        }
    198208
     209        public string ModifyOpenCLCode(string code, int maxKeys)
     210        {
     211            string[] byteReplaceStrings = new string[32];
     212            for (int i = 0; i < 32; i++)
     213                byteReplaceStrings[i] = "$$ADDKEYBYTE"+i+"$$";
     214           
     215            //Find out how many wildcards/keys we can bruteforce at once:
     216            int j = movementStatus.Length - 1;
     217            int size = 1;
     218            while ((size < maxKeys) && (j >= 0) && (movementStatus[j] == 0))
     219                size *= keyMovements[j--].Count();
     220
     221            if (size < 256)
     222                return null;    //it's futile to use OpenCL for so few keys
     223
     224            //generate the key movement string:
     225            string[] movementStrings = new string[32];
     226            string addVariable = "add";
     227            for (int x = movementStatus.Length - 1; x > j; x--)
     228            {
     229                string movStr = string.Format("({0}%{1})", addVariable, keyMovements[x].Count());;
     230
     231                if (keyMovements[x] is LinearKeyMovement)
     232                {
     233                    var lkm = keyMovements[x] as LinearKeyMovement;
     234                    movStr = string.Format("({0}*{1}+{2})", lkm.A, movStr, lkm.B);
     235                }
     236                else if (keyMovements[x] is IntervalKeyMovement)
     237                {
     238                    var ikm = keyMovements[x] as IntervalKeyMovement;
     239
     240                    //declare the invterval array:
     241                    string s = string.Format("__constant int ikm{0}[{1}] = {{", x, ikm.Count());
     242                    foreach (var c in ikm.IntervalList)
     243                        s += c + ", ";
     244                    s = s.Substring(0, s.Length - 2);
     245                    s += "}; \n";
     246                    code = code.Replace("$$MOVEMENTDECLARATIONS$$", s + "\n$$MOVEMENTDECLARATIONS$$");
     247
     248                    movStr = string.Format("ikm{0}[{1}]", x, movStr);
     249                }
     250                else
     251                {
     252                    throw new Exception("Key Movement not supported for OpenCL.");
     253                }
     254
     255                if (movementPointers[x] % 2 == 0)
     256                    movStr = "(" + movStr + " << 4)";
     257                else
     258                    movStr = "(" + movStr + ")";
     259
     260                addVariable = "(" + addVariable + "/" + keyMovements[x].Count() + ")";
     261
     262                int keyIndex = movementPointers[x]/2;
     263                if (movementStrings[keyIndex] != null)
     264                    movementStrings[keyIndex] += " | " + movStr;
     265                else
     266                    movementStrings[keyIndex] = movStr;
     267            }
     268
     269            //put movement strings in code:
     270            for (int y = 0; y < movementStrings.Length; y++)
     271                code = code.Replace(byteReplaceStrings[y], movementStrings[y] ?? "0");
     272
     273            code = code.Replace("$$MOVEMENTDECLARATIONS$$", "");
     274
     275            //progress:
     276            openCLIndex = j;
     277            openCLSize = size;
     278
     279            return code;
     280        }
     281
     282        public bool NextOpenCLBatch()
     283        {
     284            if (openCLIndex > -1)
     285            {
     286                progress += openCLSize;
     287                return IncrementMovementStatus(openCLIndex);
     288            }
     289            else
     290            {
     291                throw new Exception("This method can only be called if OpenCL code was generated!");
     292            }
     293        }
     294
    199295        #endregion
    200296
  • trunk/CrypPlugins/SDES/SDES.cs

    r2010 r2061  
    715715        }
    716716
     717        public string GetOpenCLCode(int decryptionLength)
     718        {
     719            return null;
     720        }
     721
    717722        public void changeSettings(string setting, object value)
    718723        {
     
    720725        }
    721726
    722         public KeyTranslator getKeyTranslator()
     727        public IKeyTranslator getKeyTranslator()
    723728        {
    724729            return new SDESKeyTranslator();
     
    728733    }
    729734
    730     class SDESKeyTranslator : KeyTranslator
     735    class SDESKeyTranslator : IKeyTranslator
    731736    {
    732737        private KeyPattern pattern;
     
    767772        }
    768773
     774        public string GetKeyRepresentation(int add)
     775        {
     776            return pattern.getKey(add);
     777        }
     778
    769779        public int GetProgress()
    770780        {
     
    772782            progress = 0;
    773783            return result;
     784        }
     785
     786        public string ModifyOpenCLCode(string code, int maxKeys)
     787        {
     788            throw new NotImplementedException();
     789        }
     790
     791        public bool NextOpenCLBatch()
     792        {
     793            throw new NotImplementedException();
    774794        }
    775795
  • trunk/CrypPlugins/Transposition/Transposition.cs

    r2010 r2061  
    11711171        }
    11721172
     1173        public string GetOpenCLCode(int decryptionLength)
     1174        {
     1175            return null;
     1176        }
     1177
    11731178        public void changeSettings(string setting, object value)
    11741179        {
     
    11761181        }
    11771182
    1178         public KeyTranslator getKeyTranslator()
     1183        public IKeyTranslator getKeyTranslator()
    11791184        {
    11801185            throw new NotImplementedException();
Note: See TracChangeset for help on using the changeset viewer.