# Changeset 1744

Ignore:
Timestamp:
Jul 20, 2010, 4:25:24 PM (11 years ago)
Message:

some fixes and updated some help files

Location:
trunk/PKCS1
Files:
10 edited

Unmodified
Removed
• ## trunk/PKCS1/Library/MathFunctions.cs

 r1738 using Org.BouncyCastle.Math; using Emil.GMP; using PKCS1.BigNum; //using Emil.GMP; namespace PKCS1.Library class MathFunctions { // nur zum Test; nutzt Emil.GMP lib static public BigInteger cuberoot2(BigInteger radicant) { BigInt test = new BigInt(radicant.ToString()); BigInt returnBigInt = test.Root(3); return new BigInteger(returnBigInt.ToString()); } // Heron Algorithmus static public BigInteger cuberoot(BigInteger radicant) } return true; } /// /// Computes an approximate cube root of a number, /// by using the Newton approximation for next guess. /// /// The number to compute the cube root from. /// static public BigInteger cuberoot3(BigInteger BigIntRad) { BigNumDec y;               // Guess BigNumDec d;               // Last difference of y3 and x BigNumDec l;               // The limit for optimal guess // Check for simple cases: if (BigIntRad.Equals(BigInteger.Zero)) return BigInteger.Zero; else if (BigIntRad.Equals(BigInteger.One)) return BigInteger.One; else if (BigIntRad.Equals(BigInteger.ValueOf(-1))) return BigInteger.ValueOf(-1); else { BigNumDec x = new BigNumDec(BigIntRad.ToString()); //l = Math.Abs(x * 1E-14);                // Set the limit appropriately BigNumDec E = new BigNumDec("0.00000000000000000000000000000000000000000000000000000000000000000001"); l = BigNumDec.Multiply(x, E); // the multiplication with x (its magnitude) should // ensure no infinite loops, at the cost // of some precision on high numbers. // Make initial guess: //double g = Math.Abs(x);     // Do this guess on a positive number BigNumDec g = x; //if (g < BigInteger.One) //if (g.CompareTo(new BigNumDec(1)) < 1) if( g < new BigNumDec(1)) y = x; //else if (g < 10) //else if (g.CompareTo(new BigNumDec(10)) == -1) else if( g < 10) //y = x / 3; y = BigNumDec.Divide(x,new BigNumDec(3)); else if (g < 20) //y = x / 6; y = BigNumDec.Divide(x,new BigNumDec(6)); else if (g < 50) //y = x / 10; y = BigNumDec.Divide(x,new BigNumDec(10)); else if (g < 100) //y = x / 20; y = BigNumDec.Divide(x,new BigNumDec(20)); else if (g < 1000) //y = x / 50; y = BigNumDec.Divide(x,new BigNumDec(50)); else if (g < 5000) //y = x / 100; y = BigNumDec.Divide(x, new BigNumDec(100)); //else if (g < 10000) //else if (g.CompareTo(new BigNumDec(10000)) == -1) else if( g < 10000) //y = x / 500; y = BigNumDec.Divide(x,new BigNumDec(500)); else if (g < 50000) //y = x / 1000; y = BigNumDec.Divide(x, new BigNumDec(1000)); else if (g < 100000) //y = x / 50000; y = BigNumDec.Divide(x, new BigNumDec(50000)); else //y = x / 100000; y = BigNumDec.Divide(x,new BigNumDec(100000)); // Improve guess immediately: //y = ((x / (y * y)) + 2 * y) / 3;            // Newton's approx. for new guess y = BigNumDec.Divide( BigNumDec.Add( BigNumDec.Divide(x, BigNumDec.Multiply(y,y)) , BigNumDec.Multiply(new BigNumDec(2),y) ), new BigNumDec(3)); //d = Math.Abs(y * y * y - x);                // Calculate difference d = BigNumDec.Multiply( BigNumDec.Multiply(y,y), y); d = BigNumDec.Subtract( d, x); d.Absolute(); #region while (l < d) { //y = ((x / (y * y)) + 2 * y) / 3;        // Newton's approx. for new guess y = BigNumDec.Divide(BigNumDec.Add(BigNumDec.Divide(x, BigNumDec.Multiply(y, y)), BigNumDec.Multiply(new BigNumDec(2), y)), new BigNumDec(3)); //d = Math.Abs(y * y * y - x);                // Calculate difference d = BigNumDec.Multiply(BigNumDec.Multiply(y, y), y); d = BigNumDec.Subtract(d, x); d.Absolute(); } #endregion string test = y.ToString(); return BigInteger.Three; } }
• ## trunk/PKCS1/OnlineHelp/HelpFiles/Help.Designer.cs

 r1650 /// ///   Looks up a localized string similar to <h2>Bleichenbacher Signatur generieren</h2> ///In diesem Tab wird eine gefälschte Signatur generiert, welche in ver- und entschlüsselter Form dargestellt wird. ///Die Signatur, welche von fehlerhaften Implementierungen als valide erkannt wird, hat folgende Struktur: ///In diesem Tab wird eine gefälschte Signatur generiert, die in ver- und entschlüsselter Form dargestellt wird. ///Eine Signatur, die von fehlerhaften Implementierungen als valide erkannt wird, hat folgende Struktur: ///'00' '01' PS '00' HI HW GG. </br> ///Im Einzelnen bedeutet dies: ///<li> ///<strong>'00'</strong> ///Einleitender Nullblock (8 Bit). Dadurch wird gewährleistet dass der numerische Wert der Signatur kleiner ist als das ///<a href="help://KeyGen_Modu [rest of string was truncated]";. ///Einleitender Nullblock (8 Bit). Dadurch wird gewährleistet dass, der numerische Wert der Signatur kleiner ist als das ///<a href="help://KeyGen_ModulusS [rest of string was truncated]";. /// internal static string Gen_Bleichenb_Sig_Tab { ///<li> ///<strong>Hashfunction-Identifier<br /></strong> ///Der Hashfunction-Identifier ist ein ASN.1 codierter Datenblock der unter anderem Information wie z.B. den Namen der verwendeten Hashfunktion (Algorithmidentifier), die Länge des gesamten Datenblocks, und die Länge des Hashwertes beinhaltet.</br> ///Die Länge und der We [rest of string was truncated]";. ///Der Hashfunction-Identifier ist ein ASN.1-codierter Datenblock, der unter anderem Informationen wie den Namen der verwendeten Hashfunktion (Algorithmidentifier), die Länge des gesamten Datenblocks, und die Länge des Hashwertes beinhaltet.</br> ///Die Länge und der Wert [rest of string was truncated]";. /// internal static string Gen_Datablock_Tab { /// ///   Looks up a localized string similar to <h2>Kuehn Signatur generieren</h2> ///Ihre Wahl der Methode zur Faktorisierung  bestimmt die Laufzeit und den Resourcenverbrauch der Faktorisierung. ///<ul> ///<li> ///<strong>Probedivision<br /></strong> ///Die Probedivision ist das Verfahren mit der größen Laufzeit. Es benötig sehr viel Arbeitsspeicher und Prozessorzeit. ///Sollte nach 100.000 Versuchen kein Faktor gefunden werden, wird das Verfahren automatisch beendet. ///</li> ///</ul> ///. ///In diesem Tab können gefälschte Signaturen, nach der Methode wie sie Ulrich Kühn beschrieben hat, erstellt werden. ///Die Signaturen ähneln in der Struktur denen von <a href="help://Gen_Bleichenb_Sig_Tab">Bleichenbacher</a>, machen sich jedoch die Rechenkraft von ///Computern zu nutze und sind auch auf Signaturen von 1024 Bit Länge anwendbar. Auch hier liegt folgende Struktur zugrunde: '00' '01' PS '00' HI HW GG. </br> /// ///Die Unterschiede zu den Bleichenbacher Signaturen sind [rest of string was truncated]";. /// internal static string Gen_Kuehn_Iterations { get { return ResourceManager.GetString("Gen_Kuehn_Iterations", resourceCulture); } } /// ///   Looks up a localized string similar to <h2>Kuehn Signatur generieren</h2> ///In diesem Tab können gefälschte Signaturen, nach der Methode wie sie Ulrich Kühn beschrieben hat, erstellt werden. ///Die Signaturen ähneln in der Struktur denen von <a href="help://Gen_Bleichenb_Sig_Tab">Bleichenbacher</a>, machen sich jedoch die Rechenkraft von ///Computern zu nutze und sind auch auf Signaturen von 1024 Bit Länge anwendbar. Auch hier liegt folgende Struktur zugrunde: '00' '01' PS '00' HI HW GG. </br> /// ///Die Unterschiede zu den Bleichenbacher Signaturen sind [rest of string was truncated]";. /// internal static string Gen_Kuehn_Sig_Tab { /// ///   Looks up a localized string similar to <h2>Signatur generieren</h2> ///In diesem Tab wird die komplette PKCS #1-Signatur erstellt. Die Signatur hat folgende Struktur: '00' '01' PS '00' HI HW. </br> ///In diesem Tab wird die komplette PKCS#1-Signatur erstellt. Die Signatur hat folgende Struktur: '00' '01' PS '00' HI HW. </br> ///Im Einzelnen bedeutet dies: ///<ul> ///<li> ///<strong>'01'</strong> ///Block Type. Dieser Block gibt an ob es sich um eine Verschlüsselung mit dem privat [rest of string was truncated]";. ///Block Type. Dieser Block gibt an, ob es sich um eine Operation mit dem privaten ode [rest of string was truncated]";. /// internal static string Gen_PKCS1_Sig_Tab { /// ///   Looks up a localized string similar to <h2>RSA-Schlüsselgenerierung</h2> ///Um PKCS #1-Signaturen generieren und validieren zu können ist ein RSA-Schlüsselpaar notwendig. Dieses besteht aus einem privaten und einem öffentlichen Schlüssel, sowie einem sog. RSA-Modul welches bei Beiden Schlüsseln gleich ist.</br> ///Da für die hier dargestellten Angriffe auf die PKCS #1-Signaturen der Wert des öffentlichen Schlüssels und die Länge des Moduls (in Bit) wichtig sind, können hier diese Parameter eingegeben werden. Der öffentliche Schlüssel, sowie das Modu [rest of string was truncated]";. ///Um PKCS#1-Signaturen erzeugen und validieren zu können, ist ein RSA-Schlüsselpaar notwendig. Dieses besteht aus einem privaten und einem öffentlichen Schlüssel, sowie einem sog. RSA-Modul, der bei beiden Schlüsseln gleich ist.</br> ///Für die hier dargestellten Angriffe auf die PKCS#1-Signaturen sind der Wert des öffentlichen Schlüssels und die Länge des Moduls (in Bit) wichtig. Diese Parameter können hier konfiguriert werden. Der öffentliche Schlüssel sowie der Modul werden [rest of string was truncated]";. /// internal static string KeyGen { /// ///   Looks up a localized string similar to <h2>RSA-Modul</h2> ///Das Modul ist Bestandteil eines RSA-Schlüsselpaares und in dem öffentlichen und privaten Schlüssel gleich. </br> ///Der Modul ist Teil des öffentlichen RSA-Schlüssels. Der Modul wird auch bei der Operation mit dem privaten Schlüssel gebraucht.</br> /// ///Da für die Angriffe auf die PKCS #1-Signaturen nicht der Wert, sondern nur die Länge in Bit nötig ist, kann hier die Länge angegeben werden und es wird ein Modul erzeugt. ///Da für die Angriffe auf die PKCS#1-Signaturen nicht der Wert, sondern nur die Länge in Bit nötig ist, kann hier die Länge angegeben werden und es wird ein Modul erzeugt. ///In dem Bleichenbacher Angriff wurde von einer Bitlänge des Moduls von 3072 ausgegangen. Bei den Angriffen mit kürzeren Schlüsseln kann hier die Schlüssellänge reduziert werden. ///. /// ///   Looks up a localized string similar to <h2>RSA öffentlicher Schlüssel</h2> ///Der öffentliche Schlüssel (public Key) des RSA-Schlüsselpaares wird genutzt, um die mit dem privaten Schlüssel ///verschlüsselten, Signaturen zu entschlüsseln. Aus Performance Gründen wird gewöhnlich ein Schlüssel mit einem geringen ///Hamming-Gewicht genutzt (z.B. 3, 17 oder 65537). Voraussetzung für den Bleichenbacher Angriff ist, dass der ///Der öffentliche Schlüssel (public key) des RSA-Schlüsselpaares wird genutzt, um die mit dem privaten Schlüssel ///erstellten Signaturen zu validieren. Aus Performance-Gründen wird gewöhnlich ein öffentlicher Schlüssel mit einem geringen ///Hamming-Gewicht genutzt (z.B. 3, 17 oder 65537). Voraussetzung für den Bleichenbacher Angriff ist der spezielle Fall, dass der ///öffentliche Schlüssel drei ist. /// ///. /// /// ///   Looks up a localized string similar to <h2>PKCS #1-Signaturgenerierung</h2> ///<strong>Um PKCS#1 Signaturen erzeugen zu können muss zuerst ein RSA-Schlüsselpaar, in der entsprechenden Maske, /// generiert werden</strong></br> /// <strong>Es muss zuerst der Datenblock generiert werden, bevor die komplette Signatur generiert werden kann!</strong> ///<strong>Um PKCS#1-Signaturen erzeugen zu können, muss zuerst ein RSA-Schlüsselpaar in der entsprechenden Maske /// erzeugt werden</strong></br> /// <strong>Zuerst muss der Datenblock erzeugt werden, bevor die komplette Signatur generiert werden kann!</strong> /// </br></br> ///Die PKCS #1-Signaturen basieren auf dem asymetrischen Verschlüsselungsalgorithmus RSA. Daher ist es notwendig einen ///RSA-Schlüssel zu generieren.</br> ///Um eine PKCS#1-Signatur zu generieren wird z [rest of string was truncated]";. ///Die PKCS#1-Signaturen basieren auf dem asymmetrischen Verschlüsselungsalgorithmus RSA. Daher ist es notwendig, einen ///RSA-Schlüssel zu erzeugen.</br> ///Um eine PKCS#1-Signatur zu erzeugen, wird zunächst de [rest of string was truncated]";. /// internal static string SigGen { /// ///   Looks up a localized string similar to <h2>Bleichenbacher Angriff</h2> ///<strong>Um den Bleichenbacher Angriff durchführen zu können, muss zuerst ein RSA-Schlüsselpaar, ///in der entsprechenden Maske, generiert werden</strong></br> /// <strong>Es muss zuerst der Datenblock generiert werden, bevor die komplette Signatur generiert werden kann!</strong> ///<strong>Um den Bleichenbacher Angriff durchführen zu können, muss zuerst ein RSA-Schlüsselpaar in der entsprechenden Maske erzeugt werden</strong></br> /// <strong>Zuerst muss der Datenblock erzeugt werden, bevor die komplette Signatur generiert werden kann!</strong> /// </br></br> /// Um eine gefälschte Signatur zu generieren wird zunächste der <a href="help://Gen_Datablock_Tab">Datenblock</a> wie in /// einer regulären PKCS#1-Signatur generiert. Allerdings unterscheidet [rest of string was truncated]";. /// Um eine gefälschte Signatur zu erzeugen, wird zunächst der <a href="help://Gen_Datablock_Tab">Datenblock</a> wie in /// einer regulären PKCS#1-Signatur generiert. Allerdings unterscheidet sich die <a  [rest of string was truncated]";. /// internal static string SigGenFakeBleichenbacher { /// ///   Looks up a localized string similar to <h2>Kühn</h2> ///Ihre Wahl der Methode zur Faktorisierung  bestimmt die Laufzeit und den Resourcenverbrauch der Faktorisierung. ///<ul> ///<li> ///<strong>Probedivision<br /></strong> ///Die Probedivision ist das Verfahren mit der größen Laufzeit. Es benötig sehr viel Arbeitsspeicher und Prozessorzeit. ///Sollte nach 100.000 Versuchen kein Faktor gefunden werden, wird das Verfahren automatisch beendet. ///</li> ///</ul> ///. ///   Looks up a localized string similar to <h2>Angriff mit kuerzeren Schlüsseln</h2> ///<strong>Um den Angriff mit kuerzeren Schlüsseln durchführen zu können, muss zuerst ein RSA-Schlüsselpaar in der entsprechenden Maske erzeugt werden</strong></br> ///<strong>Zuerst muss der Datenblock erzeugt werden, bevor die komplette Signatur generiert werden kann!</strong> ///</br> ///</br> ///Um eine gefälschte Signatur nach der Kuehn Methode zu erzeugen, wird zunächst der <a href="help://Gen_Datablock_Tab">Datenblock</a> generiert. Dies ///ist gleich zu dem Datenblock e [rest of string was truncated]";. /// internal static string SigGenFakeKuehn { /// ///   Looks up a localized string similar to <h2>Signaturvalidierung</h2> ///Zur Validierung von PKCS #1-Signaturen werden diese Signaturen zunächst mit dem öffentlichen Schlüssel entschlüsselt. ///Die entschlüsselte Signatur sollte eine Struktur wie <a href="help://Gen_PKCS1_Sig_Tab">hier</a> beschrieben, aufweisen. ///Bei der Validierung wird als nächster Schritt der <a href="help://Gen_Datablock_Tab">Datenblock</a> ausgelesen.</br> ///Dieses extrahieren des Datenblock kann auf eine korrekte oder fehlerhafte Art und Weise geschehen. Die fehlerhafte ///Impleme [rest of string was truncated]";. ///Bei der Validierung einer PKCS#1-Signatur wird eine Operation mit dem öffentlichen Schlüssel durchgeführt. ///Das Ergebnis dieser Operation sollte eine Struktur aufweisen, wie <a href="help://Gen_PKCS1_Sig_Tab">hier</a> beschrieben. ///Als nächster Schritt wird der <a href="help://Gen_Datablock_Tab">Datenblock</a> ausgelesen.</br> ///Dieses Extrahieren des Datenblock kann auf eine korrekte oder auf eine fehlerhafte Art und Weise geschehen. Die fehlerhafte ///Implementierung war bis zum [rest of string was truncated]";. /// internal static string SigVal { ///     </head> ///     <body> ///     <h2>PKCS#1 Signaturen / Bleichenbacher Angriff</h2> ///     <h2>PKCS#1-Signaturen / Bleichenbacher Angriff</h2> ///     <p align="justify"> ///     PKCS#1 Signaturen basieren auf dem RSA Verschlüsselungsverfahren. Der Angriff von Daniel Bleichenbacher zielt nicht ///     PKCS#1-Signaturen basieren auf dem RSA-Verschlüsselungsverfahren. Der Angriff von Daniel Bleichenbacher zielt nicht ///     auf das Verschlüsselungsverfahren selbst, sondern auf Implementierung [rest of string was truncated]";. /// /// ///   Looks up a localized string similar to <h2>PKCS #1 / Bleichenbacher Angriff - Hilfe</h2> ///   Looks up a localized string similar to <h2>PKCS#1 / Bleichenbacher Angriff - Hilfe</h2> ///Willkommen in der Hilfe des PKCS#1 / Bleichenbacher Angriff Plugins.</br> ///Hier finden Sie detaillierte Informationen zu PKCS#1 Signaturen und dem Bleichenbacher Angriff.</br></br> ///In die verschiedenen Masken dieses Plugins gelangen Sie indem Sie die Navigation auf der linken Seite nutzen. In den verschiedenen Masken ///wiederum finden Sie mehrere Hilfebuttons. Wenn Sie auf diese klicken, bekommen Sie detailierte Informationen über das jeweilige Thema. ///Hier finden Sie detaillierte Informationen zu PKCS#1-Signaturen und dem Bleichenbacher Angriff.</br></br> ///In die verschiedenen Masken dieses Plugins gelangen Sie mit Hilfe der Navigation auf der linken Seite. In den verschiedenen Masken ///wiederum finden Sie mehrere Hilfebuttons. Wenn Sie auf diese klicken, bekommen Sie detaillierte Informationen über das jeweilige Thema. ///. ///
• ## trunk/PKCS1/OnlineHelp/HelpFiles/Help.resx

 r1650 System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 de\gen_bleichenb_sig_tab.html;System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8 de\gen_datablock_tab.html;System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8 de\gen_kuehn_iterations.html;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8
• ## trunk/PKCS1/OnlineHelp/HelpFiles/de/Gen_Kuehn_Sig_Tab.html

 r1743 ﻿

Kuehn Signatur generieren

In diesem Tab können Signaturen gefälscht werden nach der Methode wie sie Ulrich Kühn beschrieben hat. Die Signaturen ähneln denen von Bleichenbacher In diesem Tab können gefälschte Signaturen, nach der Methode wie sie Ulrich Kühn beschrieben hat, erstellt werden. Die Signaturen ähneln in der Struktur denen von Bleichenbacher, machen sich jedoch die Rechenkraft von Computern zu nutze und sind auch auf Signaturen von 1024 Bit Länge anwendbar. Auch hier liegt folgende Struktur zugrunde: '00' '01' PS '00' HI HW GG.
Position nicht wählbar sondern XX Byte als Padding werden genutzt, das kürzest mögliche. Garbage == FF und nicht berechnet wie bei Bleichenbacher. Bei dieser Implementierung ist die Signatur schon nach dem Kubikwurzelziehen dargestellt, daher kann der dargestellte Garbage von dem FF Schema abweichen. 1024 Bit Signaturen möglich. Solange probieren bis dass die Berechnung der dritten Wurzel und das Potenzieren das gleiche Ergebnis liefern. Dabei werden nur die 46 signifikanten Bytes (von links) verglichen, da sich hier der Paddingstring, Hashidentifier und Hashwert befinden. Fehlerhafte Implementierungen der Verifikation vergleichen auch nur diese Bytes und der Rest wird nicht beachtet. Die Unterschiede zu den Bleichenbacher Signaturen sind im Folgenden erläutert:
• Der Paddingstring hat eine feste Länge von acht Byte (64 Bit). Diese Länge wurde gewählt, da einige fehlerhaften Implementierungen verschiedene Längen des Paddingstring voraussetzten. Maximal wurden jedoch acht Byte benötigt. Somit ist auch die Position des Hash-Identifiers (HI) und des Hashwertes (HW) fix.
• Der angehängte Garbage wird nicht berechnet, sondern es werden einfach die restlichen Oktetts mit 'FF' (hexadezimal 0xff) aufgefüllt.
Da oft die Kubikwurzel berechnet werden muss, kann es lange dauern. (Limit von 25000 einstellbar) Da der Garbage (GG) nicht berechnet wird, ist eine gefälschte Signatur nicht nur durch Kubikwurzelziehen zu erlangen. Der Ansatz von Kuehn ist, dass man von der oben beschriebenen Struktur die Kubikwurzel zieht und das Ergebnis mit drei potenziert. Vom dem Ergebnis aus der Potenzberechnung wiederum vergleicht man die ersten 46 Bytes (von links) mit der zuvor erstellten Struktur. Die 46 Bytes beinhalten:
• '00' '01' Die führenden Oktetts - 2 Byte Länge
• PS Den Paddingstring - 8 Byte Länge
• '00' Das trennende Null Oktett - 1 Byte Länge
• HI Den Hash-Identifier - 15 Byte Länge (SHA-1)
• HW Den Hashwert - 20 Byte Länge (SHA-1)
Stimmen die signifikanten 46 Bytes nicht überein, werden die zu signierenden Daten abgeändert. Dadurch ergibt sich ein anderer Hashwert und es wird erneut die Kubikwurzel berechnet, das Ergebnis potenziert und verglichen. Somit wird getestet, ob der Hash-Identifier und der Hashwert beim Kubikwurzelziehen und anschließendem Potenzieren unverändert bleibt. Werden beim Vergleich keine Unterschiede der 46 Bytes erkannt, wird die erstellte Signatur von fehlerhaften Implementierungen als korrekt betrachtet.
Da bei jeder Iteration des Algorithmus aufwendige Berechnungen wie Kubikwurzelziehen und Hashwert berechnen durchgeführt werden, kann eine lange Laufzeit zustande kommen. Um dies zu begrenzen kann ein Limit an Iterationen angegeben werden (Eingabefeld "Max. Anzahl an Iterationen").

Die Darstellung der unverschlüsselten Signatur in diesem Tab stellt die Signatur nach dem Potenzieren der verschlüsselten Signatur dar, so dass es dazu kommen kann, dass der Garbage nicht wie oben beschrieben nur aus 'FF'-Oktetten bestehen.
• ## trunk/PKCS1/OnlineHelp/HelpFiles/de/SigGenFakeKuehn.html

 r1659 ﻿

Kühn

Hier fehlt noch Text ﻿

Angriff mit kuerzeren Schlüsseln

Um den Angriff mit kuerzeren Schlüsseln durchführen zu können, muss zuerst ein RSA-Schlüsselpaar in der entsprechenden Maske erzeugt werden
Zuerst muss der Datenblock erzeugt werden, bevor die komplette Signatur generiert werden kann!

Um eine gefälschte Signatur nach der Kuehn Methode zu erzeugen, wird zunächst der Datenblock generiert. Dies ist gleich zu dem Datenblock einer regulären PKCS#1-Signatur. Allerdings unterscheidet sich die Struktur der gefälschten Signatur in folgenden Punkten:
• Der Padding-String wird verkürzt. Somit findet sich der Datenblock weiter links in der Signatur. Fehlerhafte Implementierungen der Validierung von Signaturen erkennen dies nicht. Bei Kuehn wird die Länge des Paddingstring fix gewählt (46 Byte, wenn SHA-1 als Hashalgorithmus gewählt wird)
• Der ungenutzte Platz am Ende der Signatur wird mit dem sog. Garbage, aufgefüllt. Der Garbage besteht aus Oketetten mit dem Wert 'FF' (hexadezimal 0xff).
• ## trunk/PKCS1/OnlineHelp/OnlineHelpActions.cs

 r1650 Gen_Bleichenb_Sig_Tab, Gen_Kuehn_Sig_Tab, Gen_Kuehn_Iterations, KeyGen_PubExponent, KeyGen_ModulusSize,
• ## trunk/PKCS1/PKCS1.csproj

 r1743 ..\..\CrypBuild\x86\Debug\CrypPluginBase.dll False .\Emil.GMP.dll 3.0 Designer Designer Designer Designer Designer Designer Designer
• ## trunk/PKCS1/WpfControls/Components/SigGenKuehnControl.xaml

 r1743
• ## trunk/PKCS1/WpfControls/Components/SigGenKuehnControl.xaml.cs

 r1743 public partial class SigGenKuehnControl : UserControl { private KuehnSignature m_signature = new KuehnSignature(); private KuehnSignature m_signature = (KuehnSignature)SignatureHandler.getInstance().getKuehnSig(); public KuehnSignature Signature { Cursor = Cursors.Wait; this.Signature = (KuehnSignature)SignatureHandler.getInstance().getKuehnSig(); //this.Signature = (KuehnSignature)SignatureHandler.getInstance().getKuehnSig(); if (this.Signature.GenerateSignature()) else { this.tbError.Text = "Es ist ein Fehler aufgetreten. Signatur konnte nicht erstellt werden."; this.tbError.Text = "Signatur konnte nicht erstellt werden. Es ist das Limit an Iterationen erreicht worden."; } this.lblSignatureLength.Content = "(Länge: " + UserControlHelper.GetRtbTextLength(this.rtbResult) * 4 + " bit)"; } private void btn_Help_MouseLeftButtonDown(object sender, MouseButtonEventArgs e) { if (sender == btnHelpIterations) { OnlineHelp.OnlineHelpAccess.ShowOnlineHelp(PKCS1.OnlineHelp.OnlineHelpActions.Gen_Kuehn_Iterations); } e.Handled = true; } } }
• ## trunk/PKCS1/WpfControls/Start.htm

 r1663 Implementierungen sollten diese fehlerhafte Validierung nicht mehr beinhalten.

Angriff mit kürzeren Schlüsseln (Kühn Angriff)
Im Gegensatz zum Bleichenbacher Angriff (3072 Bit lange Schlüssel) zielt der Angriff von Kühn auf kürzere Schlüssel (1024 Bit Länge). Dieser Angriff macht sich die Rechenkraft von Computer zunutze. Hier wird nicht berechnet wie eine gefälschte Signatur aussehen muss, sondern es wird ein Algorithmus durchlaufen, bis das entsprechende Ergebnis generiert ist.

Note: See TracChangeset for help on using the changeset viewer.