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/CrypPlugins/KeySearcher
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • 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
Note: See TracChangeset for help on using the changeset viewer.