Changeset 840


Ignore:
Timestamp:
Nov 12, 2009, 4:54:32 PM (12 years ago)
Author:
oruba
Message:
  • modified preprocessing phase
  • results can be saved in .cte-files
Location:
trunk
Files:
5 edited

Legend:

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

    r832 r840  
    1717{
    1818    [Author("David Oruba",
    19         "dav083@web.de",
     19        "david.oruba@web.de",
    2020        "Uni-Bochum",
    2121        "http://www.ruhr-uni-bochum.de/")]
     
    5757        [PropertyInfo(Direction.OutputData,
    5858            "Output of superpolys",
    59             "Output the located linearly independent superpolys, cube indexes and its corresponding output bits.",
     59            "Output of located linearly independent superpolys, cube indexes and its corresponding output bits.",
    6060            "",
    6161            false,
     
    134134        }     
    135135
    136         /// <summary>
    137         /// Complete CubeAttack
    138         /// </summary>
    139136        public void Preprocessing()
    140137        {
     
    147144        }
    148145
    149         /// <summary>
    150         /// Manual input of public bits
    151         /// </summary>
    152146        public void SetPublicBits()
    153147        {
     
    207201        {
    208202            this.stop = true;
    209 
    210             /*if (settings.Action == 0) // Action = Preprocessing
     203            if (settings.Action == 0) // Action = Preprocessing
    211204            {
    212205                settings.SaveOutputSuperpoly = outputSuperpoly;
     
    216209                settings.SaveCountSuperpoly = countSuperpoly;
    217210                settings.SaveMatrixCheckLinearitySuperpolys = matrixCheckLinearitySuperpolys;
    218             }*/
     211                settings.SavePublicBitSize = settings.PublicVar;
     212                settings.SaveSecretBitSize = settings.SecretVar;
     213            }
    219214        }
    220215
     
    222217        {
    223218            Dispose();
    224 
    225             //if(countSuperpoly == settings.SecretVar)
    226             /*settings.SaveOutputSuperpoly = null;
    227             settings.SaveSuperpolyMatrix = null;
    228             settings.SaveListCubeIndexes = null;
    229             settings.SaveOutputBitIndex = null;
    230             settings.SaveCountSuperpoly = 0;
    231             settings.SaveMatrixCheckLinearitySuperpolys = null;
    232             CubeAttack_LogMessage("blubbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", NotificationLevel.Info); */
    233219        }
    234220
     
    236222        {
    237223            Dispose();
    238 
    239             /*if (settings.Action == 0) // Action = Preprocessing
    240             {
     224            if (settings.Action == 0) // Action = Preprocessing
     225            {
     226                if ((settings.PublicVar != settings.SavePublicBitSize) || (settings.SecretVar != settings.SaveSecretBitSize))
     227                {
     228                    settings.SaveCountSuperpoly = 0;
     229                    settings.SaveListCubeIndexes = null;
     230                    settings.SaveMatrixCheckLinearitySuperpolys = null;
     231                    settings.SaveOutputBitIndex = null;
     232                    settings.SaveOutputSuperpoly = null;
     233                    settings.SaveSuperpolyMatrix = null;
     234
     235                    outputSuperpoly = string.Empty;
     236                    superpolyMatrix = new Matrix(settings.SecretVar, settings.SecretVar + 1);
     237                    listCubeIndexes = new List<List<int>>();
     238                    outputBitIndex = new int[settings.SecretVar];
     239                    countSuperpoly = 0;
     240                    matrixCheckLinearitySuperpolys = new Matrix(0, settings.SecretVar);
     241                }
     242
    241243                if (settings.SaveCountSuperpoly != settings.SecretVar)
    242244                {
     
    254256                        matrixCheckLinearitySuperpolys = settings.SaveMatrixCheckLinearitySuperpolys;
    255257                }
    256             }*/
     258            }
    257259        }
    258260
     
    299301
    300302        /// <summary>
    301         /// Returns the output bit of the master polynomial p
    302         /// </summary>
    303         /// <param name="v">Public bits.</param>
    304         /// <param name="x">Secret bits.</param>
    305         /// <returns>Returns the output bit of the master polynomial, either 0 or 1.</returns>
     303        /// The function returns the black box output bit.
     304        /// </summary>
     305        /// <param name="v">Public variables.</param>
     306        /// <param name="x">Secret variables.</param>
     307        /// <returns>Returns the black box output bit, either 0 or 1.</returns>
    306308        public int Blackbox(int[] v, int[] x)
    307309        {
    308             /*// Begin Trivium
    309             // Initialisierung
    310                 int[] a = new int[93];
    311                 int[] b = new int[84];
    312             int[] c = new int[111];
    313             int t1, t2, t3;
    314             int i,j;
    315                 for (i = 0; i < 80; i++)
    316             {
    317                 a[i] = x[i];
    318                 b[i] = v[i];
    319                         c[i] = 0;
    320                 }
    321                 while (i < 84){
    322                         a[i] = 0;
    323                         b[i] = 0;
    324                         c[i] = 0;
    325                         i++;
    326                 }
    327                 while (i < 93){
    328                         a[i] = 0;
    329                         c[i] = 0;
    330                         i++;
    331                 }
    332                 while (i < 108){
    333                         c[i] = 0;
    334                         i++;
    335                 }
    336                 while (i < 111){
    337                         c[i] = 1;
    338                         i++;
    339                 }
    340 
    341                 for (i = 0; i < 672; i++)
    342             {
    343                         t1 = a[65] ^ a[92];
    344                         t2 = b[68] ^ b[83];
    345                         t3 = c[65] ^ c[110];
    346                         t1 = t1 ^ (a[90] & a[91]) ^ b[77];
    347                         t2 = t2 ^ (b[81] & b[82]) ^ c[86];
    348                         t3 = t3 ^ (c[108] & c[109]) ^ a[68];
    349                         for (j = 92; j > 0; j--)
    350                                 a[j] = a[j-1];
    351                         for (j = 83; j > 0; j--)
    352                                 b[j] = b[j-1];
    353                         for (j = 110; j > 0; j--)
    354                                 c[j] = c[j-1];
    355                         a[0] = t3;
    356                         b[0] = t1;
    357                         c[0] = t2;
    358                 }
    359 
    360             // Keystream
    361             List<int> keyOutput = new List<int>();
    362                 for (i = 0; i < 4; i++)
    363             {
    364                         t1 = a[65] ^ a[92];
    365                         t2 = b[68] ^ b[83];
    366                         t3 = c[65] ^ c[110];
    367                 keyOutput.Add(t1 ^ t2 ^ t3);
    368                         t1 = t1 ^ (a[90] & a[91]) ^ b[77];
    369                         t2 = t2 ^ (b[81] & b[82]) ^ c[86];
    370                         t3 = t3 ^ (c[108] & c[109]) ^ a[68];
    371                         for (j = 92; j > 0; j--)
    372                                 a[j] = a[j-1];
    373                         for (j = 83; j > 0; j--)
    374                                 b[j] = b[j-1];
    375                         for (j = 110; j > 0; j--)
    376                                 c[j] = c[j-1];
    377                         a[0] = t3;
    378                         b[0] = t1;
    379                         c[0] = t2;
    380                 }
    381             return keyOutput[3];
    382             // End Trivium */
    383 
    384310            int result = 0;
    385            
    386311            try
    387312            {
    388                 //switch (settings.BlackBox)
    389                 {
    390                     // Parser as black box
    391                     //case 0:
    392                         bool[] vBool = new bool[v.Length];
    393                         bool[] xBool = new bool[x.Length];
    394                         for (int i = 0; i < v.Length; i++)
    395                             vBool[i] = Convert.ToBoolean(v[i]);
    396                         for (int i = 0; i < x.Length; i++)
    397                             xBool[i] = Convert.ToBoolean(x[i]);
    398                         result = CubeattackBlackbox.GenerateBlackboxOutputBit(v, x, indexOutputBit);   //ParserOutput.SolveFunction(vBool, xBool);
    399                         //  break;
    400                     // Trivium as black box
    401                         //case 1:
    402                         //result = TriviumOutput.GenerateTriviumKeystream(v, x, indexOutputBit, false);
    403                     //break;
    404                 }
     313                result = CubeattackBlackbox.GenerateBlackboxOutputBit(v, x, indexOutputBit);
    405314            }
    406315            catch (Exception ex)
     
    416325        /// The structure is derived by computing the free term and the coefficients in the superpoly.
    417326        /// </summary>
    418         /// <param name="cube">The summation cube I.</param>
    419         /// <returns>Returns the superpoly of I in p.</returns>
     327        /// <param name="pubVarElement">Public variables.</param>
     328        /// <param name="maxterm">Maxterm.</param>
     329        /// <returns>Returns the superpoly.</returns>
    420330        public List<int> ComputeSuperpoly(int[] pubVarElement, List<int> maxterm)
    421331        {
     
    433343                if (stop)
    434344                    return superpoly;
    435 
    436345                for (int j = 0; j < maxterm.Count; j++)
    437346                    pubVarElement[maxterm[j]] = (i & ((ulong)1 << j)) > 0 ? 1 : 0;
     
    450359                    if (stop)
    451360                        return superpoly;
    452 
    453361                    secVarElement[k] = 1;
    454362                    for (int j = 0; j < maxterm.Count; j++)
     
    468376
    469377        /// <summary>
    470         /// The function outputs a the superpolys, cube indexes and output bits.
     378        /// The function outputs the superpolys, cube indexes and output bits.
    471379        /// </summary>
    472380        /// <param name="cubeIndexes">The cube indexes of the maxterm.</param>
     
    508416
    509417            output.Append("   Output Bit: " + indexOutputBit + "\n");
    510            
    511418            outputSuperpoly += output.ToString();
    512419            OnPropertyChanged("OutputSuperpoly");
     
    528435        /// Test if superpoly is already in matrix.
    529436        /// </summary>
    530         /// <param name="superpoly">The superpoly of I in p.</param>
     437        /// <param name="superpoly">The superpoly.</param>
    531438        /// <param name="matrix">An n x n matrix whose rows contain their corresponding superpolys.</param>
    532439        /// <returns>A boolean value indicating if the superpoly is in the matrix or not.</returns>
     
    573480        /// Test if a superpoly is linear (BLR linearity test).
    574481        /// </summary>
     482        /// <param name="pubVarElement">Public variables.</param>
    575483        /// <param name="maxterm">The located maxterm.</param>
    576484        /// <returns>A boolean value indicating if the superpoly is probably linear or not.</returns>
     
    607515                    if (stop)
    608516                        return false;
    609 
    610517                    for (int j = 0; j < maxterm.Count; j++)
    611518                        pubVarElement[maxterm[j]] = (i & ((ulong)1 << j)) > 0 ? 1 : 0;
     
    621528                    return false;
    622529                }
    623 
    624530                if (stop)
    625531                    return false;
     
    631537        /// Test if superpoly is a constant value.
    632538        /// </summary>
     539        /// <param name="pubVarElement">Public variables.</param>
    633540        /// <param name="maxterm">The located maxterm.</param>
    634541        /// <returns>A boolean value indicating if the superpoly is constant or not.</returns>
     
    655562                    if (stop)
    656563                        return false;
    657 
    658564                    for (int k = 0; k < maxterm.Count; k++)
    659565                        pubVarElement[maxterm[k]] = (j & ((ulong)1 << k)) > 0 ? 1 : 0;
     
    669575                }
    670576                output = 0;
    671 
    672577                if (stop)
    673578                    return false;
     
    757662
    758663        /// <summary>
    759         /// Preprocessing Phase of the cube attack.
    760         /// Implementation of the algorithm Random-Walk to find maxterms.
     664        /// Preprocessing phase of the cube attack.
    761665        /// </summary>
    762666        public void PreprocessingPhase()
    763667        {
    764             CubeAttack_LogMessage("Start preprocessing, try to find " + settings.SecretVar + " linearly independent superpolys", NotificationLevel.Info);
    765 
    766             indexOutputBit = settings.TriviumOutputBit;
     668            indexOutputBit = settings.OutputBit;
    767669            pubVarGlob = null;
    768670
    769             //if (countSuperpoly == settings.SecretVar)
     671            if (countSuperpoly == settings.SecretVar)
    770672            {
    771673                outputSuperpoly = string.Empty;
     
    777679            }
    778680
    779                 if (outputSuperpoly == null)
    780                     outputSuperpoly = string.Empty;
    781                 if (superpolyMatrix == null)
    782                     superpolyMatrix = new Matrix(settings.SecretVar, settings.SecretVar + 1);
    783                 if (listCubeIndexes == null)
    784                     listCubeIndexes = new List<List<int>>();
    785                 if (outputBitIndex == null)
    786                     outputBitIndex = new int[settings.SecretVar];
    787                 //if (countSuperpoly == 0)
    788                 //countSuperpoly = 0;
    789                 if (matrixCheckLinearitySuperpolys == null)
    790                     matrixCheckLinearitySuperpolys = new Matrix(0, settings.SecretVar);
     681            if (outputSuperpoly == null)
     682                outputSuperpoly = string.Empty;
     683            if (superpolyMatrix == null)
     684                superpolyMatrix = new Matrix(settings.SecretVar, settings.SecretVar + 1);
     685            if (listCubeIndexes == null)
     686                listCubeIndexes = new List<List<int>>();
     687            if (outputBitIndex == null)
     688                outputBitIndex = new int[settings.SecretVar];
     689            if (matrixCheckLinearitySuperpolys == null)
     690                matrixCheckLinearitySuperpolys = new Matrix(0, settings.SecretVar);
     691
     692            CubeAttack_LogMessage("Start preprocessing: \nTry to find " + settings.SecretVar + " linearly independent superpolys. (Already found: " + countSuperpoly + ")", NotificationLevel.Info);
    791693
    792694            Random rnd = new Random();
     
    796698            List<int> maxterm = new List<int>();
    797699            List<List<int>> cubeList = new List<List<int>>();
     700            string outputCube = string.Empty;
    798701
    799702            // Save all public variables indexes in a list
     
    821724                        maxterm.Add(chooseIndexI[i]);
    822725
    823                     string outputCube = string.Empty;
    824                     foreach (int element in maxterm)
    825                         outputCube += "v" + element + " ";
    826 
    827726                    if (settings.EnableLogMessages)
    828                         CubeAttack_LogMessage("Start search for maxterm with subterm: " + outputCube, NotificationLevel.Info); 
    829                    
    830                     if (settings.TriviumOutputBit != indexOutputBit)
     727                    {
     728                        foreach (int element in maxterm)
     729                            outputCube += "v" + element + " ";
     730                        CubeAttack_LogMessage("Start search for maxterm with subterm: " + outputCube, NotificationLevel.Info);
     731                    }
     732                    if (settings.OutputBit != indexOutputBit)
    831733                    {
    832734                        // User has changed Output Bit index, store new value
    833                         indexOutputBit = settings.TriviumOutputBit;
     735                        indexOutputBit = settings.OutputBit;
    834736
    835737                        // Reset list of cube indexes, since a single maxterms can be associated with multiple superpolys from different outputs
     
    862764                            break;
    863765                        }
    864 
    865766                        if (IsSuperpolyConstant(new int[settings.PublicVar], maxterm))
    866767                        {
     
    940841                                else
    941842                                    outputCube += " }   Output Bit: " + indexOutputBit;
    942 
    943843                                if (settings.EnableLogMessages)
    944844                                    CubeAttack_LogMessage(outputCube, NotificationLevel.Info);
     
    959859                            for (int j = 0; j < superpoly.Count; j++)
    960860                                superpolyMatrix[countSuperpoly, j] = superpoly[j];
    961 
    962861                            listCubeIndexes.Add(maxterm);
    963862                            OutputSuperpolys(maxterm, superpoly);
     
    970869                            matrixCheckLinearitySuperpolys = matrixCheckLinearitySuperpolys.DeleteLastRow();
    971870                    }
    972 
    973871                    if (countSuperpoly == settings.SecretVar)
    974872                        CubeAttack_LogMessage(settings.SecretVar + " linearly independent superpolys have been found, preprocessing phase completed", NotificationLevel.Info);
     
    978876
    979877        /// <summary>
    980         /// Online Phase of the cube attack.
    981         /// </summary>
    982         /// <param name="superpolyMatrix">An n x n matrix which contains the superpolys.</param>
    983         /// <param name="listCubeIndexes">A list of lists of cube indexes.</param>
     878        /// Online phase of the cube attack.
     879        /// </summary>
    984880        public void OnlinePhase()
    985881        {   
     
    988884                if (File.Exists(settings.OpenFilename))
    989885                {
     886                    CubeAttack_LogMessage("Read superpolys from file !", NotificationLevel.Info);
    990887                    superpolyMatrix = new Matrix(settings.SecretVar, settings.SecretVar + 1);
    991888                    listCubeIndexes = new List<List<int>>();
     
    1002899
    1003900                        for (int j = 0; j < variablesList.Count; j++)
     901                        {
    1004902                            if (variablesList[j].Substring(0, 1) == "1")
    1005903                            {
     
    1007905                                variablesList.Remove(variablesList[j]);
    1008906                            }
    1009 
     907                        }
    1010908                        for (int j = 0; j < variablesList.Count; j++)
    1011909                            if (variablesList[j].Substring(0, 1) == "x")
     
    1025923                        outputBitIndex[i] = Convert.ToInt32(allValues[2]);
    1026924                        i++;
     925                        // Save number of input superpolys
     926                        countSuperpoly = i;
    1027927                    }
    1028928                }
     
    1033933                }
    1034934            }
    1035 
    1036935            if (superpolyMatrix == null || listCubeIndexes == null)
    1037936                CubeAttack_LogMessage("Preprocessing phase has to be executed first", NotificationLevel.Error);
     
    1039938            {
    1040939                CubeAttack_LogMessage("Start online phase", NotificationLevel.Info);
    1041 
    1042940                outputSuperpoly = string.Empty;
    1043941                int[] pubVarElement = new int[settings.PublicVar];
     
    1048946                        pubVarElement[i] = pubVarGlob[i];
    1049947                }
    1050 
    1051948                Vector b = new Vector(settings.SecretVar);
    1052949                StringBuilder output = new StringBuilder(string.Empty);
     
    1092989                        try
    1093990                        {
    1094                             //switch(settings.BlackBox)
    1095                             {
    1096                                 //case 0:
    1097                                     // Online phase BooleanFunctionParser
    1098                                 //bool[] vBool = new bool[pubVarElement.Length];
    1099                                     //for (int l = 0; l < pubVarElement.Length; l++)
    1100                                         //  vBool[l] = Convert.ToBoolean(pubVarElement[l]);
    1101                                     //b[i] ^= ParserOutput.SolveFunction(vBool, null);
    1102                                   //  break;
    1103                                     //case 1:
    1104                                     // Online phase Trivium
    1105                                 b[i] ^= CubeattackBlackbox.GenerateBlackboxOutputBit(pubVarElement, null, outputBitIndex[i]);
    1106                                 //break;
    1107                             }
     991                            b[i] ^= CubeattackBlackbox.GenerateBlackboxOutputBit(pubVarElement, null, outputBitIndex[i]);
    1108992                        }
    1109993                        catch (Exception ex)
     
    11211005                    output.Append(listCubeIndexes[i][listCubeIndexes[i].Count - 1] + "}   Output Bit: " + outputBitIndex[i] + "\n");
    11221006                    outputSuperpoly += output.ToString();
    1123 
    11241007                    OnPropertyChanged("OutputSuperpoly");
    11251008                    ProgressChanged((double)i / (double)listCubeIndexes.Count, 1.0);
    11261009                    outputSuperpoly = string.Empty;
    11271010                }
    1128 
    11291011                if (listCubeIndexes.Count == settings.SecretVar)
    11301012                {
     
    11551037            bool fault = false;
    11561038
    1157             if (settings.TriviumOutputBit != indexOutputBit)
    1158                 indexOutputBit = settings.TriviumOutputBit;
    1159 
     1039            if (settings.OutputBit != indexOutputBit)
     1040                indexOutputBit = settings.OutputBit;
    11601041            if (settings.SetPublicBits.Length != settings.PublicVar)
    11611042                CubeAttack_LogMessage("Input public bits must have size " + settings.PublicVar + " (Currently: " + settings.SetPublicBits.Length + " )", NotificationLevel.Error);
     
    12241105        #endregion
    12251106
     1107
    12261108        #region Private methods
    12271109
     
    12561138        }
    12571139
    1258         #region IControlEncryption Members
    1259 
    1260         /*private IControlSolveFunction parserOutput;
    1261         [PropertyInfo(Direction.ControlMaster, "Master for BFP", "Master for BFP (SolveFunction)", "", DisplayLevel.Beginner)]
    1262         public IControlSolveFunction ParserOutput
    1263         {
    1264             get { return parserOutput; }
    1265             set
    1266             {
    1267                 if (value != null)
    1268                     parserOutput = value;
    1269             }
    1270         }
    1271 
    1272         private IControlTrivium triviumOutput;
    1273         [PropertyInfo(Direction.ControlMaster, "Master for Trivium", "Master for Trivium", "", DisplayLevel.Beginner)]
    1274         public IControlTrivium TriviumOutput
    1275         {
    1276             get { return triviumOutput; }
    1277             set
    1278             {
    1279                 if (value != null)
    1280                     triviumOutput = value;
    1281             }
    1282         }*/
     1140
     1141        #region IControlEncryption Members
    12831142
    12841143        private IControlCubeAttack cubeattackBlackbox;
  • trunk/CrypPlugins/CubeAttack/CubeAttackSettings.cs

    r832 r840  
    4242
    4343        private bool hasChanges;
    44         private int selectedBlackBox = 0;
    4544        private int selectedAction = 0;
    4645        private int publicVar;
     
    5049        private int linTest = 50;
    5150        private string setPublicBits = "0*00*";
    52         private int outputBit;
     51        private int outputBit = 1;
    5352        private bool readSuperpolysFromFile;
    5453        private string openFilename;
     
    6160        private int saveCountSuperpoly;
    6261        private Matrix saveMatrixCheckLinearitySuperpolys;
     62        private int savePublicBitSize;
     63        private int saveSecretBitSize;
    6364
    6465        #endregion
     
    6768        #region Algorithm settings properties (visible in the settings pane)
    6869
    69         /*[PropertySaveOrder(1)]
    70         [ContextMenu("Black Box",
    71             "Select the black box",
    72             1,
    73             DisplayLevel.Beginner,
    74             ContextMenuControlType.ComboBox,
    75             null,
    76             "Boolean function parser",
    77             "Trivium")]
    78         [TaskPane("Black Box",
    79             "Select the black box",
    80             "",
    81             1,
    82             false,
    83             DisplayLevel.Beginner,
    84             ControlType.ComboBox,
    85             new string[] { "Boolean function parser", "Trivium" })]
    86         public int BlackBox
    87         {
    88             get { return this.selectedBlackBox; }
    89             set
    90             {
    91                 if (value != selectedBlackBox) HasChanges = true;
    92                 this.selectedBlackBox = value;
    93                 OnPropertyChanged("BlackBox");
    94             }
    95         }*/
    96 
    97         [PropertySaveOrder(2)]
     70        [PropertySaveOrder(1)]
    9871        [ContextMenu("Action",
    9972            "Select the cube attack modi",
    100             2,
     73            1,
    10174            DisplayLevel.Beginner,
    10275            ContextMenuControlType.ComboBox,
     
    10881            "Select the cube attack modi",
    10982            "",
    110             2,
     83            1,
    11184            false,
    11285            DisplayLevel.Beginner,
     
    12497        }
    12598       
    126         [PropertySaveOrder(3)]
     99        [PropertySaveOrder(2)]
    127100        [TaskPane("Public Bit Size",
    128101            "Public input bits (IV or plaintext) of the attacked cryptosystem.",
    129102            null,
    130             3,
     103            2,
    131104            false,
    132105            DisplayLevel.Beginner,
     
    146119        }
    147120
    148         [PropertySaveOrder(4)]
     121        [PropertySaveOrder(3)]
    149122        [TaskPane("Secret Bit Size",
    150123            "Key size or key length  of the attacked cryptosystem.",
    151124            null,
    152             4,
     125            3,
    153126            false,
    154127            DisplayLevel.Beginner,
     
    168141        }
    169142
    170         [PropertySaveOrder(5)]
     143        [PropertySaveOrder(4)]
    171144        [TaskPane("Max Cube Size",
    172145            "Maxmium size of the summation cube.",
    173146            null,
    174             5,
     147            4,
    175148            true,
    176149            DisplayLevel.Beginner,
     
    190163        }
    191164
    192         [PropertySaveOrder(6)]
     165        [PropertySaveOrder(5)]
    193166        [TaskPane("Constant Test",
    194167            "Number of tests to check if the superpoly is a constant value or not.",
    195168            null,
    196             6,
     169            5,
    197170            true,
    198171            DisplayLevel.Beginner,
     
    212185        }
    213186
    214         [PropertySaveOrder(7)]
     187        [PropertySaveOrder(6)]
    215188        [TaskPane("Linearity Test",
    216189            "Number of linearity tests to check if the superpoly is linear or not.",
    217190            null,
    218             7,
     191            6,
    219192            true,
    220193            DisplayLevel.Beginner,
     
    234207        }
    235208
    236         [PropertySaveOrder(8)]
     209        [PropertySaveOrder(7)]
    237210        [TaskPane("Output Bit",
    238211            "Chooses the output bit of the black box, which should be evaluated.",
    239212            null,
    240             8,
     213            7,
    241214            true,
    242215            DisplayLevel.Beginner,
     
    245218            1,
    246219            10000)]
    247         public int TriviumOutputBit
     220        public int OutputBit
    248221        {
    249222            get { return outputBit; }
     
    252225                if (value != this.outputBit) HasChanges = true;
    253226                outputBit = value;
    254                 OnPropertyChanged("TriviumOutputBit");
    255             }
    256         }
    257 
    258         [PropertySaveOrder(9)]
     227                OnPropertyChanged("OutputBit");
     228            }
     229        }
     230
     231        [PropertySaveOrder(8)]
    259232        [TaskPane("Manual Public Bit Input",
    260233            "Possible inputs '0' (set bit to value 0), '1' (set bit to value 1) and '*' (sum the 0/1 value of the bit).",
    261234            null,
    262             9,
     235            8,
    263236            false,
    264237            DisplayLevel.Beginner,
     
    282255        }
    283256
    284         [PropertySaveOrder(10)]
    285         [ContextMenu("Read superpolys from File",
     257        [PropertySaveOrder(9)]
     258        [ContextMenu("Read Superpolys From File",
    286259            "With this checkbox enabled, superpolys will be loaded from the selected File and can be evaluated in the online phase.",
    287             10,
     260            9,
    288261            DisplayLevel.Experienced,
    289262            ContextMenuControlType.CheckBox,
    290263            null,
    291             new string[] { "Read superpolys from File" })]
     264            new string[] { "Read Superpolys From File" })]
    292265        [TaskPane("Read superpolys from File",
    293266            "With this checkbox enabled, superpolys will be loaded from the selected File and can be evaluated in the online phase.",
    294267            null,
    295             10,
     268            9,
    296269            false,
    297270            DisplayLevel.Beginner,
     
    310283        }
    311284
    312         [PropertySaveOrder(11)]
    313         [TaskPane("Filename", "Select the file you want to open.",
    314             null,
    315             11,
     285        [PropertySaveOrder(10)]
     286        [TaskPane("Filename",
     287            "Select the file you want to open.\nFile structure: superpoly cube-indexes output-bit\nExample: 1+x0+x5 2,6 1",
     288            null,
     289            10,
    316290            false,
    317291            DisplayLevel.Beginner,
     
    332306        }
    333307
    334         [PropertySaveOrder(12)]
    335         [ContextMenu("Enable log messages",
     308        [PropertySaveOrder(11)]
     309        [ContextMenu("Enable Log Messages",
    336310            "With this checkbox enabled, log messages will be showed.",
    337             12,
     311            11,
    338312            DisplayLevel.Experienced,
    339313            ContextMenuControlType.CheckBox,
    340314            null,
    341315            new string[] { "Enable log messages?" })]
    342         [TaskPane("Enable log messages",
     316        [TaskPane("Enable Log Messages",
    343317            "With this checkbox enabled, a lot of log messages will be showed during preprocessing.",
    344318            null,
    345             12,
     319            11,
    346320            false,
    347321            DisplayLevel.Beginner,
     
    420394        }
    421395
     396        public int SavePublicBitSize
     397        {
     398            get { return savePublicBitSize; }
     399            set
     400            {
     401                if (value != savePublicBitSize) hasChanges = true;
     402                savePublicBitSize = value;
     403            }
     404        }
     405
     406        public int SaveSecretBitSize
     407        {
     408            get { return saveSecretBitSize; }
     409            set
     410            {
     411                if (value != saveSecretBitSize) hasChanges = true;
     412                saveSecretBitSize = value;
     413            }
     414        }
     415
    422416        #endregion
    423417
  • trunk/CrypPlugins/CubeAttack/Matrix.cs

    r724 r840  
    33using System.Linq;
    44using System.Text;
     5using System.Runtime.Serialization;
     6using System.Runtime.Serialization.Formatters.Binary;
    57
    68namespace Cryptool.CubeAttack
    79{
    8     public class Matrix
     10    [Serializable()]
     11    public class Matrix : ISerializable
    912    {
     13        public Matrix(SerializationInfo info, StreamingContext ctxt)
     14        {
     15            rows = (int)info.GetValue("rows", typeof(int));
     16            cols = (int)info.GetValue("cols", typeof(int));
     17            element = (int[,])info.GetValue("element", typeof(int[,]));
     18        }
     19       
     20        public void GetObjectData(SerializationInfo info, StreamingContext ctxt)
     21        {
     22            info.AddValue("rows", rows);
     23            info.AddValue("cols", cols);
     24            info.AddValue("element", element);
     25        }
     26
     27
    1028        /// <summary>
    1129        /// Class attributes/members
Note: See TracChangeset for help on using the changeset viewer.