Changeset 1738


Ignore:
Timestamp:
Jul 17, 2010, 8:06:04 PM (11 years ago)
Author:
schomburg
Message:

fixed KuehnSignatures so that they should work and minor fixes on other classes

Location:
trunk/PKCS1
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/PKCS1/Library/BleichenbacherSignature.cs

    r1663 r1738  
    5555            while (false == isDivByThree)
    5656            {
    57                 BigInteger hashDigest = new BigInteger(1, Hashfunction.generateHashDigest(Datablock.getInstance().Message, Datablock.getInstance().HashFunctionIdent));
     57                byte[] bMessage =  Datablock.getInstance().Message;
     58                HashFunctionIdent hashIdent = Datablock.getInstance().HashFunctionIdent;
     59                BigInteger hashDigest = new BigInteger(1, Hashfunction.generateHashDigest(ref bMessage, ref hashIdent));
    5860                // T*2^160 + H
    5961                datablock = derIdent.Multiply(BigInteger.Two.Pow(hashDigestLength)).Add(hashDigest); // Datablock erstellen; T=HashFuncIdent; H=HashDigest
     
    6668                else
    6769                {
    68                     Datablock.getInstance().Message = Datablock.getInstance().Message + " ";
     70                    byte[] tmp = new byte[Datablock.getInstance().Message.Length+1];
     71                    Array.Copy(Datablock.getInstance().Message,tmp,Datablock.getInstance().Message.Length);
     72                    Array.Copy(Encoding.ASCII.GetBytes(" "), 0, tmp, Datablock.getInstance().Message.Length, Encoding.ASCII.GetBytes(" ").Length);
     73                    Datablock.getInstance().Message = tmp;
    6974                }
    7075            }
     
    8489            fakeSig = fakeSig.Add( BigInteger.Two.Pow(startPos.IntValue-8).Multiply(BigInteger.ValueOf(125)) ); // add garbage
    8590
    86             BigInteger fakeSigResult = MathFunctions.cuberoot2(fakeSig);
     91            BigInteger fakeSigResult = MathFunctions.cuberoot(fakeSig);
    8792
    8893            byte[] returnByteArray = new byte[this.m_KeyLength / 8]; // KeyLength is in bit
  • trunk/PKCS1/Library/Datablock.cs

    r1650 r1738  
    4242
    4343        protected byte[] m_Message = new byte[0];
    44         public string Message
     44        public byte[] Message
    4545        {
    4646            set
    4747            {
    48                 string tmpString = (string)value;
    49                 this.m_Message = Encoding.ASCII.GetBytes(tmpString);
     48                //string tmpString = (string)value;
     49                //this.m_Message = Encoding.ASCII.GetBytes(tmpString);
     50                this.m_Message = value;
    5051                OnRaiseParamChangedEvent(ParameterChangeType.Message);
    5152            }
    52             get { return Encoding.ASCII.GetString(this.m_Message); }
     53            //get { return Encoding.ASCII.GetString(this.m_Message); }
     54            get { return this.m_Message; }
    5355        }
    5456
     
    7375        public string GetHashDigestToHexString()
    7476        {
    75             return Encoding.ASCII.GetString(Hex.Encode(Hashfunction.generateHashDigest(this.Message, this.HashFunctionIdent)));
     77            byte[] bMessage = this.Message;
     78            HashFunctionIdent hashIdent = this.HashFunctionIdent;
     79            return Encoding.ASCII.GetString(Hex.Encode(Hashfunction.generateHashDigest(ref bMessage, ref hashIdent)));
    7680        }
    7781       
  • trunk/PKCS1/Library/Hashfunction.cs

    r1650 r1738  
    1111    {
    1212        private static IDigest hashFunctionDigest = DigestUtilities.GetDigest(HashFunctionHandler.SHA1.diplayName); // default SHA1
    13 
     13       
    1414        public static byte[] generateHashDigest(string input, HashFunctionIdent hashIdent)
    1515        {
    16             return generateHashDigest(Encoding.ASCII.GetBytes(input), hashIdent);
     16            byte[] bInput = Encoding.ASCII.GetBytes(input);
     17            return generateHashDigest(ref bInput, ref hashIdent);
    1718        }
    1819
    19         public static byte[] generateHashDigest(byte[] input, HashFunctionIdent hashIdent)
     20        public static byte[] generateHashDigest(ref byte[] input, ref HashFunctionIdent hashIdent)
    2021        {   
    2122            hashFunctionDigest = DigestUtilities.GetDigest(hashIdent.diplayName);
  • trunk/PKCS1/Library/KuehnSignature.cs

    r1663 r1738  
    2121        {
    2222            this.m_KeyLength = RSAKeyManager.getInstance().RsaKeySize; // Länge des RSA Modulus
    23             string message = Datablock.getInstance().Message; // Die Nachricht für welche die Signatur erstellt werden soll
     23
     24            // drei Leerzeichen an Msg anhängen
     25            string sMsgModifier = "   ";
     26            byte[] bMsgModifier = Encoding.ASCII.GetBytes(sMsgModifier);
     27            byte[] bMessage = new byte[ Datablock.getInstance().Message.Length + bMsgModifier.Length ];
     28            Array.Copy(Datablock.getInstance().Message, bMessage, Datablock.getInstance().Message.Length);
     29            Array.Copy(bMsgModifier, 0, bMessage, Datablock.getInstance().Message.Length, bMsgModifier.Length);
     30           
    2431            HashFunctionIdent hashFuncIdent = Datablock.getInstance().HashFunctionIdent; // Die vom User gewählte Hashfunktion
    2532            byte[] hashIdent = Hex.Decode(Encoding.ASCII.GetBytes(hashFuncIdent.DERIdent)); // ASN.1 codierter Ident-string
     33            int significantByteLength = 11 + hashIdent.Length + hashFuncIdent.digestLength/8;           
    2634
    2735            // Datenblock wird konstruiert
    28             byte[] A = new byte[46];
     36            byte[] A = new byte[significantByteLength];
    2937            A[0] = 0x00;
    3038            A[1] = 0x01;
     
    3442            }
    3543            A[10] = 0x00;         
    36             Array.Copy(hashIdent, 0, A, 11, hashIdent.Length);         
     44            Array.Copy(hashIdent, 0, A, 11, hashIdent.Length);
    3745            // Datenblock noch ohne Hashwert, wird in while Schleife unten hinzugefügt
    3846
    3947            // byte array der kompletten Signatur, wird zuerst mit 'FF' gefüllt und dann nachher Datenblock an den Anfang kopiert
    40             byte[] S = new byte[128]; // 1024 bit
     48            //byte[] S = new byte[128]; // 1024 bit
     49            byte[] S = new byte[this.m_KeyLength / 8];
    4150            for (int i = A.Length; i < S.Length; i++)
    4251            {
     
    4453            }
    4554
    46             BigInteger finalSignature = null;
    47             byte[] bMessage = Encoding.ASCII.GetBytes(message);
     55            BigInteger finalSignature = null;           
    4856            int iMsgLength = bMessage.Length;
    49 
    5057            bool isEqual = false;
    5158            int limit = 250000;
    5259            int countLoops = 0;
    5360
    54             SHA1Managed sha1Hash = new SHA1Managed();
    55             this.SendGuiLogMsg("Signature tests started", NotificationLevel.Info);
     61            //this.SendGuiLogMsg("Signature tests started", NotificationLevel.Info);
     62            byte[] hashDigest = new byte[0]; // Hashwert wird in dieser var gespeichert
     63            BigInteger T = new BigInteger("0"); // hilfsvar
     64            //byte[] resultArray = new byte[128]; // damit verglichen werden kann in byte array kopieren
     65            byte[] resultArray = new byte[this.m_KeyLength/8];
    5666
    5767            while (!isEqual && (countLoops < limit))
    5868            {
    59                 //byte[] hashDigest = Hashfunction.generateHashDigest(message, hashFuncIdent); // Hashwert wird erzeugt
    60                 //byte[] hashDigest = Hashfunction.generateHashDigest(bMessage, hashFuncIdent); // Hashwert wird erzeugt
    61                 byte[] hashDigest = sha1Hash.ComputeHash(bMessage);
     69                hashDigest = Hashfunction.generateHashDigest(ref bMessage, ref hashFuncIdent); // Hashwert wird erzeugt
    6270                Array.Copy(hashDigest, 0, A, 11 + hashIdent.Length, hashDigest.Length); // erzeugter Hashwert wird in den Datenblock kopiert
    6371                Array.Copy(A, 0, S, 0, A.Length); // erzeugter Datenblock wird in erzeugte Signatur S kopiert
    6472
    65                 //string test = Encoding.ASCII.GetString(Hex.Encode(S));
    66                 /*
    67                 ///////////////////////////////////////////////////////////////////////////////////////////
    68                 // nur testweise
    69                 string test1 = Encoding.ASCII.GetString(Hex.Encode(S));
    70                 BigInteger fakegarbage = BigInteger.ValueOf(125);
    71                 Array.Copy(fakegarbage.ToByteArray(), 0, S, A.Length, fakegarbage.ToByteArray().Length);
    72                 string test2 = Encoding.ASCII.GetString(Hex.Encode(S));
    73                 //
    74                 //////////////////////////////////////////////////////////////////////////////////////////
    75                 */
    76 
    77                 finalSignature = MathFunctions.cuberoot2(new BigInteger(S)); // Kubikwurzel ziehen
    78                 BigInteger T = finalSignature.Pow(3); // mit 3 potenzieren
    79                 byte[] resultArray = new byte[128]; // damit verglichen werden kann in byte array kopieren
    80 
    81                 // durch Konvertierung in BigInteger werden führende Nullen abgeschnitten,
    82                 // daher wird an Stelle 1 in byte array kopiert.
     73                finalSignature = MathFunctions.cuberoot4(new BigInteger(S), this.m_KeyLength); // Kubikwurzel ziehen         
     74                byte[] test2 = finalSignature.ToByteArray();
     75                T = finalSignature.Pow(3); // mit 3 potenzieren       
     76                byte[] test = T.ToByteArray();
     77                resultArray[0] = 0x00; // erstes byte is 0
     78                // durch Konvertierung in BigInteger werden führende Nullen abgeschnitten, daher wird an Stelle 1 in byte array kopiert.
    8379                Array.Copy(T.ToByteArray(), 0, resultArray, 1, T.ToByteArray().Length);
    8480
    85                 //string test2 = Encoding.ASCII.GetString(Hex.Encode(resultArray));
    86                
    87 
    88                 isEqual = MathFunctions.compareByteArray(resultArray,S,45); // byte arrays vergleichen, wird in meinen Tests nicht erreicht
     81                isEqual = MathFunctions.compareByteArray(ref resultArray, ref S, significantByteLength); // byte arrays vergleichen, wird in meinen Tests nicht erreicht
    8982                if (!isEqual)
    90                 {
     83                {                   
     84                    //BigInteger bLast3Bytes = new BigInteger(new byte[] { bMessage[iMsgLength - 3], bMessage[iMsgLength - 2], bMessage[iMsgLength - 1] });
     85                    //bLast3Bytes = bLast3Bytes.Add(BigInteger.One);
     86                    //Array.Copy(bLast3Bytes.ToByteArray(), 0, bMessage, bMessage.Length - 3, 3);                   
     87                    int value1 = bMessage[iMsgLength - 1];                                       
     88                    if (++value1 >= 256)
     89                    {
     90                        value1 = 0;
     91                        int value2 = bMessage[iMsgLength - 2];
     92                        if (++value2 >= 256)
     93                        {
     94                            value2 = 0;
     95                            int value3 = bMessage[iMsgLength - 3];
     96                            ++value3;
     97                            bMessage[iMsgLength - 3] = (byte)value3;
     98                        }
     99                        bMessage[iMsgLength - 2] = (byte)value2;
     100                    }
     101                    bMessage[iMsgLength - 1] = (byte)value1;
    91102                   
    92                     byte[] tmp1 = { bMessage[iMsgLength - 3], bMessage[iMsgLength - 2], bMessage[iMsgLength - 1] };
    93 
    94                     BigInteger tmp2 = new BigInteger(tmp1);
    95                     tmp2 = tmp2.Add(BigInteger.One);
    96                     tmp1 = tmp2.ToByteArray();
    97 
    98                     Array.Copy( tmp1, 0, bMessage, bMessage.Length-3,3);
    99103                    countLoops++;
    100104                }
    101             }
    102 
    103             Datablock.getInstance().Message = message;
    104 
     105            }           
     106            Datablock.getInstance().Message = bMessage;
    105107            byte[] returnByteArray = new byte[this.m_KeyLength/8];
    106108            Array.Copy(finalSignature.ToByteArray(), 0, returnByteArray, returnByteArray.Length - finalSignature.ToByteArray().Length, finalSignature.ToByteArray().Length);
  • trunk/PKCS1/Library/MathFunctions.cs

    r1650 r1738  
    44using System.Text;
    55using Org.BouncyCastle.Math;
     6
    67using Emil.GMP;
     8using PKCS1.BigNum;
    79
    810namespace PKCS1.Library
     
    3133                biFromBevor = biStart;
    3234                // (2 * biStart + (x/ biStart^2)) / 3
    33                 biStart = biFix2.Multiply(biStart).Add(radicant.Divide(biStart.Pow(2))).Divide(biFix3);               
     35                biStart = biFix2.Multiply(biStart).Add(radicant.Divide(biStart.Pow(2))).Divide(biFix3);
    3436                i++;
    3537            }
    36             return biStart; 
     38            return biStart;
    3739        }
    3840
     
    4244            byte[] array2 = value2.ToByteArray();
    4345
    44             return compareByteArray(array1, array2, length);
    45         }
    46 
    47         static public bool compareByteArray(byte[] array1, byte[] array2, int length)
    48         {
    49             for(int i = length-1; i>0; i--)
     46            return compareByteArray(ref array1, ref array2, length);
     47        }
     48
     49        static public bool compareByteArray(ref byte[] array1, ref byte[] array2, int length)
     50        {
     51            for (int i = length - 1; i > 0; i--)
    5052            {
    5153                if (array1[i] != array2[i])
     
    5557            }
    5658            return true;
    57        
    58             /*
    59             for (int i = 0; i < length; i++)
    60             {
    61                 if (array1[i] != array2[i])
     59        }
     60
     61
     62
     63        /// <summary>
     64        /// Computes an approximate cube root of a number,
     65        /// by using the Newton approximation for next guess.
     66        /// </summary>
     67        /// <param name="x">The number to compute the cube root from.</param>
     68        /// <returns></returns>
     69        static public BigInteger cuberoot3(BigInteger BigIntRad)
     70        {
     71            BigNumDec y;               // Guess
     72            BigNumDec d;               // Last difference of y3 and x
     73            BigNumDec l;               // The limit for optimal guess
     74
     75            // Check for simple cases:
     76            if (BigIntRad.Equals(BigInteger.Zero))
     77                return BigInteger.Zero;
     78            else if (BigIntRad.Equals(BigInteger.One))
     79                return BigInteger.One;
     80            else if (BigIntRad.Equals(BigInteger.ValueOf(-1)))
     81                return BigInteger.ValueOf(-1);
     82            else
     83            {
     84                BigNumDec x = new BigNumDec(BigIntRad.ToString());
     85
     86                //l = Math.Abs(x * 1E-14);                // Set the limit appropriately
     87                BigNumDec E = new BigNumDec("0.00000000000000000000000000000000000000000000000000000000000000000001");
     88                l = BigNumDec.Multiply(x, E);
     89               
     90                // the multiplication with x (its magnitude) should
     91                // ensure no infinite loops, at the cost
     92                // of some precision on high numbers.
     93
     94                // Make initial guess:               
     95                //double g = Math.Abs(x);     // Do this guess on a positive number
     96                BigNumDec g = x;
     97                //if (g < BigInteger.One)
     98                //if (g.CompareTo(new BigNumDec(1)) < 1)
     99                if( g < new BigNumDec(1))
     100                    y = x;
     101                //else if (g < 10)
     102                //else if (g.CompareTo(new BigNumDec(10)) == -1)
     103                else if( g < 10)
     104                    //y = x / 3;
     105                    y = BigNumDec.Divide(x,new BigNumDec(3));
     106                else if (g < 20)
     107                    //y = x / 6;
     108                    y = BigNumDec.Divide(x,new BigNumDec(6));
     109                else if (g < 50)
     110                    //y = x / 10;
     111                    y = BigNumDec.Divide(x,new BigNumDec(10));
     112                else if (g < 100)
     113                    //y = x / 20;
     114                    y = BigNumDec.Divide(x,new BigNumDec(20));
     115                else if (g < 1000)
     116                    //y = x / 50;
     117                    y = BigNumDec.Divide(x,new BigNumDec(50));
     118                else if (g < 5000)
     119                    //y = x / 100;
     120                    y = BigNumDec.Divide(x, new BigNumDec(100));
     121                //else if (g < 10000)
     122                //else if (g.CompareTo(new BigNumDec(10000)) == -1)
     123                else if( g < 10000)
     124                    //y = x / 500;
     125                    y = BigNumDec.Divide(x,new BigNumDec(500));
     126                else if (g < 50000)
     127                    //y = x / 1000;
     128                    y = BigNumDec.Divide(x, new BigNumDec(1000));
     129                else if (g < 100000)
     130                    //y = x / 50000;
     131                    y = BigNumDec.Divide(x, new BigNumDec(50000));
     132                else
     133                    //y = x / 100000;
     134                    y = BigNumDec.Divide(x,new BigNumDec(100000));
     135
     136                // Improve guess immediately:
     137                //y = ((x / (y * y)) + 2 * y) / 3;            // Newton's approx. for new guess
     138                y = BigNumDec.Divide( BigNumDec.Add( BigNumDec.Divide(x, BigNumDec.Multiply(y,y)) , BigNumDec.Multiply(new BigNumDec(2),y) ), new BigNumDec(3));
     139                //d = Math.Abs(y * y * y - x);                // Calculate difference
     140                d = BigNumDec.Multiply( BigNumDec.Multiply(y,y), y);
     141                d = BigNumDec.Subtract( d, x);
     142                d.Absolute();
     143                #region
     144                while (l < d)
    62145                {
    63                     return false;
     146                    //y = ((x / (y * y)) + 2 * y) / 3;        // Newton's approx. for new guess
     147                    y = BigNumDec.Divide(BigNumDec.Add(BigNumDec.Divide(x, BigNumDec.Multiply(y, y)), BigNumDec.Multiply(new BigNumDec(2), y)), new BigNumDec(3));
     148                    //d = Math.Abs(y * y * y - x);                // Calculate difference
     149                    d = BigNumDec.Multiply(BigNumDec.Multiply(y, y), y);
     150                    d = BigNumDec.Subtract(d, x);
     151                    d.Absolute();
    64152                }
    65             }
    66             return true;
    67              */
     153                #endregion
     154
     155                string test = y.ToString();
     156
     157                return BigInteger.Three;
     158            }
     159        }
     160
     161        static public BigInteger cuberoot4(BigInteger BigIntRad, int prec)
     162        {
     163            //BigInteger x;                    // ZZ: Langzahl-Integer
     164            myFloat a = new myFloat();
     165            myFloat xi = new myFloat();
     166            myFloat x3 = new myFloat();
     167            myFloat two = new myFloat(); // RR: Gleitkommazahlen beliebiger Präzision
     168            myFloat three = new myFloat(); // RR: Gleitkommazahlen beliebiger Präzision
     169
     170            myFloat.setPrec(prec);
     171
     172            //x = BigIntRad;
     173
     174            BigInteger BigInt2 = BigInteger.Two;
     175            myFloat.to_Float(ref two, ref BigInt2);
     176
     177            BigInteger BigInt3 = BigInteger.Three;
     178            myFloat.to_Float(ref three, ref BigInt3);
     179
     180            // 1. Startwert für die Approximation berechnen (mit double)
     181            //appr_cr_x = exp( 1.0/3.0 * log(x) ); 
     182           
     183
     184            // 2. Startwert (xi) und Ausgangswert (a=x) in Gleitkommazahl mit hoher Präzision überführen
     185            //a  = to_RR(x);
     186            myFloat.to_Float(ref a, ref BigIntRad);
     187
     188            myFloat tmp = new myFloat();
     189            BigInteger tmp2 = BigInteger.ValueOf(BigIntRad.BitLength);
     190            myFloat.to_Float(ref tmp,ref tmp2);
     191            //xi = to_RR(appr_cr_x);
     192            //xi = new myFloat(appr_cr_x);
     193            //myFloat.div(ref xi, ref a,ref tmp);
     194            BigInteger start = BigIntRad.ShiftRight(BigIntRad.BitLength * 2 / 3);
     195            myFloat.to_Float(ref xi, ref start);
     196
     197
     198            // 3. Halley's konvergierende Folge (x[i+1] = xi*(xi^3 + 2*a)/(2*xi^3 + a) --> x^(1/3)) mit 200 Iterationen -- *nicht optimiert*
     199            //two = to_RR(2.0);
     200            //two = new myFloat(2.0);
     201
     202            for ( int i = 0; i<200; i++ )
     203            {
     204                //x3 = xi*xi*xi;
     205                myFloat.mul(ref x3, ref xi, ref xi);
     206                myFloat.mul(ref x3, ref x3, ref xi);
     207                //xi = (xi*(x3 + two * a)) / ( two * x3 + a );
     208               
     209                //xi = xi*( (x3 + two * a) / ( two * x3 +a ) );
     210                myFloat twoA = new myFloat();
     211                myFloat.mul(ref twoA, ref two, ref a);
     212
     213                myFloat left = new myFloat();
     214                myFloat.add(ref left, ref x3, ref twoA);
     215               
     216
     217                myFloat twoX3 = new myFloat();
     218                myFloat.mul(ref twoX3, ref two, ref x3);
     219
     220                myFloat right = new myFloat();
     221                myFloat.add(ref right, ref twoX3, ref a);
     222
     223                myFloat division = new myFloat();
     224                myFloat.div(ref division, ref left, ref right);
     225
     226                myFloat.mul(ref xi, ref xi, ref division);
     227            }
     228
     229            return myFloat.to_ZZ(ref xi);
    68230        }
    69231    }
    70 
    71     /*
    72      /// <summary>
    73      /// Computes an approximate cube root of a number,
    74      /// by using the Newton approximation for next guess.
    75      /// </summary>
    76      /// <param name="x">The number to compute the cube root from.</param>
    77      /// <returns></returns>
    78      public static BigInteger Cbrt(BigInteger x)
    79      {
    80          BigInteger y;               // Guess
    81          BigInteger d;               // Last difference of y3 and x
    82          BigInteger l;               // The limit for optimal guess
    83 
    84          // Check for simple cases:
    85          #region
    86          if (x.Equals( BigInteger.Zero))
    87              return BigInteger.Zero;
    88          else if (x.Equals(BigInteger.One))
    89              return BigInteger.One;
    90          else if (x.Equals(BigInteger.ValueOf(-1)))
    91              return BigInteger.ValueOf(-1);
    92          else
    93          #endregion
    94          {
    95 
    96              //l = Math.Abs(x * 1E-14);                // Set the limit appropriately
    97              BigInteger E = new BigInteger("0,00000000001");
    98              l = x.Multiply(E).Abs();
    99              // the multiplication with x (its magnitude) should
    100              // ensure no infinite loops, at the cost
    101              // of some precision on high numbers.
    102 
    103              // Make initial guess:
    104              #region
    105              //double g = Math.Abs(x);     // Do this guess on a positive number
    106              BigInteger g = x.Abs();
    107              if (g < BigInteger.One)
    108                  y = x;
    109              else if (g < 10)
    110                  y = x / 3;
    111              else if (g < 20)
    112                  y = x / 6;
    113              else if (g < 50)
    114                  y = x / 10;
    115              else if (g < 100)
    116                  y = x / 20;
    117              else if (g < 1000)
    118                  y = x / 50;
    119              else if (g < 5000)
    120                  y = x / 100;
    121              else if (g < 10000)
    122                  y = x / 500;
    123              else if (g < 50000)
    124                  y = x / 1000;
    125              else if (g < 100000)
    126                  y = x / 50000;
    127              else
    128                  y = x / 100000;
    129              #endregion
    130 
    131              // Improve guess immediately:
    132              y = ((x / (y * y)) + 2 * y) / 3;            // Newton's approx. for new guess
    133              d = Math.Abs(y * y * y - x);                // Calculate difference
    134              #region
    135              while (l < d)
    136              {
    137                  y = ((x / (y * y)) + 2 * y) / 3;        // Newton's approx. for new guess
    138                  d = Math.Abs(y * y * y - x);            // Calculate difference
    139              }
    140              #endregion
    141              return y;
    142          }
    143      }*/
    144232}
  • trunk/PKCS1/Library/RSASignature.cs

    r1650 r1738  
    2121        private byte[] getCompleteHw()
    2222        {
    23             byte[] hashIdent = Hex.Decode(Datablock.getInstance().HashFunctionIdent.DERIdent);
    24             byte[] hashDigest = Hashfunction.generateHashDigest(Datablock.getInstance().Message, Datablock.getInstance().HashFunctionIdent);         
    25             byte[] returnArray = new byte[hashIdent.Length + Hashfunction.getDigestSize()];
    26             Array.Copy(hashIdent, 0, returnArray, 0, hashIdent.Length);
     23            byte[] bDerHashIdent = Hex.Decode(Datablock.getInstance().HashFunctionIdent.DERIdent);
     24            byte[] bMessage = Datablock.getInstance().Message;
     25            HashFunctionIdent hashIdent = Datablock.getInstance().HashFunctionIdent;
     26            byte[] hashDigest = Hashfunction.generateHashDigest(ref bMessage, ref hashIdent);         
     27            byte[] returnArray = new byte[bDerHashIdent.Length + Hashfunction.getDigestSize()];
     28            Array.Copy(bDerHashIdent, 0, returnArray, 0, bDerHashIdent.Length);
    2729            Array.Copy(hashDigest, 0, returnArray, returnArray.Length - hashDigest.Length, hashDigest.Length);
    2830
  • trunk/PKCS1/Library/RSAValidator.cs

    r1650 r1738  
    1919        #region verify Signatures
    2020
    21         private bool verifySig(ISigner verifier, string message, byte[] signature)
     21        private bool verifySig(ISigner verifier, byte[] message, byte[] signature)
    2222        {           
    2323            verifier.Init(false, RSAKeyManager.getInstance().getPubKey());           
    24             byte[] messageInBytes = Encoding.ASCII.GetBytes(message);
     24            byte[] messageInBytes = message;
    2525            verifier.BlockUpdate(messageInBytes, 0, messageInBytes.Length); // update bekommt klartextnachricht als param           
    2626            return verifier.VerifySignature(signature); // input ist verschlüsselte Nachricht
    2727        }
    2828
    29         public bool verifyRsaSignature(string message, byte[] signature)
     29        public bool verifyRsaSignature(byte[] message, byte[] signature)
    3030        {
    3131            IAsymmetricBlockCipher eng = new Pkcs1Encoding(new RsaEngine());
     
    9595        }
    9696
    97         public bool verifyRsaSignatureWithFlaw(string message, byte[] signature)
     97        public bool verifyRsaSignatureWithFlaw(byte[] message, byte[] signature)
    9898        {
    9999            BigInteger signatureBigInt = new BigInteger(1,signature);
    100             byte[] messageInBytes = Encoding.ASCII.GetBytes(message);          
     100            byte[] messageInBytes = message; 
    101101
    102102            RsaKeyParameters pubkeyParam = (RsaKeyParameters)RSAKeyManager.getInstance().getPubKey();
     
    133133            }
    134134
    135             // MD2, Digest length: 120 Bit
     135            // MD2, Digest length: 128 Bit
    136136            if(funcIdent == HashFunctionHandler.MD2)
    137137            {
    138                 return this.verifySigWithoutPad(block, messageInBytes, HashFunctionHandler.MD2, 15);
    139             }
    140 
    141             // MD5, Digest length: 120 Bit
     138                return this.verifySigWithoutPad(block, messageInBytes, HashFunctionHandler.MD2, 16);
     139            }
     140
     141            // MD5, Digest length: 128 Bit
    142142            if(funcIdent == HashFunctionHandler.MD5)
    143143            {
    144                 return this.verifySigWithoutPad(block, messageInBytes, HashFunctionHandler.MD5, 15);
     144                return this.verifySigWithoutPad(block, messageInBytes, HashFunctionHandler.MD5, 16);
    145145            }
    146146
     
    158158
    159159            IDigest hashFunctionDigest = DigestUtilities.GetDigest(hashFuncIdent.diplayName);
    160             byte[] hashDigestMessage = Hashfunction.generateHashDigest(message, hashFuncIdent);
     160            byte[] hashDigestMessage = Hashfunction.generateHashDigest(ref message, ref hashFuncIdent);
    161161
    162162            return this.compareByteArrays(hashDigestFromSig, hashDigestMessage);
  • trunk/PKCS1/PKCS1.csproj

    r1663 r1738  
    8181  </ItemGroup>
    8282  <ItemGroup>
     83    <Compile Include="BigNum\BigNum.cs" />
     84    <Compile Include="BigNum\BigNumDec.cs" />
    8385    <Compile Include="Library\BleichenbacherSignature.cs" />
    8486    <Compile Include="Library\GuiLogMsgHandOff.cs" />
     
    9092    <Compile Include="Library\HashFunctionHandler.cs" />
    9193    <Compile Include="Library\KuehnSignature.cs" />
     94    <Compile Include="Library\myFloat.cs" />
    9295    <Compile Include="Library\NavigationCommandType.cs" />
    9396    <Compile Include="Library\ParameterChangeType.cs" />
  • trunk/PKCS1/PKCS1Plugin.cs

    r1663 r1738  
    77using PKCS1.WpfVisualization;
    88using PKCS1.Library;
     9using Cryptool.PluginBase.Miscellaneous;
    910
    1011namespace PKCS1
     
    3940            if (OnGuiLogNotificationOccured != null)
    4041            {
    41                 OnGuiLogNotificationOccured(this, new GuiLogEventArgs(message, this, logLevel));
     42                OnGuiLogNotificationOccured(this, new GuiLogEventArgs(message, this, logLevel));               
    4243            }
     44           
     45            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, message, logLevel);
    4346        }
    4447
  • trunk/PKCS1/WpfControls/Components/DatablockControl.xaml.cs

    r1650 r1738  
    5555            if (ParameterChangeType.Message == type)
    5656            {
    57                 this.tbInputText.Text = Datablock.getInstance().Message;
     57                this.tbInputText.Text =  Encoding.ASCII.GetString(Datablock.getInstance().Message);
    5858                this.tbHashDigest.Text = Datablock.getInstance().GetHashDigestToHexString();
    5959            }
     
    105105
    106106            // Text setzen, Hash wird automatisch generiert, da in Datablock das Event getriggert wird und hier im Handling Hashgenerierung auslöst
    107             Datablock.getInstance().Message = textToHash;
     107            Datablock.getInstance().Message =  Encoding.ASCII.GetBytes(textToHash);
    108108            // Hash generieren und abfragen
    109109            //this.tbHashDigest.Text = Datablock.getInstance().GetHashDigestToHexString();
Note: See TracChangeset for help on using the changeset viewer.