# 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.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.