Ejemplo n.º 1
0
 public static Datablock getInstance()
 {
     if (instance == null)
     {
         instance = new Datablock();
     }
     return(instance);
 }
Ejemplo n.º 2
0
        private byte[] getCompleteHw()
        {
            byte[]            bDerHashIdent = Hex.Decode(Datablock.getInstance().HashFunctionIdent.DERIdent);
            byte[]            bMessage      = Datablock.getInstance().Message;
            HashFunctionIdent hashIdent     = Datablock.getInstance().HashFunctionIdent;

            byte[] hashDigest  = Hashfunction.generateHashDigest(ref bMessage, ref hashIdent);
            byte[] returnArray = new byte[bDerHashIdent.Length + Hashfunction.getDigestSize()];
            Array.Copy(bDerHashIdent, 0, returnArray, 0, bDerHashIdent.Length);
            Array.Copy(hashDigest, 0, returnArray, returnArray.Length - hashDigest.Length, hashDigest.Length);

            return(returnArray);
        }
Ejemplo n.º 3
0
 protected Signature()
 {
     Datablock.getInstance().RaiseParamChangedEvent += handleParamChanged;
 }
Ejemplo n.º 4
0
        public override bool GenerateSignature()
        {
            this.SendGuiLogMsg("Message Generation started", NotificationLevel.Info);

            this.m_KeyLength = RsaKey.Instance.RsaKeySize;

            int        hashDigestLength = Hashfunction.getDigestSize() * 8;                              // weil Size in Byte zurückgegeben wird
            int        hashIdentLength  = Datablock.getInstance().HashFunctionIdent.DERIdent.Length * 4; // weil ein zeichen im string = 4 bit
            int        keyLength        = this.m_KeyLength;
            BigInteger derIdent         = new BigInteger(Datablock.getInstance().HashFunctionIdent.DERIdent, 16);
            BigInteger datablockLength  = BigInteger.ValueOf(hashDigestLength + hashIdentLength + 8); // Länge Datenblock inkl 0-Byte (=8Bit)

            bool       isDivByThree = false;
            BigInteger N            = null;
            BigInteger datablock    = null;

            while (false == isDivByThree)
            {
                byte[]            bMessage   = Datablock.getInstance().Message;
                HashFunctionIdent hashIdent  = Datablock.getInstance().HashFunctionIdent;
                BigInteger        hashDigest = new BigInteger(1, Hashfunction.generateHashDigest(ref bMessage, ref hashIdent));
                // T*2^160 + H
                datablock = derIdent.Multiply(BigInteger.Two.Pow(hashDigestLength)).Add(hashDigest); // Datablock erstellen; T=HashFuncIdent; H=HashDigest
                N         = (BigInteger.Two.Pow(datablockLength.IntValue)).Subtract(datablock);      // N muss vielfaches von 3 sein

                if (0 == (N.Mod(BigInteger.Three)).IntValue)
                {
                    isDivByThree = true;
                }
                else
                {
                    byte[] extSign = Encoding.ASCII.GetBytes(ChangeSign);
                    byte[] tmp     = new byte[Datablock.getInstance().Message.Length + extSign.Length];
                    Array.Copy(Datablock.getInstance().Message, tmp, Datablock.getInstance().Message.Length);
                    Array.Copy(extSign, 0, tmp, Datablock.getInstance().Message.Length, extSign.Length);
                    Datablock.getInstance().Message = tmp;
                }
            }

            BigInteger sigLengthWithoutZeros = BigInteger.ValueOf(this.m_KeyLength - 15); // 15 weil die ersten 15 bit 0 sind
            BigInteger startPos          = BigInteger.ValueOf(this.m_dataBlockStartPos);
            BigInteger endPos            = startPos.Add(datablockLength);
            BigInteger sigLengthDivThree = sigLengthWithoutZeros.Divide(BigInteger.Three);

            BigInteger testbeta = endPos.Subtract(BigInteger.Two.Multiply(sigLengthDivThree)).Subtract(datablockLength); // sollte 34 seinbei keylength 3072

            //2^3057 - 2^ (2038 + 288 + 34) == 2^3057 - 2^2360
            BigInteger fakeSig = (BigInteger.Two.Pow(sigLengthWithoutZeros.IntValue)).Subtract(BigInteger.Two.Pow(2 * sigLengthDivThree.IntValue + datablockLength.IntValue + testbeta.IntValue));

            // 2^3057 - 2^2360 + 2^2072 * N
            fakeSig = fakeSig.Add((BigInteger.Two.Pow(startPos.IntValue)).Multiply(datablock));
            fakeSig = fakeSig.Add(BigInteger.Two.Pow(startPos.IntValue - 8).Multiply(BigInteger.ValueOf(125))); // add garbage

            BigInteger fakeSigResult = MathFunctions.cuberoot(fakeSig);

            byte[] returnByteArray = new byte[this.m_KeyLength / 8]; // KeyLength is in bit
            Array.Copy(fakeSigResult.ToByteArray(), 0, returnByteArray, returnByteArray.Length - fakeSigResult.ToByteArray().Length, fakeSigResult.ToByteArray().Length);

            this.m_Signature     = returnByteArray;
            this.m_bSigGenerated = true;
            this.OnRaiseSigGenEvent(SignatureType.Bleichenbacher);
            return(true);
        }
Ejemplo n.º 5
0
        public override bool GenerateSignature()
        {
            this.m_KeyLength = RsaKey.Instance.RsaKeySize; // Länge des RSA Modulus

            // drei Leerzeichen an Msg anhängen
            string sMsgModifier = "   ";

            byte[] bMsgModifier = Encoding.ASCII.GetBytes(sMsgModifier);
            byte[] bMessage     = new byte[Datablock.getInstance().Message.Length + bMsgModifier.Length];
            Array.Copy(Datablock.getInstance().Message, bMessage, Datablock.getInstance().Message.Length);
            Array.Copy(bMsgModifier, 0, bMessage, Datablock.getInstance().Message.Length, bMsgModifier.Length);

            HashFunctionIdent hashFuncIdent = Datablock.getInstance().HashFunctionIdent;                // Die vom User gewählte Hashfunktion

            byte[] hashIdent             = Hex.Decode(Encoding.ASCII.GetBytes(hashFuncIdent.DERIdent)); // ASN.1 codierter Ident-string
            int    significantByteLength = 11 + hashIdent.Length + hashFuncIdent.digestLength / 8;

            // Datenblock wird konstruiert
            byte[] A = new byte[significantByteLength];
            A[0] = 0x00;
            A[1] = 0x01;
            for (int i = 2; i < 10; i++)
            {
                A[i] = 0xFF;
            }
            A[10] = 0x00;
            Array.Copy(hashIdent, 0, A, 11, hashIdent.Length);
            // Datenblock noch ohne Hashwert, wird in while Schleife unten hinzugefügt

            // byte array der kompletten Signatur, wird zuerst mit 'FF' gefüllt und dann nachher Datenblock an den Anfang kopiert
            byte[] S = new byte[this.m_KeyLength / 8];
            for (int i = A.Length; i < S.Length; i++)
            {
                S[i] = 0xFF;
            }

            BigInteger finalSignature = null;
            int        iMsgLength     = bMessage.Length;
            bool       isEqual        = false;
            int        countLoops     = 0;

            this.SendGuiLogMsg("Signature Generation started", NotificationLevel.Info);
            byte[]     hashDigest = new byte[0];         // Hashwert wird in dieser var gespeichert
            BigInteger T          = new BigInteger("0"); // hilfsvar

            byte[] resultArray = new byte[this.m_KeyLength / 8];

            while (!isEqual && (countLoops < this.m_Iterations))
            {
                hashDigest = Hashfunction.generateHashDigest(ref bMessage, ref hashFuncIdent); // Hashwert wird erzeugt
                Array.Copy(hashDigest, 0, A, 11 + hashIdent.Length, hashDigest.Length);        // erzeugter Hashwert wird in den Datenblock kopiert
                Array.Copy(A, 0, S, 0, A.Length);                                              // erzeugter Datenblock wird in erzeugte Signatur S kopiert

                finalSignature = MathFunctions.cuberoot4(new BigInteger(S), this.m_KeyLength); // Kubikwurzel ziehen
                byte[] test2 = finalSignature.ToByteArray();
                T = finalSignature.Pow(3);                                                     // mit 3 potenzieren
                byte[] test = T.ToByteArray();
                resultArray[0] = 0x00;                                                         // erstes byte is 0
                // durch Konvertierung in BigInteger werden führende Nullen abgeschnitten, daher wird an Stelle 1 in byte array kopiert.
                Array.Copy(T.ToByteArray(), 0, resultArray, 1, T.ToByteArray().Length);

                isEqual = MathFunctions.compareByteArray(ref resultArray, ref S, significantByteLength); // byte arrays vergleichen, wird in meinen Tests nicht erreicht
                if (!isEqual)
                {
                    int value1 = bMessage[iMsgLength - 1];
                    if (++value1 >= 256)
                    {
                        value1 = 0;
                        int value2 = bMessage[iMsgLength - 2];
                        if (++value2 >= 256)
                        {
                            value2 = 0;
                            int value3 = bMessage[iMsgLength - 3];
                            ++value3;
                            bMessage[iMsgLength - 3] = (byte)value3;
                        }
                        bMessage[iMsgLength - 2] = (byte)value2;
                    }
                    bMessage[iMsgLength - 1] = (byte)value1;

                    countLoops++;
                }
            }
            if (countLoops != this.m_Iterations)
            {
                Datablock.getInstance().Message = bMessage;
                byte[] returnByteArray          = new byte[this.m_KeyLength / 8];
                Array.Copy(finalSignature.ToByteArray(), 0, returnByteArray, returnByteArray.Length - finalSignature.ToByteArray().Length, finalSignature.ToByteArray().Length);

                this.m_Signature     = returnByteArray;
                this.m_bSigGenerated = true;
                this.OnRaiseSigGenEvent(SignatureType.Kuehn);
                return(true);
            }
            else
            {
                this.m_bSigGenerated = false;
            }
            return(false);
        }