Ignore:
Timestamp:
Sep 30, 2009, 11:28:06 PM (12 years ago)
Author:
oruba
Message:
  • M/S Connection between CubeAttack-Trivium and CubeAttack-BooleanFunctionParser can now be switched during program execution
Location:
trunk/CrypPlugins/CubeAttack
Files:
2 edited

Legend:

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

    r563 r617  
    1111using Cryptool.PluginBase.Miscellaneous;
    1212using Cryptool.PluginBase.IO;
    13 // reference to the BFPController interface
     13// Reference to the BFPController interface
    1414using Cryptool.BooleanFunctionParserController;
    15 // reference to the TriviumController interface (own dll)
     15// Reference to the TriviumController interface (own dll)
    1616using Cryptool.TriviumController;
    1717
     
    249249        public int Blackbox(int[] v, int[] x)
    250250        {
    251             int result = -1;
     251            int result = 0;
     252           
    252253            try
    253254            {
    254                 /*bool[] vBool = new bool[v.Length];
    255                 bool[] xBool = new bool[x.Length];
    256 
    257                 for (int i = 0; i < v.Length; i++)
    258                     vBool[i] = Convert.ToBoolean(v[i]);
    259                 for (int i = 0; i < x.Length; i++)
    260                     xBool[i] = Convert.ToBoolean(x[i]);
    261 
    262                 bool[] vx = new bool[v.Length + x.Length];
    263                 System.Buffer.BlockCopy(vBool, 0, vx, 0, vBool.Length);
    264                 System.Buffer.BlockCopy(xBool, 0, vx, vBool.Length, xBool.Length);
    265 
    266                 result = TestProperty.SolveFunction(null, vx, 1); */
    267                 result = TriviumOutput.GenerateTriviumKeystream(v, x, settings.TriviumOutputBit, settings.TriviumRounds, false);
     255                switch (settings.BlackBox)
     256                {
     257                    // Parser as black box
     258                    case 0:
     259                        bool[] vBool = new bool[v.Length];
     260                        bool[] xBool = new bool[x.Length];
     261                        for (int i = 0; i < v.Length; i++)
     262                            vBool[i] = Convert.ToBoolean(v[i]);
     263                        for (int i = 0; i < x.Length; i++)
     264                            xBool[i] = Convert.ToBoolean(x[i]);
     265                        bool[] vx = new bool[v.Length + x.Length];
     266                        System.Buffer.BlockCopy(vBool, 0, vx, 0, vBool.Length);
     267                        System.Buffer.BlockCopy(xBool, 0, vx, vBool.Length, xBool.Length);
     268                        result = ParserOutput.SolveFunction(null, vx, 1);
     269                        break;
     270                    // Trivium as black box
     271                    case 1:
     272                        if (settings.PublicVar != 80 || settings.SecretVar != 80)
     273                        {
     274                            CubeAttack_LogMessage("Public bit size and Secret bit size must be 80", NotificationLevel.Error);
     275                            stop = true;
     276                            break;
     277                        }
     278                        else
     279                        {
     280                            result = TriviumOutput.GenerateTriviumKeystream(v, x, settings.TriviumOutputBit, settings.TriviumRounds, false);
     281                            break;
     282                        }
     283                }
    268284            }
    269285            catch (Exception ex)
    270286            {
     287                stop = true;
    271288                CubeAttack_LogMessage("Error: " + ex, NotificationLevel.Error);
    272289            }
    273             if (result == -1)
    274             {
    275                 CubeAttack_LogMessage("Error: -1", NotificationLevel.Error);
    276                 return result;
    277             }
    278             else
    279                 return result;
    280            
    281             /*// Begin Trivium
    282             // Initialisierung
    283                 int[] a = new int[93];
    284                 int[] b = new int[84];
    285             int[] c = new int[111];
    286             int t1, t2, t3;
    287             int i,j;
    288                 for (i = 0; i < 80; i++)
    289             {
    290                 a[i] = x[i];
    291                 b[i] = v[i];
    292                         c[i] = 0;
    293                 }
    294                 while (i < 84){
    295                         a[i] = 0;
    296                         b[i] = 0;
    297                         c[i] = 0;
    298                         i++;
    299                 }
    300                 while (i < 93){
    301                         a[i] = 0;
    302                         c[i] = 0;
    303                         i++;
    304                 }
    305                 while (i < 108){
    306                         c[i] = 0;
    307                         i++;
    308                 }
    309                 while (i < 111){
    310                         c[i] = 1;
    311                         i++;
    312                 }
    313 
    314                 for (i = 0; i < 672; i++)
    315             {
    316                         t1 = a[65] ^ a[92];
    317                         t2 = b[68] ^ b[83];
    318                         t3 = c[65] ^ c[110];
    319                         t1 = t1 ^ (a[90] & a[91]) ^ b[77];
    320                         t2 = t2 ^ (b[81] & b[82]) ^ c[86];
    321                         t3 = t3 ^ (c[108] & c[109]) ^ a[68];
    322                         for (j = 92; j > 0; j--)
    323                                 a[j] = a[j-1];
    324                         for (j = 83; j > 0; j--)
    325                                 b[j] = b[j-1];
    326                         for (j = 110; j > 0; j--)
    327                                 c[j] = c[j-1];
    328                         a[0] = t3;
    329                         b[0] = t1;
    330                         c[0] = t2;
    331                 }
    332 
    333             // Keystream
    334             List<int> keyOutput = new List<int>();
    335                 for (i = 0; i < 13; i++)
    336             {
    337                         t1 = a[65] ^ a[92];
    338                         t2 = b[68] ^ b[83];
    339                         t3 = c[65] ^ c[110];
    340                 keyOutput.Add(t1 ^ t2 ^ t3);
    341                         t1 = t1 ^ (a[90] & a[91]) ^ b[77];
    342                         t2 = t2 ^ (b[81] & b[82]) ^ c[86];
    343                         t3 = t3 ^ (c[108] & c[109]) ^ a[68];
    344                         for (j = 92; j > 0; j--)
    345                                 a[j] = a[j-1];
    346                         for (j = 83; j > 0; j--)
    347                                 b[j] = b[j-1];
    348                         for (j = 110; j > 0; j--)
    349                                 c[j] = c[j-1];
    350                         a[0] = t3;
    351                         b[0] = t1;
    352                         c[0] = t2;
    353                 }
    354             return keyOutput[12];
    355             // End Trivium */
     290            return result;
    356291        }
    357292
     
    370305            int[] secVarElement = new int[settings.SecretVar];
    371306
    372             CubeAttack_LogMessage("Compute superpoly", NotificationLevel.Info);
     307            CubeAttack_LogMessage("Start deriving the algebraic structure of the superpoly, compute " + settings.SecretVar + " coefficients and the value of the constant term", NotificationLevel.Info);
    373308
    374309            // Compute the free term
    375310            for (ulong i = 0; i < Math.Pow(2, cube.Count); i++)
    376311            {
     312                if (stop)
     313                    return superpoly;
     314
    377315                for (int j = 0; j < cube.Count; j++)
    378316                    pubVarElement[cube[j]] = (i & ((ulong)1 << j)) > 0 ? 1 : 0;
     
    380318            }
    381319            superpoly.Add(constant);
    382             CubeAttack_LogMessage("c = " + (constant).ToString(), NotificationLevel.Info);
     320            CubeAttack_LogMessage("Constant term = " + (constant).ToString(), NotificationLevel.Info);
    383321
    384322            // Compute coefficients
     
    387325                for (ulong i = 0; i < Math.Pow(2, cube.Count); i++)
    388326                {
     327                    if (stop)
     328                        return superpoly;
     329
    389330                    secVarElement[k] = 1;
    390331                    for (int j = 0; j < cube.Count; j++)
    391332                        pubVarElement[cube[j]] = (i & ((ulong)1 << j)) > 0 ? 1 : 0;
    392333                    coeff ^= Blackbox((int[])pubVarElement.Clone(), (int[])secVarElement.Clone());
    393 
    394                     if (stop)
    395                     {
    396                         ProgressChanged(0.0, 1.0);
    397                         break;
    398                     }
    399334                }
    400335                superpoly.Add(constant ^ coeff);
    401                 CubeAttack_LogMessage("a" + k + " = " + (constant ^ coeff).ToString(), NotificationLevel.Info);
     336                CubeAttack_LogMessage("Coefficient of x" + k + " = " + (constant ^ coeff), NotificationLevel.Info);
    402337                coeff = 0;
    403338                secVarElement[k] = 0;
     
    438373            if (cube.Count > 0)
    439374            {
     375                cube.Sort();
    440376                for (int i = 0; i < cube.Count - 1; i++)
    441377                    output.Append(cube[i] + ",");
     
    467403        /// <returns>A boolean value indicating if the superpoly is in the matrix or not.</returns>
    468404        public bool InMatrix(List<int> superpoly, Matrix matrix)
    469 
    470405        {
    471406            bool isEqual = true;
     
    521456            int[] vecXY = new int[settings.SecretVar];
    522457
    523             CubeAttack_LogMessage("Linearity test", NotificationLevel.Info);
    524 
    525458            for (int k = 0; k < settings.LinTest; k++)
    526459            {
     460                CubeAttack_LogMessage("Linearity test " + (k + 1) + " of " + settings.LinTest, NotificationLevel.Info);
    527461                psLeft = 0;
    528462                psRight = 0;
     
    541475                for (ulong i = 0; i < Math.Pow(2, cube.Count); i++)
    542476                {
     477                    if (stop)
     478                        return false;
     479
    543480                    for (int j = 0; j < cube.Count; j++)
    544481                        pubVarElement[cube[j]] = (i & ((ulong)1 << j)) > 0 ? 1 : 0;
     
    549486                }
    550487                if (psLeft != psRight)
     488                {
     489                    CubeAttack_LogMessage("Linearity test " + (k + 1) + " failed", NotificationLevel.Info);
    551490                    return false;
     491                }
    552492
    553493                if (stop)
    554                 {
    555                     ProgressChanged(0.0, 1.0);
    556                     break;
    557                 }
     494                    return false;
    558495            }
    559496            return true;
     
    574511            int[] pubVarElement = new int[settings.PublicVar];
    575512
    576             CubeAttack_LogMessage("Test if superpoly is constant", NotificationLevel.Info);
     513            string outputCube = string.Empty;
     514            foreach (int element in cube)
     515                outputCube += "v" + element + " ";
     516            CubeAttack_LogMessage("Test if superpoly of subset " + outputCube + " is constant", NotificationLevel.Info);
    577517
    578518            for (int i = 0; i < settings.ConstTest; i++)
     
    582522                for (ulong j = 0; j < Math.Pow(2, cube.Count); j++)
    583523                {
     524                    if (stop)
     525                        return false;
     526
    584527                    for (int k = 0; k < cube.Count; k++)
    585528                        pubVarElement[cube[k]] = (j & ((ulong)1 << k)) > 0 ? 1 : 0;
    586529                    output ^= Blackbox(pubVarElement, vectorX);
    587 
    588                     if (stop)
    589                     {
    590                         ProgressChanged(0.0, 1.0);
    591                         break;
    592                     }
    593530                }
    594531                if (i == 0)
    595532                    flag = output;
    596533                if (flag != output)
     534                {
     535                    CubeAttack_LogMessage("Superpoly of subset " + outputCube + " is not constant", NotificationLevel.Info);
    597536                    return false;
     537                }
    598538                output = 0;
     539
     540                if (stop)
     541                    return false;
    599542            }
    600543            return true;
     
    679622
    680623        /// <summary>
    681         /// Preprocessing Phase of the cube attack. Implementation of the algorithm RandomWalk to find maxterms.
     624        /// Preprocessing Phase of the cube attack.
     625        /// Implementation of the algorithm Random-Walk to find maxterms.
    682626        /// </summary>
    683627        public void PreprocessingPhase()
    684628        {
    685             CubeAttack_LogMessage("Begin preprocessing", NotificationLevel.Info);
     629            CubeAttack_LogMessage("Start preprocessing", NotificationLevel.Info);
    686630
    687631            outputMaxterm = string.Empty;
     
    705649            while (countMaxterms < settings.SecretVar)
    706650            {
    707                 cube = new List<int>();
    708                 superpoly.Clear();
    709 
    710                 // Generate random size k between 1 and the number of public variables
    711                 numberOfVariables = rnd.Next(1, settings.MaxCube + 1);
    712 
    713                 // Permutation of the public variables
    714                 Shuffle<int>(chooseIndexI);
    715 
    716                 // Construct cube of size k. Add k public variables to the cube
    717                 for (int i = 0; i < numberOfVariables; i++)
    718                     cube.Add(chooseIndexI[i]);
    719                
    720                 string outputCube = string.Empty;
    721                 foreach (int element in cube)
    722                     outputCube += "v" + element + " ";
    723                 CubeAttack_LogMessage("Begin search for maxterm with subterm: " + outputCube, NotificationLevel.Info);
    724                 while (superpoly.Count == 0)
    725                 {
    726                     if (cube.Count == 0)
    727                     {
    728                         // Subterm is empty, restart with new subset
    729                         break;
    730                     }
    731 
    732                     if (IsSuperpolyConstant(cube))
    733                     {
    734                         CubeAttack_LogMessage("Superpoly is constant, drop variable v" + cube[0], NotificationLevel.Info);
    735                         cube.RemoveAt(0);
    736                     }
    737                     else if (!IsLinear(cube))
    738                     {
    739                         CubeAttack_LogMessage("Superpoly is not linear", NotificationLevel.Info);
    740                         if (numberOfVariables < chooseIndexI.Count)
    741                         {
    742                             if (cube.Count <= settings.MaxCube)
     651                if (stop)
     652                    return;
     653                else
     654                {
     655                    cube = new List<int>();
     656                    superpoly.Clear();
     657
     658                    // Generate random size k between 1 and the number of public variables
     659                    numberOfVariables = rnd.Next(1, settings.MaxCube + 1);
     660
     661                    // Permutation of the public variables
     662                    Shuffle<int>(chooseIndexI);
     663
     664                    // Construct cube of size k. Add k public variables to the cube
     665                    for (int i = 0; i < numberOfVariables; i++)
     666                        cube.Add(chooseIndexI[i]);
     667
     668                    string outputCube = string.Empty;
     669                    foreach (int element in cube)
     670                        outputCube += "v" + element + " ";
     671                    CubeAttack_LogMessage("Start search for maxterm with subterm: " + outputCube, NotificationLevel.Info);
     672                    while (superpoly.Count == 0)
     673                    {
     674                        if (cube.Count == 0)
     675                        {
     676                            if (numberOfVariables < chooseIndexI.Count)
    743677                            {
    744                                 CubeAttack_LogMessage("Add variable v" + chooseIndexI[numberOfVariables], NotificationLevel.Info);
     678                                CubeAttack_LogMessage("Subset is empty, add variable v" + chooseIndexI[numberOfVariables], NotificationLevel.Info);
    745679                                cube.Add(chooseIndexI[numberOfVariables]);
    746680                                numberOfVariables++;
    747681                            }
    748                         }
    749                         else
    750                             break;
    751                     }
    752                     else
    753                     {
    754                         if (!CubeKnown(mCube, cube))
    755                         {
    756                             mCube.Add(cube);
    757                             outputCube = string.Empty;
    758                             foreach (int element in cube)
    759                                 outputCube += "v" + element + " ";
    760                             CubeAttack_LogMessage(outputCube + " is new maxterm", NotificationLevel.Info);
    761                             superpoly = ComputePSI(cube);
    762                             break;
    763                         }
    764                         else
     682                            else
     683                                break;
     684                        }
     685                        if (CubeKnown(mCube, cube))
    765686                        {
    766687                            // Maxterm is already known, break and restart with new subset
     
    768689                            break;
    769690                        }
    770                     }
    771 
    772                     outputCube = string.Empty;
    773                     foreach (int element in cube)
    774                         outputCube += "v" + element + " ";
    775                     CubeAttack_LogMessage("Subterm: " + outputCube, NotificationLevel.Info);
    776                 }
    777 
    778                 if (!InMatrix(superpoly, mSuperpoly))
    779                 {
    780                     List<int> superpolyWithoutConstant = new List<int>();
    781                     for (int i = 1; i < superpoly.Count; i++)
    782                         superpolyWithoutConstant.Add(superpoly[i]);
    783 
    784                     mCheckLinearity = mCheckLinearity.AddRow(superpolyWithoutConstant);
    785                     if (IsLinearIndependent(mCheckLinearity))
    786                     {
    787                         for (int j = 0; j < superpoly.Count; j++)
    788                             mSuperpoly[countMaxterms, j] = superpoly[j];
    789 
    790                         cubeIndex.Add(cube);
    791                         countMaxterms++;
    792                         OutputMaxterms(cube, superpoly);
    793                         ProgressChanged((double)countMaxterms / (double)settings.SecretVar, 1.0);
    794                     }
    795                     else
    796                         mCheckLinearity = mCheckLinearity.DeleteLastRow();
    797                 }
    798                 if (stop)
    799                 {
    800                     ProgressChanged(0.0, 1.0);
    801                     return;
    802                 }
    803             }
    804 
    805             if (countMaxterms == settings.SecretVar)
    806             {
    807                 // Save the free terms of the superpolys in a vector
    808                 for (int i = 0; i < settings.SecretVar; i++)
    809                     freeTerms[i] = mSuperpoly[i, 0];
    810                 mSuperpoly = mSuperpoly.DeleteFirstColumn();
    811 
    812                 try
    813                 {
    814                     mSuperpoly = mSuperpoly.Inverse();
    815                     if (settings.OnlinePhase)
    816                         OnlinePhase(mSuperpoly, freeTerms, cubeIndex);
    817                 }
    818                 catch (Exception exception)
    819                 {
    820                     GuiLogMessage(exception.Message, NotificationLevel.Error);
    821                 }
    822             }
    823         }
     691
     692                        if (IsSuperpolyConstant(cube))
     693                        {
     694                            if (stop)
     695                                return;
     696                            else
     697                            {
     698                                CubeAttack_LogMessage("Superpoly is likely constant, drop variable v" + cube[0], NotificationLevel.Info);
     699                                cube.RemoveAt(0);
     700                            }
     701                        }
     702                        else if (!IsLinear(cube))
     703                        {
     704                            if (stop)
     705                                return;
     706                            else
     707                            {
     708                                CubeAttack_LogMessage("Superpoly is not linear", NotificationLevel.Info);
     709                                if (numberOfVariables < chooseIndexI.Count)
     710                                {
     711                                    if (cube.Count <= settings.MaxCube)
     712                                    {
     713                                        CubeAttack_LogMessage("Add variable v" + chooseIndexI[numberOfVariables], NotificationLevel.Info);
     714                                        cube.Add(chooseIndexI[numberOfVariables]);
     715                                        numberOfVariables++;
     716                                    }
     717                                }
     718                                else
     719                                    break;
     720                            }
     721                        }
     722                        else
     723                        {
     724                            if (stop)
     725                                return;
     726                            else
     727                            {
     728                                CubeAttack_LogMessage("Superpoly is likely linear", NotificationLevel.Info);
     729                                mCube.Add(cube);
     730                                outputCube = string.Empty;
     731                                foreach (int element in cube)
     732                                    outputCube += "v" + element + " ";
     733                                CubeAttack_LogMessage(outputCube + " is new maxterm", NotificationLevel.Info);
     734                                superpoly = ComputePSI(cube);
     735                                break;
     736                            }
     737                        }
     738                    }//End while (superpoly.Count == 0)
     739
     740                    if (!InMatrix(superpoly, mSuperpoly))
     741                    {
     742                        List<int> superpolyWithoutConstant = new List<int>();
     743                        for (int i = 1; i < superpoly.Count; i++)
     744                            superpolyWithoutConstant.Add(superpoly[i]);
     745
     746                        mCheckLinearity = mCheckLinearity.AddRow(superpolyWithoutConstant);
     747                        if (IsLinearIndependent(mCheckLinearity))
     748                        {
     749                            for (int j = 0; j < superpoly.Count; j++)
     750                                mSuperpoly[countMaxterms, j] = superpoly[j];
     751
     752                            cubeIndex.Add(cube);
     753                            countMaxterms++;
     754                            OutputMaxterms(cube, superpoly);
     755                            ProgressChanged((double)countMaxterms / (double)settings.SecretVar, 1.0);
     756                        }
     757                        else
     758                            mCheckLinearity = mCheckLinearity.DeleteLastRow();
     759                    }
     760
     761                    if (countMaxterms == settings.SecretVar)
     762                    {
     763                        // Save the free terms of the superpolys in a vector
     764                        for (int i = 0; i < settings.SecretVar; i++)
     765                            freeTerms[i] = mSuperpoly[i, 0];
     766                        mSuperpoly = mSuperpoly.DeleteFirstColumn();
     767
     768                        try
     769                        {
     770                            if (settings.OnlinePhase)
     771                            {
     772                                CubeAttack_LogMessage("Start online phase", NotificationLevel.Info);
     773                                CubeAttack_LogMessage("Invert matrix", NotificationLevel.Info);
     774                                mSuperpoly = mSuperpoly.Inverse();
     775                                OnlinePhase(mSuperpoly, freeTerms, cubeIndex);
     776                            }
     777                        }
     778                        catch (Exception exception)
     779                        {
     780                            GuiLogMessage(exception.Message, NotificationLevel.Error);
     781                        }
     782                    }
     783                }
     784            }//End while (countMaxterms < settings.SecretVar)
     785        }//End PreprocessingPhase
    824786
    825787        /// <summary>
     
    831793        public void OnlinePhase(Matrix mSuperpoly, Vector b, List<List<int>> cubeIndex)
    832794        {
    833             CubeAttack_LogMessage("Begin online phase", NotificationLevel.Info);
    834 
    835795            int[] pubVarElement = new int[settings.PublicVar];
    836            
     796            bool superpolyHasConstantTerm = false;
     797
    837798            for (int i = 0; i < settings.SecretVar; i++)
    838799            {
     800                if (b[i] == 1)
     801                    superpolyHasConstantTerm = true;
    839802                for (int j = 0; j < settings.PublicVar; j++)
    840803                    pubVarElement[j] = 0;
    841804                for (ulong k = 0; k < Math.Pow(2, cubeIndex[i].Count); k++)
    842805                {
     806                    if (stop)
     807                        return;
     808
    843809                    for (int l = 0; l < cubeIndex[i].Count; l++)
    844810                        pubVarElement[cubeIndex[i][l]] = (k & ((ulong)1 << l)) > 0 ? 1 : 0;
    845 
    846811                    try
    847812                    {
     
    850815                        for (int l = 0; l < pubVarElement.Length; l++)
    851816                            vBool[l] = Convert.ToBoolean(pubVarElement[l]);
    852 
    853                         b[i] ^= TestProperty.SolveFunction(null, vBool, 2);
     817                        b[i] ^= ParserOutput.SolveFunction(null, vBool, 2);
    854818                    }
    855819                    catch (Exception ex)
     
    858822                    }
    859823                }
    860                 CubeAttack_LogMessage("Secret bit x" + i + " = " + b[i], NotificationLevel.Info);
     824                if (superpolyHasConstantTerm)
     825                    CubeAttack_LogMessage("Value of maxterm equation " + (i + 1) + " of " + settings.SecretVar + " = " + (b[i] ^ 1), NotificationLevel.Info);
     826                else
     827                    CubeAttack_LogMessage("Value of maxterm equation " + (i + 1) + " of " + settings.SecretVar + " = " + b[i], NotificationLevel.Info);
     828                // Reset variable
     829                superpolyHasConstantTerm = false;
    861830            }
    862831            OutputKey(mSuperpoly * b);
     
    877846
    878847            if (settings.SetPublicBits.Length != settings.PublicVar)
    879                 CubeAttack_LogMessage("Input public bits must have size " + settings.PublicVar + " !", NotificationLevel.Error);
     848                CubeAttack_LogMessage("Input public bits must have size " + settings.PublicVar + " (Currently: " + settings.SetPublicBits.Length + " )", NotificationLevel.Error);
    880849            else
    881850            {
     
    902871                else
    903872                {
    904                     //int result = TriviumOutput.GenerateTriviumKeystream(pubVari, secVari, settings.TriviumOutputBit, settings.TriviumRounds, false);
    905                     //CubeAttack_LogMessage("Result = " + result, NotificationLevel.Info);
    906873                    if (cube.Count > 0)
    907874                    {
     
    909876                        {
    910877                            List<int> superpoly = ComputePSI(cube);
    911                             OutputMaxterms(cube, superpoly);
     878                            if (!stop)
     879                                OutputMaxterms(cube, superpoly);
    912880                        }
    913881                        else
    914                           CubeAttack_LogMessage("The corresponding superpoly is not a linear polynomial !", NotificationLevel.Info);
     882                        {
     883                            if(!stop)
     884                                CubeAttack_LogMessage("The corresponding superpoly is not a linear polynomial !", NotificationLevel.Info);
     885                        }
    915886                    }
    916887                    else
     
    963934        #region IControlEncryption Members
    964935
    965         private IControlSolveFunction testProperty;
     936        private IControlSolveFunction parserOutput;
    966937        [PropertyInfo(Direction.ControlMaster, "Master for BFP", "Master for BFP (SolveFunction)", "", DisplayLevel.Beginner)]
    967         public IControlSolveFunction TestProperty
    968         {
    969             get { return testProperty; }
     938        public IControlSolveFunction ParserOutput
     939        {
     940            get { return parserOutput; }
    970941            set
    971942            {
    972943                if (value != null)
    973                     testProperty = value;
     944                    parserOutput = value;
    974945            }
    975946        }
  • trunk/CrypPlugins/CubeAttack/CubeAttackSettings.cs

    r563 r617  
    4242
    4343        private bool hasChanges;
     44        private int selectedBlackBox = 0;
    4445        private int selectedAction = 0;
    4546        bool onlinePhase = false;
     
    5960
    6061        [PropertySaveOrder(1)]
     62        [ContextMenu("Black box",
     63            "Select the black box",
     64            1,
     65            DisplayLevel.Beginner,
     66            ContextMenuControlType.ComboBox,
     67            null,
     68            "Boolean function parser",
     69            "Trivium")]
     70        [TaskPane("Black box",
     71            "Select the black box",
     72            "",
     73            1,
     74            false,
     75            DisplayLevel.Beginner,
     76            ControlType.ComboBox,
     77            new string[] { "Boolean function parser", "Trivium" })]
     78        public int BlackBox
     79        {
     80            get { return this.selectedBlackBox; }
     81            set
     82            {
     83                if (value != selectedBlackBox) HasChanges = true;
     84                this.selectedBlackBox = value;
     85                OnPropertyChanged("BlackBox");
     86            }
     87        }
     88
     89        [PropertySaveOrder(2)]
    6190        [ContextMenu("Action",
    6291            "Select the Algorithm action",
    63             1,
     92            2,
    6493            DisplayLevel.Beginner,
    6594            ContextMenuControlType.ComboBox,
     
    7099            "Select the phase",
    71100            "",
    72             1,
     101            2,
    73102            false,
    74103            DisplayLevel.Beginner,
     
    86115        }
    87116
    88         [PropertySaveOrder(2)]
     117        [PropertySaveOrder(3)]
    89118        [ContextMenu("Try to discover key",
    90119            "Online phase of the cube attack which tries to solve the system of linear maxterm equations to discover the secret key.",
    91             2,
     120            3,
    92121            DisplayLevel.Beginner,
    93122            ContextMenuControlType.CheckBox,
     
    97126            "Online phase of the cube attack which tries to solve the system of linear maxterm equations to discover the secret key.",
    98127            null,
    99             2,
     128            3,
    100129            false,
    101130            DisplayLevel.Expert,
     
    112141        }
    113142
    114         [PropertySaveOrder(3)]
     143        [PropertySaveOrder(4)]
    115144        [TaskPane("Public bit size",
    116145            "Public input bits (IV or plaintext) of the attacked cryptosystem.",
    117146            null,
    118             3,
     147            4,
    119148            false,
    120149            DisplayLevel.Beginner,
     
    134163        }
    135164
    136         [PropertySaveOrder(4)]
     165        [PropertySaveOrder(5)]
    137166        [TaskPane("Secret bit size",
    138167            "Key size or key length  of the attacked cryptosystem.",
    139168            null,
    140             4,
     169            5,
    141170            false,
    142171            DisplayLevel.Beginner,
     
    156185        }
    157186
    158         [PropertySaveOrder(5)]
     187        [PropertySaveOrder(6)]
    159188        [TaskPane("Max cube size",
    160189            "Maxmium size of the summation cube.",
    161190            null,
    162             5,
     191            6,
    163192            false,
    164193            DisplayLevel.Beginner,
     
    178207        }
    179208
    180         [PropertySaveOrder(6)]
     209        [PropertySaveOrder(7)]
    181210        [TaskPane("Constant Test",
    182211            "Number of tests to check if the superpoly is a constant value or not.",
    183212            null,
    184             6,
     213            7,
    185214            false,
    186215            DisplayLevel.Beginner,
     
    200229        }
    201230
    202         [PropertySaveOrder(7)]
     231        [PropertySaveOrder(8)]
    203232        [TaskPane("Linearity tests",
    204233            "Number of linearity tests to check if the superpoly is linear or not.",
    205234            null,
    206             7,
     235            8,
    207236            false,
    208237            DisplayLevel.Beginner,
     
    222251        }
    223252
    224         [PropertySaveOrder(8)]
     253        [PropertySaveOrder(9)]
    225254        [TaskPane("Input public bits",
    226255            "Manual input of public bits.",
    227256            null,
    228             8,
     257            9,
    229258            false,
    230259            DisplayLevel.Beginner,
     
    248277        }
    249278
    250         [PropertySaveOrder(9)]
     279        [PropertySaveOrder(10)]
    251280        [TaskPane("Trivium output bit index",
    252281            "Chooses the output bit index in the stream cipher Trivium.",
    253282            null,
    254             9,
     283            10,
    255284            false,
    256285            DisplayLevel.Beginner,
     
    270299        }
    271300
    272         [PropertySaveOrder(10)]
     301        [PropertySaveOrder(11)]
    273302        [TaskPane("Trivium rounds",
    274303            "Number of Trivium initialisation rounds.",
    275304            null,
    276             10,
     305            11,
    277306            false,
    278307            DisplayLevel.Beginner,
Note: See TracChangeset for help on using the changeset viewer.