Ignore:
Timestamp:
Oct 14, 2009, 12:32:41 PM (12 years ago)
Author:
oruba
Message:
  • improved preprocessing and online modus
  • output bit index is now changeable while executing
Location:
trunk/CrypPlugins/CubeAttack
Files:
4 edited

Legend:

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

    r617 r724  
    3232
    3333        private CubeAttackSettings settings;
    34         private string outputMaxterm;
     34        private string outputSuperpoly;
    3535        private string outputKeyBits;
    36         private enum CubeAttackMode { preprocessing, setPublicBits };
     36        private enum CubeAttackMode { preprocessing, online, setPublicBits };
    3737        private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    3838        private bool stop = false;
     39
     40        #endregion
     41
     42
     43        #region Public variables
     44
     45        public Matrix superpolyMatrix = null;
     46        public List<List<int>> listCubeIndexes = null;
     47        public int[] pubVarGlob = null;
     48        public int indexOutputBit;
     49        public int[] outputBitIndex;
    3950
    4051        #endregion
     
    4455       
    4556        [PropertyInfo(Direction.OutputData,
    46             "Maxterm output",
    47             "Outputs the located maxterms.",
     57            "Output of superpolys",
     58            "Output the located linearly independent superpolys, cube indexes and its corresponding output bits.",
    4859            "",
    4960            false,
     
    5263            QuickWatchFormat.Text,
    5364            null)]
    54         public CryptoolStream OutputMaxterm
     65        public CryptoolStream OutputSuperpoly
    5566        {
    5667            get
    5768            {
    58                 if (outputMaxterm != null)
     69                if (outputSuperpoly != null)
    5970                {
    6071                    CryptoolStream cs = new CryptoolStream();
    6172                    listCryptoolStreamsOut.Add(cs);
    62                     cs.OpenRead(Encoding.Default.GetBytes(outputMaxterm.ToCharArray()));
     73                    cs.OpenRead(Encoding.Default.GetBytes(outputSuperpoly.ToCharArray()));
    6374                    return cs;
    6475                }
     
    7384        [PropertyInfo(Direction.OutputData,
    7485            "Key bits",
    75             "This output provides the result of the secret key",
     86            "This output provides the result of the secret key bits",
    7687            "",
    7788            false,
     
    130141        }
    131142
     143        public void Online()
     144        {
     145            ProcessCubeAttack(CubeAttackMode.online);
     146        }
     147
    132148        /// <summary>
    133149        /// Manual input of public bits
     
    150166        {
    151167            stop = false;
    152             //this.stop = false;
    153168            foreach (CryptoolStream stream in listCryptoolStreamsOut)
    154169            {
     
    215230        {
    216231            if (settings.MaxCube > settings.PublicVar)
    217                 CubeAttack_LogMessage("Error: Max cube size cannot be greater than Public bit size.", NotificationLevel.Error);
     232                CubeAttack_LogMessage("Error: Max Cube Size cannot be greater than Public Bit Size.", NotificationLevel.Error);
    218233            else
    219234            {
     
    226241                            break;
    227242                        case 1:
     243                            Online();
     244                            break;
     245                        case 2:
    228246                            SetPublicBits();
    229247                            break;
     
    249267        public int Blackbox(int[] v, int[] x)
    250268        {
     269            /*// Begin Trivium
     270            // Initialisierung
     271                int[] a = new int[93];
     272                int[] b = new int[84];
     273            int[] c = new int[111];
     274            int t1, t2, t3;
     275            int i,j;
     276                for (i = 0; i < 80; i++)
     277            {
     278                a[i] = x[i];
     279                b[i] = v[i];
     280                        c[i] = 0;
     281                }
     282                while (i < 84){
     283                        a[i] = 0;
     284                        b[i] = 0;
     285                        c[i] = 0;
     286                        i++;
     287                }
     288                while (i < 93){
     289                        a[i] = 0;
     290                        c[i] = 0;
     291                        i++;
     292                }
     293                while (i < 108){
     294                        c[i] = 0;
     295                        i++;
     296                }
     297                while (i < 111){
     298                        c[i] = 1;
     299                        i++;
     300                }
     301
     302                for (i = 0; i < 672; i++)
     303            {
     304                        t1 = a[65] ^ a[92];
     305                        t2 = b[68] ^ b[83];
     306                        t3 = c[65] ^ c[110];
     307                        t1 = t1 ^ (a[90] & a[91]) ^ b[77];
     308                        t2 = t2 ^ (b[81] & b[82]) ^ c[86];
     309                        t3 = t3 ^ (c[108] & c[109]) ^ a[68];
     310                        for (j = 92; j > 0; j--)
     311                                a[j] = a[j-1];
     312                        for (j = 83; j > 0; j--)
     313                                b[j] = b[j-1];
     314                        for (j = 110; j > 0; j--)
     315                                c[j] = c[j-1];
     316                        a[0] = t3;
     317                        b[0] = t1;
     318                        c[0] = t2;
     319                }
     320
     321            // Keystream
     322            List<int> keyOutput = new List<int>();
     323                for (i = 0; i < 4; i++)
     324            {
     325                        t1 = a[65] ^ a[92];
     326                        t2 = b[68] ^ b[83];
     327                        t3 = c[65] ^ c[110];
     328                keyOutput.Add(t1 ^ t2 ^ t3);
     329                        t1 = t1 ^ (a[90] & a[91]) ^ b[77];
     330                        t2 = t2 ^ (b[81] & b[82]) ^ c[86];
     331                        t3 = t3 ^ (c[108] & c[109]) ^ a[68];
     332                        for (j = 92; j > 0; j--)
     333                                a[j] = a[j-1];
     334                        for (j = 83; j > 0; j--)
     335                                b[j] = b[j-1];
     336                        for (j = 110; j > 0; j--)
     337                                c[j] = c[j-1];
     338                        a[0] = t3;
     339                        b[0] = t1;
     340                        c[0] = t2;
     341                }
     342            return keyOutput[3];
     343            // End Trivium */
     344
    251345            int result = 0;
    252346           
     
    278372                        else
    279373                        {
    280                             result = TriviumOutput.GenerateTriviumKeystream(v, x, settings.TriviumOutputBit, settings.TriviumRounds, false);
     374                            result = TriviumOutput.GenerateTriviumKeystream(v, x, indexOutputBit, settings.TriviumRounds, false);
    281375                            break;
    282376                        }
     
    288382                CubeAttack_LogMessage("Error: " + ex, NotificationLevel.Error);
    289383            }
    290             return result;
     384            return result; 
    291385        }
    292386
     
    297391        /// <param name="cube">The summation cube I.</param>
    298392        /// <returns>Returns the superpoly of I in p.</returns>
    299         public List<int> ComputePSI(List<int> cube)
     393        public List<int> ComputeSuperpoly(int[] pubVarElement, List<int> maxterm)
    300394        {
    301395            int constant = 0;
    302396            int coeff = 0;
    303397            List<int> superpoly = new List<int>();
    304             int[] pubVarElement = new int[settings.PublicVar];
    305398            int[] secVarElement = new int[settings.SecretVar];
    306399
    307             CubeAttack_LogMessage("Start deriving the algebraic structure of the superpoly, compute " + settings.SecretVar + " coefficients and the value of the constant term", NotificationLevel.Info);
     400            CubeAttack_LogMessage("Start deriving the algebraic structure of the superpoly", NotificationLevel.Info);
    308401
    309402            // Compute the free term
    310             for (ulong i = 0; i < Math.Pow(2, cube.Count); i++)
     403            for (ulong i = 0; i < Math.Pow(2, maxterm.Count); i++)
    311404            {
    312405                if (stop)
    313406                    return superpoly;
    314407
    315                 for (int j = 0; j < cube.Count; j++)
    316                     pubVarElement[cube[j]] = (i & ((ulong)1 << j)) > 0 ? 1 : 0;
     408                for (int j = 0; j < maxterm.Count; j++)
     409                    pubVarElement[maxterm[j]] = (i & ((ulong)1 << j)) > 0 ? 1 : 0;
    317410                constant ^= Blackbox((int[])pubVarElement.Clone(), (int[])secVarElement.Clone());
    318411            }
     
    323416            for (int k = 0; k < settings.SecretVar; k++)
    324417            {
    325                 for (ulong i = 0; i < Math.Pow(2, cube.Count); i++)
     418                for (ulong i = 0; i < Math.Pow(2, maxterm.Count); i++)
    326419                {
    327420                    if (stop)
     
    329422
    330423                    secVarElement[k] = 1;
    331                     for (int j = 0; j < cube.Count; j++)
    332                         pubVarElement[cube[j]] = (i & ((ulong)1 << j)) > 0 ? 1 : 0;
     424                    for (int j = 0; j < maxterm.Count; j++)
     425                        pubVarElement[maxterm[j]] = (i & ((ulong)1 << j)) > 0 ? 1 : 0;
    333426                    coeff ^= Blackbox((int[])pubVarElement.Clone(), (int[])secVarElement.Clone());
    334427                }
     
    342435
    343436        /// <summary>
    344         /// The function outputs a superpoly and its corresponding maxterm.
    345         /// </summary>
    346         /// <param name="cube">The summation Cube I.</param>
    347         /// <param name="superpoly">The superpoly of I in p.</param>
    348         public void OutputMaxterms(List<int> cube, List<int> superpoly)
     437        /// The function outputs a the superpolys, cube indexes and output bits.
     438        /// </summary>
     439        /// <param name="cubeIndexes">The cube indexes of the maxterm.</param>
     440        /// <param name="superpoly">The superpoly for the given cube indexes.</param>
     441        public void OutputSuperpolys(List<int> cubeIndexes, List<int> superpoly)
    349442        {
    350443            StringBuilder output = new StringBuilder(string.Empty);
    351444            bool superpolyIsEmpty = true;
    352445            bool flag = false;
    353             output.Append("Maxterm Equation: ");
     446            output.Append("Superpoly: ");
    354447            if (superpoly[0] == 1)
    355448            {
     
    371464                output.Append("0");
    372465            output.Append("   Cube Indexes: {");
    373             if (cube.Count > 0)
    374             {
    375                 cube.Sort();
    376                 for (int i = 0; i < cube.Count - 1; i++)
    377                     output.Append(cube[i] + ",");
    378                 output.AppendLine(cube[cube.Count - 1] + "}");
     466            if (cubeIndexes.Count > 0)
     467            {
     468                cubeIndexes.Sort();
     469                for (int i = 0; i < cubeIndexes.Count - 1; i++)
     470                    output.Append(cubeIndexes[i] + ",");
     471                output.Append(cubeIndexes[cubeIndexes.Count - 1] + "}");
    379472            }
    380473            else
    381                 output.Append(" }\n");
    382             outputMaxterm += output.ToString();
    383             OnPropertyChanged("OutputMaxterm");
     474                output.Append(" }");
     475
     476            // Output Bit Index if Trivium is Black Box
     477            if (settings.BlackBox == 1)
     478                output.Append("   Trivium Output Bit Index: " + (indexOutputBit + settings.TriviumRounds - 1) + "\n");
     479            else
     480                output.Append("\n");
     481
     482            outputSuperpoly += output.ToString();
     483            OnPropertyChanged("OutputSuperpoly");
    384484        }
    385485
     
    387487        /// The function outputs the key bits.
    388488        /// </summary>
    389         /// <param name="res">Result Vector</param>
     489        /// <param name="res">Result vector</param>
    390490        public void OutputKey(Vector res)
    391491        {
     
    418518
    419519        /// <summary>
    420         /// Test if cube is already known.
    421         /// </summary>
    422         /// <param name="mCube">A list of cubes.</param>
    423         /// <param name="cube">The summation cube I.</param>
    424         /// <returns>A boolean value indicating if the cube is in the list of cubes or not.</returns>
    425         public bool CubeKnown(List<List<int>> mCube, List<int> cube)
     520        /// Test if a maxterm is already known.
     521        /// </summary>
     522        /// <param name="cubeList">A list of cube indexes.</param>
     523        /// <param name="maxterm">The located maxterm.</param>
     524        /// <returns>A boolean value indicating if the maxterm is already in the list of cubes indexes or not.</returns>
     525        public bool MaxtermKnown(List<List<int>> cubeList, List<int> maxterm)
    426526        {
    427527            bool isEqual = true;
    428             for (int i = 0; i < mCube.Count; i++)
     528            for (int i = 0; i < cubeList.Count; i++)
    429529            {
    430530                isEqual = true;
    431                 if (mCube[i].Count == cube.Count)
    432                 {
    433                     for (int j = 0; j < cube.Count; j++)
    434                         if (!mCube[i].Contains(cube[j]))
     531                if (cubeList[i].Count == maxterm.Count)
     532                {
     533                    for (int j = 0; j < maxterm.Count; j++)
     534                        if (!cubeList[i].Contains(maxterm[j]))
    435535                            isEqual = false;
    436536                    if (isEqual)
     
    442542
    443543        /// <summary>
    444         /// Test if superpoly is linear (BLR linearity test).
    445         /// </summary>
    446         /// <param name="cube">The summation Cube I.</param>
     544        /// Test if a superpoly is linear (BLR linearity test).
     545        /// </summary>
     546        /// <param name="maxterm">The located maxterm.</param>
    447547        /// <returns>A boolean value indicating if the superpoly is probably linear or not.</returns>
    448         public bool IsLinear(List<int> cube)
     548        public bool IsSuperpolyLinear(int[] pubVarElement, List<int> maxterm)
    449549        {
    450550            Random rnd = new Random();
    451551            int psLeft = 0;
    452552            int psRight = 0;
    453             int[] pubVarElement = new int[settings.PublicVar];
    454553            int[] vectorX = new int[settings.SecretVar];
    455554            int[] vectorY = new int[settings.SecretVar];
     
    473572                    vecXY[i] = (vectorX[i] ^ vectorY[i]);
    474573
    475                 for (ulong i = 0; i < Math.Pow(2, cube.Count); i++)
     574                for (ulong i = 0; i < Math.Pow(2, maxterm.Count); i++)
    476575                {
    477576                    if (stop)
    478577                        return false;
    479578
    480                     for (int j = 0; j < cube.Count; j++)
    481                         pubVarElement[cube[j]] = (i & ((ulong)1 << j)) > 0 ? 1 : 0;
     579                    for (int j = 0; j < maxterm.Count; j++)
     580                        pubVarElement[maxterm[j]] = (i & ((ulong)1 << j)) > 0 ? 1 : 0;
    482581                    psLeft ^= Blackbox((int[])pubVarElement.Clone(), new int[settings.SecretVar])
    483582                            ^ Blackbox((int[])pubVarElement.Clone(), (int[])vectorX.Clone())
     
    500599        /// Test if superpoly is a constant value.
    501600        /// </summary>
    502         /// <param name="cube">The summation Cube I.</param>
     601        /// <param name="maxterm">The located maxterm.</param>
    503602        /// <returns>A boolean value indicating if the superpoly is constant or not.</returns>
    504         public bool IsSuperpolyConstant(List<int> cube)
     603        public bool IsSuperpolyConstant(int[] pubVarElement, List<int> maxterm)
    505604        {
    506605            Random rnd = new Random();
     
    509608            int output = 0;
    510609            int[] secVarElement = new int[settings.SecretVar];
    511             int[] pubVarElement = new int[settings.PublicVar];
    512610
    513611            string outputCube = string.Empty;
    514             foreach (int element in cube)
     612            foreach (int element in maxterm)
    515613                outputCube += "v" + element + " ";
    516             CubeAttack_LogMessage("Test if superpoly of subset " + outputCube + " is constant", NotificationLevel.Info);
    517 
     614            if(settings.ConstTest > 0)
     615                CubeAttack_LogMessage("Test if superpoly of subset " + outputCube + " is constant", NotificationLevel.Info);
    518616            for (int i = 0; i < settings.ConstTest; i++)
    519617            {
    520618                for (int j = 0; j < settings.SecretVar; j++)
    521619                    vectorX[j] = rnd.Next(0, 2);
    522                 for (ulong j = 0; j < Math.Pow(2, cube.Count); j++)
     620                for (ulong j = 0; j < Math.Pow(2, maxterm.Count); j++)
    523621                {
    524622                    if (stop)
    525623                        return false;
    526624
    527                     for (int k = 0; k < cube.Count; k++)
    528                         pubVarElement[cube[k]] = (j & ((ulong)1 << k)) > 0 ? 1 : 0;
     625                    for (int k = 0; k < maxterm.Count; k++)
     626                        pubVarElement[maxterm[k]] = (j & ((ulong)1 << k)) > 0 ? 1 : 0;
    529627                    output ^= Blackbox(pubVarElement, vectorX);
    530628                }
     
    541639                    return false;
    542640            }
    543             return true;
     641            if (settings.ConstTest > 0)
     642                return true;
     643            else
     644                return false;
    544645        }
    545646
     
    548649        /// </summary>
    549650        /// <param name="ilist">A List of values.</param>
    550         public static void Shuffle<T>(List<int> ilist)
     651        public static void Shuffle(List<int> ilist)
    551652        {
    552653            Random rand = new Random();
     
    627728        public void PreprocessingPhase()
    628729        {
    629             CubeAttack_LogMessage("Start preprocessing", NotificationLevel.Info);
    630 
    631             outputMaxterm = string.Empty;
    632             int countMaxterms = 0;
     730            CubeAttack_LogMessage("Start preprocessing, try to find " + settings.SecretVar + " linearly independent superpolys", NotificationLevel.Info);
     731
     732            indexOutputBit = settings.TriviumOutputBit;
     733            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;
    633740            Random rnd = new Random();
    634741            int numberOfVariables = 0;
    635742            List<int> chooseIndexI = new List<int>();
    636             Matrix mSuperpoly = new Matrix(settings.SecretVar, settings.SecretVar + 1);
    637             Matrix mCheckLinearity = new Matrix(0, settings.SecretVar);
     743            Matrix matrixCheckLinearitySuperpolys = new Matrix(0, settings.SecretVar);
    638744            List<int> superpoly = new List<int>();
    639             List<int> cube = new List<int>();
    640             Vector freeTerms = new Vector(settings.SecretVar);
    641             List<List<int>> cubeIndex = new List<List<int>>();
    642             List<List<int>> mCube = new List<List<int>>();
     745            List<int> maxterm = new List<int>();
     746            List<List<int>> cubeList = new List<List<int>>();
    643747
    644748            // Save all public variables indexes in a list
     
    647751
    648752            // Find n maxterms and save their in the matrix
    649             while (countMaxterms < settings.SecretVar)
     753            while (countSuperpoly < settings.SecretVar)
    650754            {
    651755                if (stop)
     
    653757                else
    654758                {
    655                     cube = new List<int>();
     759                    maxterm = new List<int>();
    656760                    superpoly.Clear();
    657761
     
    660764
    661765                    // Permutation of the public variables
    662                     Shuffle<int>(chooseIndexI);
     766                    Shuffle(chooseIndexI);
    663767
    664768                    // Construct cube of size k. Add k public variables to the cube
    665769                    for (int i = 0; i < numberOfVariables; i++)
    666                         cube.Add(chooseIndexI[i]);
     770                        maxterm.Add(chooseIndexI[i]);
    667771
    668772                    string outputCube = string.Empty;
    669                     foreach (int element in cube)
     773                    foreach (int element in maxterm)
    670774                        outputCube += "v" + element + " ";
    671775                    CubeAttack_LogMessage("Start search for maxterm with subterm: " + outputCube, NotificationLevel.Info);
     776                    if (settings.TriviumOutputBit != indexOutputBit)
     777                    {
     778                        // User has changed Output Bit index, store new value
     779                        indexOutputBit = settings.TriviumOutputBit;
     780
     781                        // Reset list of cube indexes, since a single maxterms can be associated with multiple superpolys from different outputs
     782                        cubeList = new List<List<int>>();
     783                    }
    672784                    while (superpoly.Count == 0)
    673785                    {
    674                         if (cube.Count == 0)
     786                        if (maxterm.Count == 0)
    675787                        {
    676788                            if (numberOfVariables < chooseIndexI.Count)
    677789                            {
    678790                                CubeAttack_LogMessage("Subset is empty, add variable v" + chooseIndexI[numberOfVariables], NotificationLevel.Info);
    679                                 cube.Add(chooseIndexI[numberOfVariables]);
     791                                maxterm.Add(chooseIndexI[numberOfVariables]);
    680792                                numberOfVariables++;
    681793                            }
     
    683795                                break;
    684796                        }
    685                         if (CubeKnown(mCube, cube))
     797                        if (MaxtermKnown(cubeList, maxterm))
    686798                        {
    687799                            // Maxterm is already known, break and restart with new subset
    688                             CubeAttack_LogMessage("Maxterm is already known, restart with new subset", NotificationLevel.Info);
     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);
    689804                            break;
    690805                        }
    691806
    692                         if (IsSuperpolyConstant(cube))
     807                        if (IsSuperpolyConstant(new int[settings.PublicVar], maxterm))
    693808                        {
    694809                            if (stop)
     
    696811                            else
    697812                            {
    698                                 CubeAttack_LogMessage("Superpoly is likely constant, drop variable v" + cube[0], NotificationLevel.Info);
    699                                 cube.RemoveAt(0);
     813                                CubeAttack_LogMessage("Superpoly is likely constant, drop variable v" + maxterm[0], NotificationLevel.Info);
     814                                maxterm.RemoveAt(0);
    700815                            }
    701816                        }
    702                         else if (!IsLinear(cube))
     817                        else if (!IsSuperpolyLinear(new int[settings.PublicVar], maxterm))
    703818                        {
    704819                            if (stop)
     
    709824                                if (numberOfVariables < chooseIndexI.Count)
    710825                                {
    711                                     if (cube.Count <= settings.MaxCube)
     826                                    if (maxterm.Count < settings.MaxCube)
    712827                                    {
    713828                                        CubeAttack_LogMessage("Add variable v" + chooseIndexI[numberOfVariables], NotificationLevel.Info);
    714                                         cube.Add(chooseIndexI[numberOfVariables]);
     829                                        maxterm.Add(chooseIndexI[numberOfVariables]);
    715830                                        numberOfVariables++;
    716831                                    }
     832                                    else
     833                                        break;
    717834                                }
    718835                                else
     
    726843                            else
    727844                            {
    728                                 CubeAttack_LogMessage("Superpoly is likely linear", NotificationLevel.Info);
    729                                 mCube.Add(cube);
     845                                //CubeAttack_LogMessage("Superpoly is likely linear", NotificationLevel.Info);
     846                                cubeList.Add(maxterm);
    730847                                outputCube = string.Empty;
    731                                 foreach (int element in cube)
     848                                foreach (int element in maxterm)
    732849                                    outputCube += "v" + element + " ";
    733850                                CubeAttack_LogMessage(outputCube + " is new maxterm", NotificationLevel.Info);
    734                                 superpoly = ComputePSI(cube);
     851                                outputCube = string.Empty;
     852                                superpoly = ComputeSuperpoly(new int[settings.PublicVar], maxterm);
     853                                bool flag = false;
     854                                outputCube += "Superpoly: ";
     855                                if (superpoly[0] == 1)
     856                                {
     857                                    outputCube += "1";
     858                                    flag = true;
     859                                }
     860                                for (int i = 1; i < superpoly.Count; i++)
     861                                    if (superpoly[i] == 1)
     862                                    {
     863                                        if (flag)
     864                                            outputCube += "+x" + Convert.ToString(i - 1);
     865                                        else
     866                                            outputCube += "x" + Convert.ToString(i - 1);
     867                                        flag = true;
     868                                    }
     869                                outputCube += "   Cube Indexes: {";
     870                                if (maxterm.Count > 0)
     871                                {
     872                                    maxterm.Sort();
     873                                    for (int i = 0; i < maxterm.Count - 1; i++)
     874                                        outputCube += maxterm[i] + ",";
     875                                    outputCube += maxterm[maxterm.Count - 1] + "}";
     876                                }
     877                                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 + settings.TriviumRounds - 1);
     883
     884                                CubeAttack_LogMessage(outputCube, NotificationLevel.Info);
    735885                                break;
    736886                            }
     
    738888                    }//End while (superpoly.Count == 0)
    739889
    740                     if (!InMatrix(superpoly, mSuperpoly))
     890                    if (!InMatrix(superpoly, superpolyMatrix))
    741891                    {
    742892                        List<int> superpolyWithoutConstant = new List<int>();
     
    744894                            superpolyWithoutConstant.Add(superpoly[i]);
    745895
    746                         mCheckLinearity = mCheckLinearity.AddRow(superpolyWithoutConstant);
    747                         if (IsLinearIndependent(mCheckLinearity))
     896                        matrixCheckLinearitySuperpolys = matrixCheckLinearitySuperpolys.AddRow(superpolyWithoutConstant);
     897                        if (IsLinearIndependent(matrixCheckLinearitySuperpolys))
    748898                        {
    749899                            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);
     900                                superpolyMatrix[countSuperpoly, j] = superpoly[j];
     901
     902                            listCubeIndexes.Add(maxterm);
     903                            OutputSuperpolys(maxterm, superpoly);
     904                            outputBitIndex[countSuperpoly] = indexOutputBit;
     905                            countSuperpoly++;
     906                            CubeAttack_LogMessage("Found " + countSuperpoly + " of " + settings.SecretVar + " linearly independent superpolys", NotificationLevel.Info);
     907                            ProgressChanged((double)countSuperpoly / (double)settings.SecretVar, 1.0);
    756908                        }
    757909                        else
    758                             mCheckLinearity = mCheckLinearity.DeleteLastRow();
     910                            matrixCheckLinearitySuperpolys = matrixCheckLinearitySuperpolys.DeleteLastRow();
    759911                    }
    760912
    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 
     913                    if (countSuperpoly == settings.SecretVar)
     914                        CubeAttack_LogMessage(settings.SecretVar + " linearly independent superpolys have been found, preprocessing phase completed", NotificationLevel.Info);
     915                }
     916            }//End while (countSuperpoly < settings.SecretVar)
     917        }//End PreprocessingPhase
     918
     919        /// <summary>
     920        /// Online Phase of the cube attack.
     921        /// </summary>
     922        /// <param name="superpolyMatrix">An n x n matrix which contains the superpolys.</param>
     923        /// <param name="listCubeIndexes">A list of lists of cube indexes.</param>
     924        public void OnlinePhase(Matrix superpolyMatrix, List<List<int>> listCubeIndexes)
     925        {
     926            if (superpolyMatrix == null || listCubeIndexes == null)
     927                CubeAttack_LogMessage("Preprocessing phase has to be executed first", NotificationLevel.Error);
     928            else
     929            {
     930                CubeAttack_LogMessage("Start online phase", NotificationLevel.Info);
     931
     932                outputSuperpoly = string.Empty;
     933                int[] pubVarElement = new int[settings.PublicVar];
     934
     935                if (pubVarGlob != null)
     936                {
     937                    for (int i = 0; i < settings.PublicVar; i++)
     938                        pubVarElement[i] = pubVarGlob[i];
     939                }
     940
     941                Vector b = new Vector(settings.SecretVar);
     942                StringBuilder output = new StringBuilder(string.Empty);
     943                bool flag = false;
     944                string logOutput = string.Empty;
     945
     946                for (int i = 0; i < listCubeIndexes.Count; i++)
     947                {
     948                    flag = false;
     949                    logOutput = string.Empty;
     950                    output.Append("Maxterm Equation: ");
     951                    if (superpolyMatrix[i, 0] == 1)
     952                    {
     953                        output.Append("1");
     954                        logOutput += "1";
     955                        flag = true;
     956                    }
     957                    for (int j = 1; j < superpolyMatrix.Cols; j++)
     958                    {
     959                        if (superpolyMatrix[i, j] == 1)
     960                        {
     961                            if (flag)
     962                            {
     963                                output.Append("+x" + Convert.ToString(j - 1));
     964                                logOutput += "+x" + Convert.ToString(j - 1);
     965                            }
     966                            else
     967                            {
     968                                output.Append("x" + Convert.ToString(j - 1));
     969                                logOutput += "x" + Convert.ToString(j - 1);
     970                            }
     971                            flag = true;
     972                        }
     973                    }
     974                    CubeAttack_LogMessage("Compute value of maxterm equation " + logOutput, NotificationLevel.Info);
     975
     976                    for (ulong k = 0; k < Math.Pow(2, listCubeIndexes[i].Count); k++)
     977                    {
     978                        if (stop)
     979                            return;
     980                        for (int l = 0; l < listCubeIndexes[i].Count; l++)
     981                            pubVarElement[listCubeIndexes[i][l]] = (k & ((ulong)1 << l)) > 0 ? 1 : 0;
    768982                        try
    769983                        {
    770                             if (settings.OnlinePhase)
     984                            switch(settings.BlackBox)
    771985                            {
    772                                 CubeAttack_LogMessage("Start online phase", NotificationLevel.Info);
    773                                 CubeAttack_LogMessage("Invert matrix", NotificationLevel.Info);
    774                                 mSuperpoly = mSuperpoly.Inverse();
    775                                 OnlinePhase(mSuperpoly, freeTerms, cubeIndex);
     986                                case 0:
     987                                    // 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(null, vBool, 2);
     992                                    break;
     993                                case 1:
     994                                    // Online phase Trivium
     995                                    b[i] ^= TriviumOutput.GenerateTriviumKeystream(pubVarElement, null, outputBitIndex[i], settings.TriviumRounds, false);
     996                                    break;
    776997                            }
    777998                        }
    778                         catch (Exception exception)
     999                        catch (Exception ex)
    7791000                        {
    780                             GuiLogMessage(exception.Message, NotificationLevel.Error);
     1001                            CubeAttack_LogMessage("Error: " + ex, NotificationLevel.Error);
    7811002                        }
    7821003                    }
    783                 }
    784             }//End while (countMaxterms < settings.SecretVar)
    785         }//End PreprocessingPhase
    786 
    787         /// <summary>
    788         /// Online Phase of the cube attack.
    789         /// </summary>
    790         /// <param name="mSuperpoly">An n x n matrix which contains the superpolys (without the free terms).</param>
    791         /// <param name="b">Vector which contains the corresponding free terms of the superpolys.</param>
    792         /// <param name="cubeIndex">A list of lists of cube indices.</param>
    793         public void OnlinePhase(Matrix mSuperpoly, Vector b, List<List<int>> cubeIndex)
    794         {
    795             int[] pubVarElement = new int[settings.PublicVar];
    796             bool superpolyHasConstantTerm = false;
    797 
    798             for (int i = 0; i < settings.SecretVar; i++)
    799             {
    800                 if (b[i] == 1)
    801                     superpolyHasConstantTerm = true;
    802                 for (int j = 0; j < settings.PublicVar; j++)
    803                     pubVarElement[j] = 0;
    804                 for (ulong k = 0; k < Math.Pow(2, cubeIndex[i].Count); k++)
    805                 {
    806                     if (stop)
    807                         return;
    808 
    809                     for (int l = 0; l < cubeIndex[i].Count; l++)
    810                         pubVarElement[cubeIndex[i][l]] = (k & ((ulong)1 << l)) > 0 ? 1 : 0;
    811                     try
    812                     {
    813                         bool[] vBool = new bool[pubVarElement.Length];
    814 
    815                         for (int l = 0; l < pubVarElement.Length; l++)
    816                             vBool[l] = Convert.ToBoolean(pubVarElement[l]);
    817                         b[i] ^= ParserOutput.SolveFunction(null, vBool, 2);
    818                     }
    819                     catch (Exception ex)
    820                     {
    821                         CubeAttack_LogMessage("Error: " + ex, NotificationLevel.Error);
    822                     }
    823                 }
    824                 if (superpolyHasConstantTerm)
    825                     CubeAttack_LogMessage("Value of maxterm equation " + (i + 1) + " of " + settings.SecretVar + " = " + (b[i] ^ 1), NotificationLevel.Info);
     1004                    for (int j = 0; j < settings.PublicVar; j++)
     1005                        pubVarElement[j] = 0;
     1006
     1007                    outputSuperpoly += output.Append(" = " + b[i] + "\n").ToString();
     1008                    OnPropertyChanged("OutputSuperpoly");
     1009                    ProgressChanged((double)i / (double)listCubeIndexes.Count, 1.0);
     1010                    outputSuperpoly = string.Empty;
     1011                }
     1012
     1013                if (listCubeIndexes.Count == settings.SecretVar)
     1014                {
     1015                    CubeAttack_LogMessage("Solve system of equations", NotificationLevel.Info);
     1016                    for (int i = 0; i < settings.SecretVar; i++)
     1017                        b[i] ^= superpolyMatrix[i, 0];
     1018                    // Delete first column and invert
     1019                    OutputKey(superpolyMatrix.DeleteFirstColumn().Inverse() * b);
     1020                    OnPropertyChanged("OutputKeyBits");
     1021                    CubeAttack_LogMessage("Key bits successfully discovered, online phase completed", NotificationLevel.Info);
     1022                }
    8261023                else
    827                     CubeAttack_LogMessage("Value of maxterm equation " + (i + 1) + " of " + settings.SecretVar + " = " + b[i], NotificationLevel.Info);
    828                 // Reset variable
    829                 superpolyHasConstantTerm = false;
    830             }
    831             OutputKey(mSuperpoly * b);
    832             OnPropertyChanged("OutputKeyBits");
    833         }
    834 
    835         /// <summary>
    836         /// In this mode the user is allowed to set the summation cube manually.
     1024                    CubeAttack_LogMessage("Not enough linearly independent superpolys have been found to discover all secret bits !", NotificationLevel.Info);
     1025            }
     1026        }
     1027
     1028        /// <summary>
     1029        /// User-Mode to set public bit values manually.
    8371030        /// </summary>
    8381031        public void SetPublicBitsPhase()
    8391032        {
    840             outputMaxterm = string.Empty;
     1033            outputSuperpoly = string.Empty;
    8411034            outputKeyBits = string.Empty;
    842             int[] secVari = new int[settings.SecretVar];
    843             int[] pubVari = new int[settings.PublicVar];
    844             List<int> cube = new List<int>();
     1035            superpolyMatrix = new Matrix(settings.SecretVar, settings.SecretVar + 1);
     1036            listCubeIndexes = new List<List<int>>();
     1037            pubVarGlob = new int[settings.PublicVar];
     1038            List<int> maxterm = new List<int>();
    8451039            bool fault = false;
     1040
     1041            if (settings.TriviumOutputBit != indexOutputBit)
     1042                indexOutputBit = settings.TriviumOutputBit;
    8461043
    8471044            if (settings.SetPublicBits.Length != settings.PublicVar)
     
    8541051                    {
    8551052                        case '0':
    856                             pubVari[i] = 0;
     1053                            pubVarGlob[i] = 0;
    8571054                            break;
    8581055                        case '1':
    859                             pubVari[i] = 1;
     1056                            pubVarGlob[i] = 1;
    8601057                            break;
    8611058                        case '*':
    862                             cube.Add(i);
     1059                            maxterm.Add(i);
    8631060                            break;
    8641061                        default:
     
    8711068                else
    8721069                {
    873                     if (cube.Count > 0)
    874                     {
    875                         if (IsLinear(cube))
    876                         {
    877                             List<int> superpoly = ComputePSI(cube);
    878                             if (!stop)
    879                                 OutputMaxterms(cube, superpoly);
    880                         }
     1070                    if (maxterm.Count > 0)
     1071                    {
     1072                        if (!IsSuperpolyConstant(pubVarGlob, maxterm))
     1073                            if (IsSuperpolyLinear(pubVarGlob, maxterm))
     1074                            {
     1075                                List<int> superpoly = ComputeSuperpoly(pubVarGlob, maxterm);
     1076                                if (!stop)
     1077                                {
     1078                                    for (int i = 0; i < superpoly.Count; i++)
     1079                                        superpolyMatrix[0, i] = superpoly[i];
     1080                                    listCubeIndexes.Add(maxterm);
     1081                                    OutputSuperpolys(maxterm, superpoly);
     1082                                }
     1083                            }
     1084                            else
     1085                            {
     1086                                if(!stop)
     1087                                    CubeAttack_LogMessage("The corresponding superpoly is not a linear polynomial !", NotificationLevel.Info);
     1088                            }
    8811089                        else
    882                         {
    883                             if(!stop)
    884                                 CubeAttack_LogMessage("The corresponding superpoly is not a linear polynomial !", NotificationLevel.Info);
    885                         }
     1090                            CubeAttack_LogMessage("The corresponding superpoly is constant !", NotificationLevel.Info);
    8861091                    }
    8871092                    else
    8881093                    {
    8891094                        StringBuilder output = new StringBuilder(string.Empty);
    890                         output.Append("Output bit: " + Blackbox(pubVari, secVari));
    891                         outputMaxterm += output.ToString();
    892                         OnPropertyChanged("OutputMaxterm");
    893                         CubeAttack_LogMessage("Output bit: " + Blackbox(pubVari, secVari), NotificationLevel.Info);
     1095                        output.Append("Black box output bit: " + Blackbox(pubVarGlob, new int[settings.SecretVar]));
     1096                        outputSuperpoly += output.ToString();
     1097                        OnPropertyChanged("OutputSuperpoly");
     1098                        CubeAttack_LogMessage("Black box output bit: " + Blackbox(pubVarGlob, new int[settings.SecretVar]), NotificationLevel.Info);
    8941099                    }
    8951100                }
     
    9141119                case CubeAttackMode.preprocessing:
    9151120                    PreprocessingPhase();
     1121                    break;
     1122                case CubeAttackMode.online:
     1123                    OnlinePhase(superpolyMatrix, listCubeIndexes);
    9161124                    break;
    9171125                case CubeAttackMode.setPublicBits:
  • trunk/CrypPlugins/CubeAttack/CubeAttackSettings.cs

    r617 r724  
    4444        private int selectedBlackBox = 0;
    4545        private int selectedAction = 0;
    46         bool onlinePhase = false;
    4746        private int publicVar;
    4847        private int secretVar;
     
    6059
    6160        [PropertySaveOrder(1)]
    62         [ContextMenu("Black box",
     61        [ContextMenu("Black Box",
    6362            "Select the black box",
    6463            1,
     
    6867            "Boolean function parser",
    6968            "Trivium")]
    70         [TaskPane("Black box",
     69        [TaskPane("Black Box",
    7170            "Select the black box",
    7271            "",
     
    8988        [PropertySaveOrder(2)]
    9089        [ContextMenu("Action",
    91             "Select the Algorithm action",
     90            "Select the cube attack modi",
    9291            2,
    9392            DisplayLevel.Beginner,
    9493            ContextMenuControlType.ComboBox,
    9594            null,
    96             "Preprocessing/Online Phase",
    97             "Input public bits")]
    98         [TaskPane("Action",
    99             "Select the phase",
     95            "Preprocessing",
     96            "Online",
     97            "Manual Public Bit Input")]
     98        [TaskPane("Action",
     99            "Select the cube attack modi",
    100100            "",
    101101            2,
     
    103103            DisplayLevel.Beginner,
    104104            ControlType.ComboBox,
    105             new string[] { "Preprocessing/Online Phase", "Input public bits" })]
     105            new string[] { "Preprocessing", "Online", "Manual Public Bit Input" })]
    106106        public int Action
    107107        {
     
    114114            }
    115115        }
    116 
     116       
    117117        [PropertySaveOrder(3)]
    118         [ContextMenu("Try to discover key",
    119             "Online phase of the cube attack which tries to solve the system of linear maxterm equations to discover the secret key.",
     118        [TaskPane("Public Bit Size",
     119            "Public input bits (IV or plaintext) of the attacked cryptosystem.",
     120            null,
    120121            3,
    121             DisplayLevel.Beginner,
    122             ContextMenuControlType.CheckBox,
    123             null,
    124             "")]
    125         [TaskPane("Try to discover key",
    126             "Online phase of the cube attack which tries to solve the system of linear maxterm equations to discover the secret key.",
    127             null,
    128             3,
    129             false,
    130             DisplayLevel.Expert,
    131             ControlType.CheckBox, "")]
    132         public bool OnlinePhase
    133         {
    134             get { return this.onlinePhase; }
    135             set
    136             {
    137                 if (value != this.onlinePhase) HasChanges = true;
    138                 this.onlinePhase = value;
    139                 OnPropertyChanged("OnlinePhase");
    140             }
    141         }
    142 
    143         [PropertySaveOrder(4)]
    144         [TaskPane("Public bit size",
    145             "Public input bits (IV or plaintext) of the attacked cryptosystem.",
    146             null,
    147             4,
    148122            false,
    149123            DisplayLevel.Beginner,
     
    163137        }
    164138
    165         [PropertySaveOrder(5)]
    166         [TaskPane("Secret bit size",
     139        [PropertySaveOrder(4)]
     140        [TaskPane("Secret Bit Size",
    167141            "Key size or key length  of the attacked cryptosystem.",
    168142            null,
    169             5,
     143            4,
    170144            false,
    171145            DisplayLevel.Beginner,
     
    185159        }
    186160
    187         [PropertySaveOrder(6)]
    188         [TaskPane("Max cube size",
     161        [PropertySaveOrder(5)]
     162        [TaskPane("Max Cube Size",
    189163            "Maxmium size of the summation cube.",
    190164            null,
    191             6,
    192             false,
     165            5,
     166            true,
    193167            DisplayLevel.Beginner,
    194168            ControlType.NumericUpDown,
     
    207181        }
    208182
    209         [PropertySaveOrder(7)]
     183        [PropertySaveOrder(6)]
    210184        [TaskPane("Constant Test",
    211185            "Number of tests to check if the superpoly is a constant value or not.",
    212186            null,
    213             7,
    214             false,
     187            6,
     188            true,
    215189            DisplayLevel.Beginner,
    216190            ControlType.NumericUpDown,
     
    229203        }
    230204
    231         [PropertySaveOrder(8)]
    232         [TaskPane("Linearity tests",
     205        [PropertySaveOrder(7)]
     206        [TaskPane("Linearity Test",
    233207            "Number of linearity tests to check if the superpoly is linear or not.",
    234208            null,
    235             8,
    236             false,
     209            7,
     210            true,
    237211            DisplayLevel.Beginner,
    238212            ControlType.NumericUpDown,
     
    251225        }
    252226
    253         [PropertySaveOrder(9)]
    254         [TaskPane("Input public bits",
    255             "Manual input of public bits.",
    256             null,
    257             9,
     227        [PropertySaveOrder(8)]
     228        [TaskPane("Manual Public Bit Input",
     229            "Possible inputs '0' (set bit to value 0), '1' (set bit to value 1) and '*' (sum the 0/1 value of the bit).",
     230            null,
     231            8,
    258232            false,
    259233            DisplayLevel.Beginner,
     
    277251        }
    278252
    279         [PropertySaveOrder(10)]
    280         [TaskPane("Trivium output bit index",
    281             "Chooses the output bit index in the stream cipher Trivium.",
    282             null,
    283             10,
    284             false,
     253        [PropertySaveOrder(9)]
     254        [TaskPane("Trivium Output Bit",
     255            "Chooses the output bit in the stream cipher Trivium.",
     256            null,
     257            9,
     258            true,
    285259            DisplayLevel.Beginner,
    286260            ControlType.NumericUpDown,
     
    299273        }
    300274
    301         [PropertySaveOrder(11)]
    302         [TaskPane("Trivium rounds",
     275        [PropertySaveOrder(10)]
     276        [TaskPane("Trivium Initialisation Rounds",
    303277            "Number of Trivium initialisation rounds.",
    304278            null,
    305             11,
     279            10,
    306280            false,
    307281            DisplayLevel.Beginner,
  • trunk/CrypPlugins/CubeAttack/Matrix.cs

    r446 r724  
    88    public class Matrix
    99    {
    10         // Class attributes
     10        /// <summary>
     11        /// Class attributes/members
     12        /// </summary>
    1113        private int rows, cols;
    1214        private int[,] element;
    1315
    14         // Constructor
     16        /// <summary>
     17        /// Contructor
     18        /// </summary>
    1519        public Matrix(int rows, int cols)
    1620        {
     
    2428        }
    2529
    26         // Properties
     30        /// <summary>
     31        /// Properites
     32        /// </summary>
    2733        public int Rows
    2834        {
     
    3541        }
    3642
     43        /// <summary>
     44        /// Indexer
     45        /// </summary>
    3746        public int this[int row, int col]
    3847        {
     
    4150        }
    4251
     52        /// <summary>
     53        /// Internal functions for getting/setting values
     54        /// </summary>
    4355        public int GetElement(int row, int col)
    4456        {
     
    5567        }
    5668
    57         // Transpose the matrix
     69        /// <summary>
     70        /// Returns the transpose of the current matrix
     71        /// </summary>
    5872        public Matrix Transpose()
    5973        {
     
    6579        }
    6680
    67         // Returns the minor of a Matrix element[Row,Col]
     81        /// <summary>
     82        /// Return the minor of a matrix element[Row,Col]
     83        /// </summary>
    6884        public static Matrix Minor(Matrix matrix, int row, int col)
    6985        {
     
    87103        }
    88104
    89         // Returns the determinent of the matrix
     105        /// <summary>
     106        /// Returns the determinent of the current Matrix
     107        /// It computes the determinent in the traditional way (i.e. using minors)
     108        /// </summary>
    90109        public int Determinent()
    91110        {
     
    93112        }
    94113
     114        /// <summary>
     115        /// Helper function for the above Determinent() method
     116        /// it calls itself recursively and computes determinent using minors
     117        /// </summary>
    95118        private int Determinent(Matrix matrix)
    96119        {
     
    103126        }
    104127
    105         // Returns the adjoint of the matrix
     128        /// <summary>
     129        /// Returns the adjoint of the current matrix
     130        /// </summary>
    106131        public Matrix Adjoint()
    107132        {
     
    114139        }
    115140
    116         // Returns the inverse of a square matrix by adjoint method
     141        /// <summary>
     142        /// Returns the inverse of a square matrix over GF(2) (by adjoint method)
     143        /// </summary>
    117144        public Matrix Inverse()
    118145        {
     
    127154        }
    128155
     156        /// <summary>
     157        /// Operator for the matrix object
     158        /// includes binary operator /
     159        /// </summary>
     160        public static Matrix operator /(Matrix matrix, int iNo)
     161        { return Matrix.Multiply(matrix, iNo); }
     162
     163        /// <summary>
     164        /// Internal function for the above operator
     165        /// </summary>
    129166        private static Matrix Multiply(Matrix matrix, int iNo)
    130167        {
     
    136173        }
    137174
     175        /// <summary>
     176        /// The function adds one superpoly for the current matrix
     177        /// </summary>
    138178        public Matrix AddRow(List<int> superpoly)
    139179        {
     
    147187        }
    148188
     189        /// <summary>
     190        /// The function deletes the last row of the current matrix
     191        /// </summary>
    149192        public Matrix DeleteLastRow()
    150193        {
     
    156199        }
    157200
     201        /// <summary>
     202        /// The function deletes the first columnm of the current matrix
     203        /// </summary>
    158204        public Matrix DeleteFirstColumn()
    159205        {
     
    164210            return m;
    165211        }
    166 
    167         public static Matrix operator /(Matrix matrix, int iNo)
    168         { return Matrix.Multiply(matrix, iNo); }
    169212    }
    170213
     214    /// <summary>
     215    /// Exception class for Matrix and Vector, derived from System.Exception
     216    /// </summary>
    171217    public class MatrixVectorException : Exception
    172218    {
  • trunk/CrypPlugins/CubeAttack/Vector.cs

    r446 r724  
    88    public class Vector
    99    {
    10         // Class attributes
     10        /// <summary>
     11        /// Class attributes/members
     12        /// </summary>
    1113        private int length;
    1214        private int[] element;
    1315
    14         // Constructor
     16        /// <summary>
     17        /// Contructor
     18        /// </summary>
    1519        public Vector(int length)
    1620        {
     
    1923        }
    2024
    21         // Properties
     25        /// <summary>
     26        /// Properites
     27        /// </summary>
    2228        public int Length
    2329        {
     
    2632        }
    2733
     34        /// <summary>
     35        /// Indexer
     36        /// </summary>
    2837        public int this[int i]
    2938        {
     
    3241        }
    3342
     43        /// <summary>
     44        /// Internal functions for getting/setting values
     45        /// </summary>
    3446        public int GetElement(int i)
    3547        {
     
    4658        }
    4759
    48         // Returns the product of a matrix and a vector
     60        /// <summary>
     61        /// The function multiplies the given matrix on a vector
     62        /// </summary>
    4963        public static Vector Multiply(Matrix matrix1, Vector vec)
    5064        {
     
    5872        }
    5973
     74        /// <summary>
     75        /// Operator for the Vector object
     76        /// includes binary operator *
     77        /// </summary>
    6078        public static Vector operator *(Matrix matrix1, Vector vec)
    6179        { return (Multiply(matrix1, vec)); }
Note: See TracChangeset for help on using the changeset viewer.