Changeset 832


Ignore:
Timestamp:
Nov 9, 2009, 12:03:29 PM (12 years ago)
Author:
Sören Rinne
Message:
  • slight changes in BerlekampMassey
  • changed CubeAttack, BooleanFunctionParser, Trivium to implement only one Controller interface (IControlGenerateBlackboxOutputBit)
  • modified samples
Location:
trunk
Files:
8 added
6 deleted
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/BerlekampMassey/BerlekampMasseyPresentation.xaml.cs

    r689 r832  
    236236          Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    237237          {
    238               lText.Text = "\t" + length;
     238              lText.Text = length;
    239239          }, null);
    240240      }
     
    244244          Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    245245          {
    246               cdText.Text = "\t" + polynommial;
     246              cdText.Text = polynommial;
    247247          }, null);
    248248      }
  • trunk/CrypPlugins/BooleanFunctionParser/BooleanFunctionParser.cs

    r752 r832  
    1818// for IControl
    1919using Cryptool.PluginBase.Control;
    20 // reference to the BFPController interface (own dll)
    21 using Cryptool.BooleanFunctionParserController;
     20// reference to the CubeAttackController interface (own dll)
     21using Cryptool.CubeAttackController;
    2222// for QuickwatchPresentaton
    2323using System.Windows.Threading;
     
    4141        private bool lastInputWasFunction = false;
    4242        private int inputs = 1;
    43         //private string fillValue;
    4443        private bool canSendPropertiesChangedEvent = true;
    4544
     
    5251        #region Public variables
    5352
    54         public int inputOneFlag = 0;
    55         public int inputTwoFlag = 0;
    56         public int inputThreeFlag = 0;
     53        //public int inputOneFlag = 0;
     54        //public int inputTwoFlag = 0;
     55        //public int inputThreeFlag = 0;
    5756        public int[] additionalInputsFlag = null;
    5857
     
    6766        {
    6867            this.settings = new BooleanFunctionParserSettings();
     68            settings.OnGuiLogNotificationOccured += settings_OnGuiLogNotificationOccured;
    6969            settings.PropertyChanged += settings_PropertyChanged;
    7070
     
    287287        void settings_PropertyChanged(object sender, PropertyChangedEventArgs e)
    288288        {
    289             // if the count of inputs has been change, renew all inputs
     289            // if the count of inputs has been changed, renew all inputs
    290290            if (e.PropertyName == "CountOfInputs")
    291291            {
     
    296296                booleanFunctionParserPresentation.SwitchCubeView(settings.UseBFPforCube);
    297297            }
     298        }
     299
     300        // catches LogNotification from settings
     301        private void settings_OnGuiLogNotificationOccured(IPlugin sender, GuiLogEventArgs args)
     302        {
     303            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(args.Message, this, args.NotificationLevel));
    298304        }
    299305
     
    525531            // replace AND, NAND, OR, NOR, XOR, NXOR with symbols
    526532            // NAND => -
    527             strExpression = strExpression.Replace("NAND", "-");
     533            //strExpression = strExpression.Replace("NAND", "-");
    528534            // AND => *
    529535            strExpression = strExpression.Replace("AND", "*");
    530536
    531537            // NOR => _
    532             strExpression = strExpression.Replace("NOR", "_");
     538            //strExpression = strExpression.Replace("NOR", "_");
    533539
    534540            // NXOR => °
    535             strExpression = strExpression.Replace("NXOR", "°");
     541            //strExpression = strExpression.Replace("NXOR", "°");
    536542            // XOR => *
    537543            strExpression = strExpression.Replace("XOR", "+");
    538544
    539545            // OR => |
    540             strExpression = strExpression.Replace("OR", "|");
     546            //strExpression = strExpression.Replace("OR", "|");
    541547
    542548            // replace ^ and & with symbols
    543549            // ^ => XOR => +
    544             strExpression = strExpression.Replace("^", "+");
     550            //strExpression = strExpression.Replace("^", "+");
    545551
    546552            // & => AND => *
    547             strExpression = strExpression.Replace("&", "*");
     553            //strExpression = strExpression.Replace("&", "*");
    548554
    549555            return strExpression;
     
    650656                    GuiLogMessage("sum fehlgeschlagen:", NotificationLevel.Info);
    651657                    GuiLogMessage("op1 and op2: " + operator1 + ", " + operator2, NotificationLevel.Info);
     658                    GuiLogMessage("exception: " + ex, NotificationLevel.Info);
    652659                }
    653660               
     
    817824        #region IControl
    818825
    819         private IControlSolveFunction bfpSlave;
     826        private IControlCubeAttack bfpSlave;
    820827        [PropertyInfo(Direction.ControlSlave, "BFP Slave", "Direct access to BFP.", "", DisplayLevel.Beginner)]
    821         public IControlSolveFunction BFPSlave
     828        public IControlCubeAttack BFPSlave
    822829        {
    823830            get
    824831            {
    825832                if (bfpSlave == null)
    826                     bfpSlave = new BFPControl(this);
     833                    bfpSlave = new CubeAttackControl(this);
    827834                return bfpSlave;
    828835            }
     
    832839    }
    833840
    834     #region BFPControl : IControlSolveFunction
    835 
    836     public class BFPControl : IControlSolveFunction
     841    #region CubeAttackControl : IControlCubeAttack
     842
     843    public class CubeAttackControl : IControlCubeAttack
    837844    {
    838845        public event IControlStatusChangedEventHandler OnStatusChanged;
    839846        private BooleanFunctionParser plugin;
    840847
    841         public BFPControl(BooleanFunctionParser Plugin)
     848        public CubeAttackControl(BooleanFunctionParser Plugin)
    842849        {
    843850            this.plugin = Plugin;
     
    847854
    848855        // here comes the slave side implementation of SolveFunction
    849         public int SolveFunction(bool[] dataOne, bool[] dataTwo)
     856        public int GenerateBlackboxOutputBit(object dataOne, object dataTwo, object ignoreMe)
    850857        {
    851858            int resultInt;
     859
     860            bool[] myDataOneBool = null;
     861            bool[] myDataTwoBool = null;
     862
     863            // parse objects and convert to boolean arrays
     864            if (dataOne != null)
     865            {
     866                int[] myDataOneInt = dataOne as int[];
     867                myDataOneBool = new bool[myDataOneInt.Length];
     868                for (int i = 0; i < myDataOneInt.Length; i++)
     869                {
     870                    myDataOneBool[i] = Convert.ToBoolean(myDataOneInt[i]);
     871                }
     872            }
     873
     874            if (dataTwo != null)
     875            {
     876                int[] myDataTwoInt = dataTwo as int[];
     877                myDataTwoBool = new bool[myDataTwoInt.Length];
     878                for (int i = 0; i < myDataTwoInt.Length; i++)
     879                {
     880                    myDataTwoBool[i] = Convert.ToBoolean(myDataTwoInt[i]);
     881                }
     882            }
    852883
    853884            // the result is computed by calling the ParseBooleanFunction (step into it with F11)
    854885            // returns -1 on error (e.g. not a valid function)
    855             resultInt = plugin.ParseBooleanFunction(dataOne, dataTwo);
     886            resultInt = plugin.ParseBooleanFunction(myDataOneBool, myDataTwoBool);
    856887
    857888            return resultInt;
  • trunk/CrypPlugins/BooleanFunctionParser/BooleanFunctionParser.csproj

    r585 r832  
    101101  </ItemGroup>
    102102  <ItemGroup>
    103     <ProjectReference Include="..\BooleanFunctionParserController\BooleanFunctionParserController.csproj">
    104       <Project>{273EA298-0198-4CA5-B10A-D85FE6FE5499}</Project>
    105       <Name>BooleanFunctionParserController</Name>
     103    <ProjectReference Include="..\CubeAttackController\CubeAttackController.csproj">
     104      <Project>{2100AC2F-3F2B-48A2-AF42-87EC52C8A703}</Project>
     105      <Name>CubeAttackController</Name>
    106106    </ProjectReference>
    107107  </ItemGroup>
  • trunk/CrypPlugins/BooleanFunctionParser/BooleanFunctionParserSettings.cs

    r599 r832  
    1818        #region Private variables
    1919
    20         private bool hasChanges;
     20        private bool hasChanges = false;
    2121        private bool useBFPforCube = false;
     22        private int saveInputsCount = 1;
    2223
    2324        #endregion
     
    8081            set
    8182            {
    82                 this.countOfInputs = value;
    83                 OnPropertyChanged("CountOfInputs");
    84                 HasChanges = true;
     83                // this handling has to be implemented; doesn't work as expected right now
     84                /*if (CanChangeProperty)
     85                {*/
     86                    this.countOfInputs = value;
     87                    OnPropertyChanged("CountOfInputs");
     88                    //saveInputsCount = value;
     89                    HasChanges = true;
     90                /*}
     91                else
     92                {
     93                    EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, null, new GuiLogEventArgs("Can't change number of boolean inputs while plugin is connected.", null, NotificationLevel.Warning));
     94                    this.countOfInputs = saveInputsCount;
     95                }*/
    8596            }
    8697        }
     
    114125        {
    115126            get { return hasChanges; }
    116             set { hasChanges = value; }
     127            set
     128            {
     129                if (value != hasChanges)
     130                {
     131                    hasChanges = value;
     132                    OnPropertyChanged("HasChanges");
     133                }
     134            }
    117135        }
    118136
     
    124142
    125143        public event PropertyChangedEventHandler PropertyChanged;
     144
     145        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
    126146
    127147        public void OnPropertyChanged(string name)
  • trunk/CrypPlugins/CubeAttack/CubeAttack.cs

    r748 r832  
    1111using Cryptool.PluginBase.Miscellaneous;
    1212using Cryptool.PluginBase.IO;
    13 // Reference to the BFPController interface
    14 using Cryptool.BooleanFunctionParserController;
    15 // Reference to the TriviumController interface (own dll)
    16 using Cryptool.TriviumController;
     13// Reference to the CubeAttackController interface (own dll)
     14using Cryptool.CubeAttackController;
    1715
    1816namespace Cryptool.CubeAttack
     
    3230
    3331        private CubeAttackSettings settings;
    34         private string outputSuperpoly;
    3532        private string outputKeyBits;
    3633        private enum CubeAttackMode { preprocessing, online, setPublicBits };
    3734        private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    3835        private bool stop = false;
    39 
     36       
    4037        #endregion
    4138
     
    4340        #region Public variables
    4441
     42        public int[] pubVarGlob = null;
     43        public int indexOutputBit = 1;
     44
     45        public string outputSuperpoly = null;
    4546        public Matrix superpolyMatrix = null;
    4647        public List<List<int>> listCubeIndexes = null;
    47         public int[] pubVarGlob = null;
    48         public int indexOutputBit;
    49         public int[] outputBitIndex;
     48        public int[] outputBitIndex = null;
     49        public int countSuperpoly = 0;
     50        public Matrix matrixCheckLinearitySuperpolys = null;
    5051
    5152        #endregion
     
    206207        {
    207208            this.stop = true;
     209
     210            /*if (settings.Action == 0) // Action = Preprocessing
     211            {
     212                settings.SaveOutputSuperpoly = outputSuperpoly;
     213                settings.SaveSuperpolyMatrix = superpolyMatrix;
     214                settings.SaveListCubeIndexes = listCubeIndexes;
     215                settings.SaveOutputBitIndex = outputBitIndex;
     216                settings.SaveCountSuperpoly = countSuperpoly;
     217                settings.SaveMatrixCheckLinearitySuperpolys = matrixCheckLinearitySuperpolys;
     218            }*/
    208219        }
    209220
     
    211222        {
    212223            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); */
    213233        }
    214234
     
    216236        {
    217237            Dispose();
     238
     239            /*if (settings.Action == 0) // Action = Preprocessing
     240            {
     241                if (settings.SaveCountSuperpoly != settings.SecretVar)
     242                {
     243                    if (settings.SaveOutputSuperpoly != null)
     244                        outputSuperpoly = settings.SaveOutputSuperpoly;
     245                    if (settings.SaveSuperpolyMatrix != null)
     246                        superpolyMatrix = settings.SaveSuperpolyMatrix;
     247                    if (settings.SaveListCubeIndexes != null)
     248                        listCubeIndexes = settings.SaveListCubeIndexes;
     249                    if (settings.SaveOutputBitIndex != null)
     250                        outputBitIndex = settings.SaveOutputBitIndex;
     251                    if (settings.SaveCountSuperpoly != 0)
     252                        countSuperpoly = settings.SaveCountSuperpoly;
     253                    if (settings.SaveMatrixCheckLinearitySuperpolys != null)
     254                        matrixCheckLinearitySuperpolys = settings.SaveMatrixCheckLinearitySuperpolys;
     255                }
     256            }*/
    218257        }
    219258
     
    347386            try
    348387            {
    349                 switch (settings.BlackBox)
     388                //switch (settings.BlackBox)
    350389                {
    351390                    // Parser as black box
    352                     case 0:
     391                    //case 0:
    353392                        bool[] vBool = new bool[v.Length];
    354393                        bool[] xBool = new bool[x.Length];
     
    357396                        for (int i = 0; i < x.Length; i++)
    358397                            xBool[i] = Convert.ToBoolean(x[i]);
    359                         /*bool[] vx = new bool[v.Length + x.Length];
    360                         System.Buffer.BlockCopy(vBool, 0, vx, 0, vBool.Length);
    361                         System.Buffer.BlockCopy(xBool, 0, vx, vBool.Length, xBool.Length); */
    362                         result = ParserOutput.SolveFunction(vBool, xBool);
    363                         break;
     398                        result = CubeattackBlackbox.GenerateBlackboxOutputBit(v, x, indexOutputBit);   //ParserOutput.SolveFunction(vBool, xBool);
     399                        //  break;
    364400                    // Trivium as black box
    365                     case 1:
    366                         if (settings.PublicVar != 80 || settings.SecretVar != 80)
    367                         {
    368                             CubeAttack_LogMessage("Public bit size and Secret bit size must be 80", NotificationLevel.Error);
    369                             stop = true;
    370                             break;
    371                         }
    372                         else
    373                         {
    374                             result = TriviumOutput.GenerateTriviumKeystream(v, x, indexOutputBit, false);
    375                             break;
    376                         }
     401                        //case 1:
     402                        //result = TriviumOutput.GenerateTriviumKeystream(v, x, indexOutputBit, false);
     403                    //break;
    377404                }
    378405            }
     
    398425            int[] secVarElement = new int[settings.SecretVar];
    399426
    400             CubeAttack_LogMessage("Start deriving the algebraic structure of the superpoly", NotificationLevel.Info);
     427            if (settings.EnableLogMessages)
     428                CubeAttack_LogMessage("Start deriving the algebraic structure of the superpoly", NotificationLevel.Info);
    401429
    402430            // Compute the free term
     
    411439            }
    412440            superpoly.Add(constant);
    413             CubeAttack_LogMessage("Constant term = " + (constant).ToString(), NotificationLevel.Info);
     441
     442            if (settings.EnableLogMessages)
     443                CubeAttack_LogMessage("Constant term = " + (constant).ToString(), NotificationLevel.Info);
    414444
    415445            // Compute coefficients
     
    427457                }
    428458                superpoly.Add(constant ^ coeff);
    429                 CubeAttack_LogMessage("Coefficient of x" + k + " = " + (constant ^ coeff), NotificationLevel.Info);
     459
     460                if (settings.EnableLogMessages)
     461                    CubeAttack_LogMessage("Coefficient of x" + k + " = " + (constant ^ coeff), NotificationLevel.Info);
     462               
    430463                coeff = 0;
    431464                secVarElement[k] = 0;
     
    474507                output.Append(" }");
    475508
    476             // Output Bit Index if Trivium is Black Box
    477             if (settings.BlackBox == 1)
    478                 output.Append("   Trivium Output Bit Index: " + indexOutputBit + "\n");
    479             else
    480                 output.Append("\n");
    481 
     509            output.Append("   Output Bit: " + indexOutputBit + "\n");
     510           
    482511            outputSuperpoly += output.ToString();
    483512            OnPropertyChanged("OutputSuperpoly");
     
    557586            for (int k = 0; k < settings.LinTest; k++)
    558587            {
    559                 CubeAttack_LogMessage("Linearity test " + (k + 1) + " of " + settings.LinTest, NotificationLevel.Info);
     588                if (settings.EnableLogMessages)
     589                    CubeAttack_LogMessage("Linearity test " + (k + 1) + " of " + settings.LinTest, NotificationLevel.Info);
     590               
    560591                psLeft = 0;
    561592                psRight = 0;
     
    586617                if (psLeft != psRight)
    587618                {
    588                     CubeAttack_LogMessage("Linearity test " + (k + 1) + " failed", NotificationLevel.Info);
     619                    if (settings.EnableLogMessages)
     620                        CubeAttack_LogMessage("Linearity test " + (k + 1) + " failed", NotificationLevel.Info);
    589621                    return false;
    590622                }
     
    613645                outputCube += "v" + element + " ";
    614646            if(settings.ConstTest > 0)
    615                 CubeAttack_LogMessage("Test if superpoly of subset " + outputCube + " is constant", NotificationLevel.Info);
     647                if (settings.EnableLogMessages)
     648                    CubeAttack_LogMessage("Test if superpoly of subset " + outputCube + " is constant", NotificationLevel.Info);
    616649            for (int i = 0; i < settings.ConstTest; i++)
    617650            {
     
    631664                if (flag != output)
    632665                {
    633                     CubeAttack_LogMessage("Superpoly of subset " + outputCube + " is not constant", NotificationLevel.Info);
     666                    if (settings.EnableLogMessages)
     667                        CubeAttack_LogMessage("Superpoly of subset " + outputCube + " is not constant", NotificationLevel.Info);
    634668                    return false;
    635669                }
     
    732766            indexOutputBit = settings.TriviumOutputBit;
    733767            pubVarGlob = null;
    734             outputSuperpoly = string.Empty;
    735             superpolyMatrix = new Matrix(settings.SecretVar, settings.SecretVar + 1);
    736             listCubeIndexes = new List<List<int>>();
    737             outputBitIndex = new int[settings.SecretVar];
    738 
    739             int countSuperpoly = 0;
     768
     769            //if (countSuperpoly == settings.SecretVar)
     770            {
     771                outputSuperpoly = string.Empty;
     772                superpolyMatrix = new Matrix(settings.SecretVar, settings.SecretVar + 1);
     773                listCubeIndexes = new List<List<int>>();
     774                outputBitIndex = new int[settings.SecretVar];
     775                countSuperpoly = 0;
     776                matrixCheckLinearitySuperpolys = new Matrix(0, settings.SecretVar);
     777            }
     778
     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);
     791
    740792            Random rnd = new Random();
    741793            int numberOfVariables = 0;
    742794            List<int> chooseIndexI = new List<int>();
    743             Matrix matrixCheckLinearitySuperpolys = new Matrix(0, settings.SecretVar);
    744795            List<int> superpoly = new List<int>();
    745796            List<int> maxterm = new List<int>();
     
    773824                    foreach (int element in maxterm)
    774825                        outputCube += "v" + element + " ";
    775                     CubeAttack_LogMessage("Start search for maxterm with subterm: " + outputCube, NotificationLevel.Info);
     826
     827                    if (settings.EnableLogMessages)
     828                        CubeAttack_LogMessage("Start search for maxterm with subterm: " + outputCube, NotificationLevel.Info); 
     829                   
    776830                    if (settings.TriviumOutputBit != indexOutputBit)
    777831                    {
     
    788842                            if (numberOfVariables < chooseIndexI.Count)
    789843                            {
    790                                 CubeAttack_LogMessage("Subset is empty, add variable v" + chooseIndexI[numberOfVariables], NotificationLevel.Info);
     844                                if (settings.EnableLogMessages)
     845                                    CubeAttack_LogMessage("Subset is empty, add variable v" + chooseIndexI[numberOfVariables], NotificationLevel.Info);
    791846                                maxterm.Add(chooseIndexI[numberOfVariables]);
    792847                                numberOfVariables++;
     
    798853                        {
    799854                            // Maxterm is already known, break and restart with new subset
    800                             outputCube = string.Empty;
    801                             foreach (int element in maxterm)
    802                                 outputCube += "v" + element + " ";
    803                             CubeAttack_LogMessage("Maxterm " + outputCube + " is already known, restart with new subset", NotificationLevel.Info);
     855                            if (settings.EnableLogMessages)
     856                            {
     857                                outputCube = string.Empty;
     858                                foreach (int element in maxterm)
     859                                    outputCube += "v" + element + " ";
     860                                CubeAttack_LogMessage("Maxterm " + outputCube + " is already known, restart with new subset", NotificationLevel.Info);
     861                            }
    804862                            break;
    805863                        }
     
    811869                            else
    812870                            {
    813                                 CubeAttack_LogMessage("Superpoly is likely constant, drop variable v" + maxterm[0], NotificationLevel.Info);
     871                                if (settings.EnableLogMessages)
     872                                    CubeAttack_LogMessage("Superpoly is likely constant, drop variable v" + maxterm[0], NotificationLevel.Info);
    814873                                maxterm.RemoveAt(0);
    815874                            }
     
    821880                            else
    822881                            {
    823                                 CubeAttack_LogMessage("Superpoly is not linear", NotificationLevel.Info);
     882                                if (settings.EnableLogMessages)
     883                                    CubeAttack_LogMessage("Superpoly is not linear", NotificationLevel.Info);
    824884                                if (numberOfVariables < chooseIndexI.Count)
    825885                                {
    826886                                    if (maxterm.Count < settings.MaxCube)
    827887                                    {
    828                                         CubeAttack_LogMessage("Add variable v" + chooseIndexI[numberOfVariables], NotificationLevel.Info);
     888                                        if (settings.EnableLogMessages)
     889                                            CubeAttack_LogMessage("Add variable v" + chooseIndexI[numberOfVariables], NotificationLevel.Info);
    829890                                        maxterm.Add(chooseIndexI[numberOfVariables]);
    830891                                        numberOfVariables++;
     
    843904                            else
    844905                            {
    845                                 //CubeAttack_LogMessage("Superpoly is likely linear", NotificationLevel.Info);
    846906                                cubeList.Add(maxterm);
    847                                 outputCube = string.Empty;
    848                                 foreach (int element in maxterm)
    849                                     outputCube += "v" + element + " ";
    850                                 CubeAttack_LogMessage(outputCube + " is new maxterm", NotificationLevel.Info);
    851                                 outputCube = string.Empty;
     907                                if (settings.EnableLogMessages)
     908                                {
     909                                    outputCube = string.Empty;
     910                                    foreach (int element in maxterm)
     911                                        outputCube += "v" + element + " ";
     912                                    CubeAttack_LogMessage(outputCube + " is new maxterm", NotificationLevel.Info);
     913                                    outputCube = string.Empty;
     914                                }
    852915                                superpoly = ComputeSuperpoly(new int[settings.PublicVar], maxterm);
    853916                                bool flag = false;
     
    873936                                    for (int i = 0; i < maxterm.Count - 1; i++)
    874937                                        outputCube += maxterm[i] + ",";
    875                                     outputCube += maxterm[maxterm.Count - 1] + "}";
     938                                    outputCube += maxterm[maxterm.Count - 1] + "}   Output Bit: " + indexOutputBit;
    876939                                }
    877940                                else
    878                                     outputCube += " }";
    879 
    880                                 // Output Bit Index if Trivium is Black Box
    881                                 if (settings.BlackBox == 1)
    882                                     outputCube += "   Trivium Output Bit Index: " + indexOutputBit;
    883 
    884                                 CubeAttack_LogMessage(outputCube, NotificationLevel.Info);
     941                                    outputCube += " }   Output Bit: " + indexOutputBit;
     942
     943                                if (settings.EnableLogMessages)
     944                                    CubeAttack_LogMessage(outputCube, NotificationLevel.Info);
    885945                                break;
    886946                            }
     
    922982        /// <param name="superpolyMatrix">An n x n matrix which contains the superpolys.</param>
    923983        /// <param name="listCubeIndexes">A list of lists of cube indexes.</param>
    924         public void OnlinePhase(Matrix superpolyMatrix, List<List<int>> listCubeIndexes)
    925         {
     984        public void OnlinePhase()
     985        {   
     986            if (settings.ReadSuperpolysFromFile)
     987            {
     988                if (File.Exists(settings.OpenFilename))
     989                {
     990                    superpolyMatrix = new Matrix(settings.SecretVar, settings.SecretVar + 1);
     991                    listCubeIndexes = new List<List<int>>();
     992                    outputBitIndex = new int[settings.SecretVar];
     993
     994                    int i = 0;
     995                    foreach (string sLine in File.ReadAllLines(settings.OpenFilename))
     996                    {
     997                        string[] allValues = sLine.Split(' ');
     998                        string[] variables = allValues[0].Split('+');
     999                        string[] cubeIndex = allValues[1].Split(',');
     1000
     1001                        List<string> variablesList = new List<string>(variables); // Copy to List
     1002
     1003                        for (int j = 0; j < variablesList.Count; j++)
     1004                            if (variablesList[j].Substring(0, 1) == "1")
     1005                            {
     1006                                superpolyMatrix[i, 0] = 1;
     1007                                variablesList.Remove(variablesList[j]);
     1008                            }
     1009
     1010                        for (int j = 0; j < variablesList.Count; j++)
     1011                            if (variablesList[j].Substring(0, 1) == "x")
     1012                                variablesList[j] = variablesList[j].Substring(1);
     1013
     1014                        List<int> superpoly = new List<int>();
     1015                        for (int j = 0; j < variablesList.Count; j++)
     1016                            superpoly.Add(Convert.ToInt32(variablesList[j]));
     1017                        for (int j = 0; j < superpoly.Count; j++)
     1018                            superpolyMatrix[i, superpoly[j] + 1] = 1;
     1019
     1020                        List<int> maxterm = new List<int>();
     1021                        foreach (string cube in cubeIndex)
     1022                            maxterm.Add(Convert.ToInt32(cube));
     1023                        listCubeIndexes.Add(maxterm);
     1024
     1025                        outputBitIndex[i] = Convert.ToInt32(allValues[2]);
     1026                        i++;
     1027                    }
     1028                }
     1029                else
     1030                {
     1031                    CubeAttack_LogMessage("Please input a File", NotificationLevel.Error);
     1032                    return;
     1033                }
     1034            }
     1035
    9261036            if (superpolyMatrix == null || listCubeIndexes == null)
    9271037                CubeAttack_LogMessage("Preprocessing phase has to be executed first", NotificationLevel.Error);
     
    9821092                        try
    9831093                        {
    984                             switch(settings.BlackBox)
     1094                            //switch(settings.BlackBox)
    9851095                            {
    986                                 case 0:
     1096                                //case 0:
    9871097                                    // Online phase BooleanFunctionParser
    988                                     bool[] vBool = new bool[pubVarElement.Length];
    989                                     for (int l = 0; l < pubVarElement.Length; l++)
    990                                         vBool[l] = Convert.ToBoolean(pubVarElement[l]);
    991                                     b[i] ^= ParserOutput.SolveFunction(vBool, null);
    992                                     break;
    993                                 case 1:
     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:
    9941104                                    // Online phase Trivium
    995                                     b[i] ^= TriviumOutput.GenerateTriviumKeystream(pubVarElement, null, outputBitIndex[i], false);
    996                                     break;
     1105                                b[i] ^= CubeattackBlackbox.GenerateBlackboxOutputBit(pubVarElement, null, outputBitIndex[i]);
     1106                                //break;
    9971107                            }
    9981108                        }
     
    10051115                        pubVarElement[j] = 0;
    10061116
    1007                     outputSuperpoly += output.Append(" = " + b[i] + "\n").ToString();
     1117                    output.Append(" = " + b[i] + "   Cube Indexes: {");
     1118                    listCubeIndexes[i].Sort();
     1119                    for (int j = 0; j < listCubeIndexes[i].Count - 1; j++)
     1120                        output.Append(listCubeIndexes[i][j] + ",");
     1121                    output.Append(listCubeIndexes[i][listCubeIndexes[i].Count - 1] + "}   Output Bit: " + outputBitIndex[i] + "\n");
     1122                    outputSuperpoly += output.ToString();
     1123
    10081124                    OnPropertyChanged("OutputSuperpoly");
    10091125                    ProgressChanged((double)i / (double)listCubeIndexes.Count, 1.0);
     
    10931209                    {
    10941210                        StringBuilder output = new StringBuilder(string.Empty);
    1095                         output.Append("Black box output bit: " + Blackbox(pubVarGlob, new int[settings.SecretVar]));
     1211                        output.Append("Output bit: " + Blackbox(pubVarGlob, new int[settings.SecretVar]));
    10961212                        outputSuperpoly += output.ToString();
    10971213                        OnPropertyChanged("OutputSuperpoly");
    1098                         CubeAttack_LogMessage("Black box output bit: " + Blackbox(pubVarGlob, new int[settings.SecretVar]), NotificationLevel.Info);
     1214                        CubeAttack_LogMessage("Output bit: " + Blackbox(pubVarGlob, new int[settings.SecretVar]), NotificationLevel.Info);
    10991215                    }
    11001216                }
     
    11211237                    break;
    11221238                case CubeAttackMode.online:
    1123                     OnlinePhase(superpolyMatrix, listCubeIndexes);
     1239                    OnlinePhase();
    11241240                    break;
    11251241                case CubeAttackMode.setPublicBits:
     
    11421258        #region IControlEncryption Members
    11431259
    1144         private IControlSolveFunction parserOutput;
     1260        /*private IControlSolveFunction parserOutput;
    11451261        [PropertyInfo(Direction.ControlMaster, "Master for BFP", "Master for BFP (SolveFunction)", "", DisplayLevel.Beginner)]
    11461262        public IControlSolveFunction ParserOutput
     
    11641280                    triviumOutput = value;
    11651281            }
     1282        }*/
     1283
     1284        private IControlCubeAttack cubeattackBlackbox;
     1285        [PropertyInfo(Direction.ControlMaster, "Master for CubeAttack", "Master for CubeAttack", "", DisplayLevel.Beginner)]
     1286        public IControlCubeAttack CubeattackBlackbox
     1287        {
     1288            get { return cubeattackBlackbox; }
     1289            set
     1290            {
     1291                if (value != null)
     1292                    cubeattackBlackbox = value;
     1293            }
    11661294        }
    11671295
  • trunk/CrypPlugins/CubeAttack/CubeAttack.csproj

    r735 r832  
    5252    <Reference Include="System.Data" />
    5353    <Reference Include="System.Xml" />
    54     <Reference Include="TriviumController, Version=1.0.0.0, Culture=neutral, PublicKeyToken=d4526fd6dc4c2912, processorArchitecture=MSIL">
    55       <SpecificVersion>False</SpecificVersion>
    56       <HintPath>..\TriviumController\bin\Debug\TriviumController.dll</HintPath>
    57     </Reference>
    5854    <Reference Include="WindowsBase">
    5955      <RequiredTargetFramework>3.0</RequiredTargetFramework>
     
    7571      <Name>CrypPluginBase</Name>
    7672    </ProjectReference>
    77     <ProjectReference Include="..\BooleanFunctionParserController\BooleanFunctionParserController.csproj">
    78       <Project>{273EA298-0198-4CA5-B10A-D85FE6FE5499}</Project>
    79       <Name>BooleanFunctionParserController</Name>
     73    <ProjectReference Include="..\CubeAttackController\CubeAttackController.csproj">
     74      <Project>{2100AC2F-3F2B-48A2-AF42-87EC52C8A703}</Project>
     75      <Name>CubeAttackController</Name>
    8076    </ProjectReference>
    8177  </ItemGroup>
  • trunk/CrypPlugins/CubeAttack/CubeAttackSettings.cs

    r748 r832  
    5151        private string setPublicBits = "0*00*";
    5252        private int outputBit;
    53        
     53        private bool readSuperpolysFromFile;
     54        private string openFilename;
     55        private bool enableLogMessages = false;
     56
     57        private string saveOutputSuperpoly;
     58        private Matrix saveSuperpolyMatrix;
     59        private List<List<int>> saveListCubeIndexes;
     60        private int[] saveOutputBitIndex;
     61        private int saveCountSuperpoly;
     62        private Matrix saveMatrixCheckLinearitySuperpolys;
     63
    5464        #endregion
    5565
     
    5767        #region Algorithm settings properties (visible in the settings pane)
    5868
    59         [PropertySaveOrder(1)]
     69        /*[PropertySaveOrder(1)]
    6070        [ContextMenu("Black Box",
    6171            "Select the black box",
     
    8393                OnPropertyChanged("BlackBox");
    8494            }
    85         }
     95        }*/
    8696
    8797        [PropertySaveOrder(2)]
     
    163173            null,
    164174            5,
    165             false,
     175            true,
    166176            DisplayLevel.Beginner,
    167177            ControlType.NumericUpDown,
     
    225235
    226236        [PropertySaveOrder(8)]
    227         [TaskPane("Manual Public Bit Input",
    228             "Possible inputs '0' (set bit to value 0), '1' (set bit to value 1) and '*' (sum the 0/1 value of the bit).",
    229             null,
    230             8,
    231             false,
    232             DisplayLevel.Beginner,
    233             ControlType.TextBox,
    234             null)]
    235         public string SetPublicBits
    236         {
    237             get
    238             {
    239                 if (setPublicBits != null)
    240                     return setPublicBits;
    241                 else
    242                     return "";
    243             }
    244             set
    245             {
    246                 if (value != this.setPublicBits) HasChanges = true;
    247                 setPublicBits = value;
    248                 OnPropertyChanged("SetPublicBits");
    249             }
    250         }
    251 
    252         [PropertySaveOrder(9)]
    253237        [TaskPane("Output Bit",
    254238            "Chooses the output bit of the black box, which should be evaluated.",
    255239            null,
    256             9,
     240            8,
    257241            true,
    258242            DisplayLevel.Beginner,
     
    272256        }
    273257
     258        [PropertySaveOrder(9)]
     259        [TaskPane("Manual Public Bit Input",
     260            "Possible inputs '0' (set bit to value 0), '1' (set bit to value 1) and '*' (sum the 0/1 value of the bit).",
     261            null,
     262            9,
     263            false,
     264            DisplayLevel.Beginner,
     265            ControlType.TextBox,
     266            null)]
     267        public string SetPublicBits
     268        {
     269            get
     270            {
     271                if (setPublicBits != null)
     272                    return setPublicBits;
     273                else
     274                    return "";
     275            }
     276            set
     277            {
     278                if (value != this.setPublicBits) HasChanges = true;
     279                setPublicBits = value;
     280                OnPropertyChanged("SetPublicBits");
     281            }
     282        }
     283
     284        [PropertySaveOrder(10)]
     285        [ContextMenu("Read superpolys from File",
     286            "With this checkbox enabled, superpolys will be loaded from the selected File and can be evaluated in the online phase.",
     287            10,
     288            DisplayLevel.Experienced,
     289            ContextMenuControlType.CheckBox,
     290            null,
     291            new string[] { "Read superpolys from File" })]
     292        [TaskPane("Read superpolys from File",
     293            "With this checkbox enabled, superpolys will be loaded from the selected File and can be evaluated in the online phase.",
     294            null,
     295            10,
     296            false,
     297            DisplayLevel.Beginner,
     298            ControlType.CheckBox,
     299            "",
     300            null)]
     301        public bool ReadSuperpolysFromFile
     302        {
     303            get { return this.readSuperpolysFromFile; }
     304            set
     305            {
     306                this.readSuperpolysFromFile = (bool)value;
     307                OnPropertyChanged("ReadSuperpolysFromFile");
     308                HasChanges = true;
     309            }
     310        }
     311
     312        [PropertySaveOrder(11)]
     313        [TaskPane("Filename", "Select the file you want to open.",
     314            null,
     315            11,
     316            false,
     317            DisplayLevel.Beginner,
     318            ControlType.OpenFileDialog,
     319            FileExtension = "All Files (*.*)|*.*")]
     320        public string OpenFilename
     321        {
     322            get { return openFilename; }
     323            set
     324            {
     325                if (value != openFilename)
     326                {
     327                    openFilename = value;
     328                    HasChanges = true;
     329                    OnPropertyChanged("OpenFilename");
     330                }
     331            }
     332        }
     333
     334        [PropertySaveOrder(12)]
     335        [ContextMenu("Enable log messages",
     336            "With this checkbox enabled, log messages will be showed.",
     337            12,
     338            DisplayLevel.Experienced,
     339            ContextMenuControlType.CheckBox,
     340            null,
     341            new string[] { "Enable log messages?" })]
     342        [TaskPane("Enable log messages",
     343            "With this checkbox enabled, a lot of log messages will be showed during preprocessing.",
     344            null,
     345            12,
     346            false,
     347            DisplayLevel.Beginner,
     348            ControlType.CheckBox,
     349            "",
     350            null)]
     351        public bool EnableLogMessages
     352        {
     353            get { return this.enableLogMessages; }
     354            set
     355            {
     356                this.enableLogMessages = (bool)value;
     357                OnPropertyChanged("EnableLogMessages");
     358                HasChanges = true;
     359            }
     360        }
     361
     362        public string SaveOutputSuperpoly
     363        {
     364            get { return saveOutputSuperpoly; }
     365            set
     366            {
     367                if (value != saveOutputSuperpoly) hasChanges = true;
     368                saveOutputSuperpoly = value;
     369            }
     370        }
     371
     372        public Matrix SaveSuperpolyMatrix
     373        {
     374            get { return saveSuperpolyMatrix; }
     375            set
     376            {
     377                if (value != saveSuperpolyMatrix) hasChanges = true;
     378                saveSuperpolyMatrix = value;
     379            }
     380        }
     381
     382        public List<List<int>> SaveListCubeIndexes
     383        {
     384            get { return saveListCubeIndexes; }
     385            set
     386            {
     387                if (value != saveListCubeIndexes) hasChanges = true;
     388                saveListCubeIndexes = value;
     389            }
     390        }
     391
     392        public int[] SaveOutputBitIndex
     393        {
     394            get { return saveOutputBitIndex; }
     395            set
     396            {
     397                if (value != saveOutputBitIndex) hasChanges = true;
     398                saveOutputBitIndex = value;
     399            }
     400        }
     401
     402        public int SaveCountSuperpoly
     403        {
     404            get { return saveCountSuperpoly; }
     405            set
     406            {
     407                if (value != saveCountSuperpoly) hasChanges = true;
     408                saveCountSuperpoly = value;
     409            }
     410        }
     411
     412        public Matrix SaveMatrixCheckLinearitySuperpolys
     413        {
     414            get { return saveMatrixCheckLinearitySuperpolys; }
     415            set
     416            {
     417                if (value != saveMatrixCheckLinearitySuperpolys) hasChanges = true;
     418                saveMatrixCheckLinearitySuperpolys = value;
     419            }
     420        }
     421
    274422        #endregion
    275423
  • trunk/CrypPlugins/LFSR/LFSR.cs

    r689 r832  
    4949        public bool stop = false;
    5050        public bool newSeed = true;
    51         public String seedbuffer = "0";
     51        public String seedbuffer = null;
    5252        public String tapSequencebuffer = "1";
    5353        public Char outputbuffer = '0';
     
    8181        {
    8282            if (e.PropertyName == "InitLFSR")
    83                 preprocessingLFSR();           
     83                preprocessingLFSR();
     84            if (e.PropertyName == "SaveCurrentState")
     85            {
     86                if (settings.SaveCurrentState)
     87                    settings.CurrentState = seedbuffer;
     88                else
     89                    settings.CurrentState = null;
     90            }
    8491        }
    8592
     
    442449
    443450            //read seed
    444             if (settings.Seed == null || (settings.Seed != null && settings.Seed.Length == 0))
     451            if (settings.CurrentState != null && settings.CurrentState.Length != 0)
     452                seedbuffer = settings.CurrentState;
     453            else if (settings.Seed == null || (settings.Seed != null && settings.Seed.Length == 0))
    445454                seedbuffer = inputSeed;
    446455            else
     
    851860        public void PostExecution()
    852861        {
     862            if (settings.SaveCurrentState)
     863                settings.CurrentState = seedbuffer;
     864            else
     865                settings.CurrentState = null;
    853866            Dispose();
    854867        }
  • trunk/CrypPlugins/LFSR/LFSRSettings.cs

    r752 r832  
    2323        #region ISettings Members
    2424
     25        private string currentState = null;
     26        public string CurrentState
     27        {
     28            get { return currentState; }
     29            set
     30            {
     31                if (value != currentState) hasChanges = true;
     32                currentState = value;
     33            }
     34        }
     35
    2536        private bool hasChanges = false;
    2637
     
    8091            {
    8192                this.noQuickwatch = (bool)value;
    82                 OnPropertyChanged("NoQuickwatch");
     93                //OnPropertyChanged("NoQuickwatch");
     94                HasChanges = true;
     95            }
     96        }
     97
     98        private bool saveCurrentState = false;
     99        [ContextMenu("Save the state of the LFSR", "With this checkbox enabled, the current state will be restored after opening a .cte.", 0, DisplayLevel.Experienced, ContextMenuControlType.CheckBox, null, new string[] { "Save current state?" })]
     100        [TaskPane("Save the state of the LFSR", "With this checkbox enabled, the current state will be restored after opening a .cte.", null, 3, true, DisplayLevel.Experienced, ControlType.CheckBox, "", null)]
     101        public bool SaveCurrentState
     102        {
     103            get { return this.saveCurrentState; }
     104            set
     105            {
     106                this.saveCurrentState = (bool)value;
     107                OnPropertyChanged("SaveCurrentState");
    83108                HasChanges = true;
    84109            }
  • trunk/CrypPlugins/Trivium/Trivium.cs

    r752 r832  
    1414// for IControl
    1515using Cryptool.PluginBase.Control;
    16 // reference to the TriviumController interface (own dll)
    17 using Cryptool.TriviumController;
     16// reference to the CubeAttackController interface (own dll)
     17using Cryptool.CubeAttackController;
    1818
    1919namespace Cryptool.Trivium
    2020{
    21     [Author("Soeren Rinne, David Oruba & Daehyun Strobel", "soeren.rinne@cryptool.de", "Ruhr-Universitaet Bochum, Chair for Embedded Security (EmSec)", "http://www.trust.ruhr-uni-bochum.de/")]
     21    [Author("Soeren Rinne, David Oruba & Daehyun Strobel", "soeren.rinne@cryptool.org", "Ruhr-Universitaet Bochum, Chair for Embedded Security (EmSec)", "http://www.trust.ruhr-uni-bochum.de/")]
    2222    [PluginInfo(false, "Trivium", "Trivium", "Trivium/DetailedDescription/Description.xaml", "Trivium/icon.png", "Trivium/Images/encrypt.png", "Trivium/Images/decrypt.png")]
    2323    [EncryptionType(EncryptionType.SymmetricBlock)]
     
    678678        #region IControl
    679679
    680         private IControlTrivium triviumSlave;
     680        private IControlCubeAttack triviumSlave;
    681681        [PropertyInfo(Direction.ControlSlave, "Trivium Slave", "Direct access to Trivium.", "", DisplayLevel.Beginner)]
    682         public IControlTrivium TriviumSlave
     682        public IControlCubeAttack TriviumSlave
    683683        {
    684684            get
    685685            {
    686686                if (triviumSlave == null)
    687                     triviumSlave = new TriviumControl(this);
     687                    triviumSlave = new CubeAttackControl(this);
    688688                return triviumSlave;
    689689            }
     
    693693    }
    694694
    695     #region TriviumControl : IControlTrivium
    696 
    697     public class TriviumControl : IControlTrivium
     695    #region TriviumControl : IControlCubeAttack
     696
     697    public class CubeAttackControl : IControlCubeAttack
    698698    {
    699699        public event IControlStatusChangedEventHandler OnStatusChanged;
     
    701701        private TriviumSettings pluginSettings;
    702702
    703         public TriviumControl(Trivium Plugin)
     703        public CubeAttackControl(Trivium Plugin)
    704704        {
    705705            this.plugin = Plugin;
    706706        }
    707707
    708         public TriviumControl(TriviumSettings PluginSettings)
     708        public CubeAttackControl(TriviumSettings PluginSettings)
    709709        {
    710710            this.pluginSettings = PluginSettings;
     
    714714
    715715        // here comes the slave side implementation
    716         public int GenerateTriviumKeystream(int[] IV, int[] key, int length, bool byteSwapping)
     716        /*public int GenerateTriviumKeystream(int[] IV, int[] key, int length, bool byteSwapping)
    717717        {
    718718            string resultString;
     
    732732
    733733            resultString = plugin.keystreamTrivium(length);
     734
     735            return resultInt = Int32.Parse(resultString.Substring(resultString.Length - 1, 1));
     736        }
     737        */
     738
     739        // here comes the slave side implementation
     740        public int GenerateBlackboxOutputBit(object IV, object key, object length)
     741        {
     742            string resultString;
     743            int resultInt;
     744
     745            // convert from object
     746            int[] triviumIV = IV as int[];
     747            int[] triviumKey = key as int[];
     748            int triviumLength = (int)length;
     749
     750            if (triviumKey == null)
     751            {
     752                triviumKey = new int[((TriviumSettings)plugin.Settings).InputKey.Length * 4];
     753                triviumKey = plugin.hextobin(((TriviumSettings)plugin.Settings).InputKey.ToCharArray());
     754                // key = new int[] { 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1 };
     755            }
     756
     757            //plugin.masterSlaveRounds = rounds;
     758            plugin.masterSlaveRounds = ((TriviumSettings)plugin.Settings).InitRounds;
     759            plugin.initTrivium(triviumIV, triviumKey);
     760
     761            resultString = plugin.keystreamTrivium(triviumLength);
    734762
    735763            return resultInt = Int32.Parse(resultString.Substring(resultString.Length - 1, 1));
  • trunk/CrypPlugins/Trivium/Trivium.csproj

    r585 r832  
    7272      <Name>CrypPluginBase</Name>
    7373    </ProjectReference>
    74     <ProjectReference Include="..\TriviumController\TriviumController.csproj">
    75       <Project>{3858B6BC-2680-491F-9022-498A8AC80D7B}</Project>
    76       <Name>TriviumController</Name>
     74    <ProjectReference Include="..\CubeAttackController\CubeAttackController.csproj">
     75      <Project>{2100AC2F-3F2B-48A2-AF42-87EC52C8A703}</Project>
     76      <Name>CubeAttackController</Name>
    7777    </ProjectReference>
    7878  </ItemGroup>
Note: See TracChangeset for help on using the changeset viewer.