Changeset 1744


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

some fixes and updated some help files

Location:
trunk/PKCS1
Files:
1 added
10 edited

Legend:

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

    r1738 r1744  
    55using Org.BouncyCastle.Math;
    66
    7 using Emil.GMP;
    8 using PKCS1.BigNum;
     7//using Emil.GMP;
    98
    109namespace PKCS1.Library
     
    1211    class MathFunctions
    1312    {
    14         // nur zum Test; nutzt Emil.GMP lib
    15         static public BigInteger cuberoot2(BigInteger radicant)
    16         {
    17             BigInt test = new BigInt(radicant.ToString());
    18             BigInt returnBigInt = test.Root(3);
    19             return new BigInteger(returnBigInt.ToString());
    20         }
    21 
    2213        // Heron Algorithmus
    2314        static public BigInteger cuberoot(BigInteger radicant)
     
    5748            }
    5849            return true;
    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)
    145                 {
    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();
    152                 }
    153                 #endregion
    154 
    155                 string test = y.ToString();
    156 
    157                 return BigInteger.Three;
    158             }
    15950        }
    16051
  • trunk/PKCS1/OnlineHelp/HelpFiles/Help.Designer.cs

    r1650 r1744  
    6363        /// <summary>
    6464        ///   Looks up a localized string similar to &lt;h2&gt;Bleichenbacher Signatur generieren&lt;/h2&gt;
    65         ///In diesem Tab wird eine gefälschte Signatur generiert, welche in ver- und entschlüsselter Form dargestellt wird.
    66         ///Die Signatur, welche von fehlerhaften Implementierungen als valide erkannt wird, hat folgende Struktur:
     65        ///In diesem Tab wird eine gefälschte Signatur generiert, die in ver- und entschlüsselter Form dargestellt wird.
     66        ///Eine Signatur, die von fehlerhaften Implementierungen als valide erkannt wird, hat folgende Struktur:
    6767        ///&apos;00&apos; &apos;01&apos; PS &apos;00&apos; HI HW GG. &lt;/br&gt;
    6868        ///Im Einzelnen bedeutet dies:
     
    7070        ///&lt;li&gt;
    7171        ///&lt;strong&gt;&apos;00&apos;&lt;/strong&gt;
    72         ///Einleitender Nullblock (8 Bit). Dadurch wird gewährleistet dass der numerische Wert der Signatur kleiner ist als das
    73         ///&lt;a href=&quot;help://KeyGen_Modu [rest of string was truncated]&quot;;.
     72        ///Einleitender Nullblock (8 Bit). Dadurch wird gewährleistet dass, der numerische Wert der Signatur kleiner ist als das
     73        ///&lt;a href=&quot;help://KeyGen_ModulusS [rest of string was truncated]&quot;;.
    7474        /// </summary>
    7575        internal static string Gen_Bleichenb_Sig_Tab {
     
    8585        ///&lt;li&gt;
    8686        ///&lt;strong&gt;Hashfunction-Identifier&lt;br /&gt;&lt;/strong&gt;
    87         ///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.&lt;/br&gt;
    88         ///Die Länge und der We [rest of string was truncated]&quot;;.
     87        ///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.&lt;/br&gt;
     88        ///Die Länge und der Wert [rest of string was truncated]&quot;;.
    8989        /// </summary>
    9090        internal static string Gen_Datablock_Tab {
     
    9696        /// <summary>
    9797        ///   Looks up a localized string similar to &lt;h2&gt;Kuehn Signatur generieren&lt;/h2&gt;
    98         ///Ihre Wahl der Methode zur Faktorisierung  bestimmt die Laufzeit und den Resourcenverbrauch der Faktorisierung.
    99         ///&lt;ul&gt;
    100         ///&lt;li&gt;
    101         ///&lt;strong&gt;Probedivision&lt;br /&gt;&lt;/strong&gt;
    102         ///Die Probedivision ist das Verfahren mit der größen Laufzeit. Es benötig sehr viel Arbeitsspeicher und Prozessorzeit.
    103         ///Sollte nach 100.000 Versuchen kein Faktor gefunden werden, wird das Verfahren automatisch beendet.
    104         ///&lt;/li&gt;
    105         ///&lt;/ul&gt;
    106         ///.
     98        ///In diesem Tab können gefälschte Signaturen, nach der Methode wie sie Ulrich Kühn beschrieben hat, erstellt werden.
     99        ///Die Signaturen ähneln in der Struktur denen von &lt;a href=&quot;help://Gen_Bleichenb_Sig_Tab&quot;&gt;Bleichenbacher&lt;/a&gt;, machen sich jedoch die Rechenkraft von
     100        ///Computern zu nutze und sind auch auf Signaturen von 1024 Bit Länge anwendbar. Auch hier liegt folgende Struktur zugrunde: &apos;00&apos; &apos;01&apos; PS &apos;00&apos; HI HW GG. &lt;/br&gt;
     101        ///
     102        ///Die Unterschiede zu den Bleichenbacher Signaturen sind [rest of string was truncated]&quot;;.
     103        /// </summary>
     104        internal static string Gen_Kuehn_Iterations {
     105            get {
     106                return ResourceManager.GetString("Gen_Kuehn_Iterations", resourceCulture);
     107            }
     108        }
     109       
     110        /// <summary>
     111        ///   Looks up a localized string similar to &lt;h2&gt;Kuehn Signatur generieren&lt;/h2&gt;
     112        ///In diesem Tab können gefälschte Signaturen, nach der Methode wie sie Ulrich Kühn beschrieben hat, erstellt werden.
     113        ///Die Signaturen ähneln in der Struktur denen von &lt;a href=&quot;help://Gen_Bleichenb_Sig_Tab&quot;&gt;Bleichenbacher&lt;/a&gt;, machen sich jedoch die Rechenkraft von
     114        ///Computern zu nutze und sind auch auf Signaturen von 1024 Bit Länge anwendbar. Auch hier liegt folgende Struktur zugrunde: &apos;00&apos; &apos;01&apos; PS &apos;00&apos; HI HW GG. &lt;/br&gt;
     115        ///
     116        ///Die Unterschiede zu den Bleichenbacher Signaturen sind [rest of string was truncated]&quot;;.
    107117        /// </summary>
    108118        internal static string Gen_Kuehn_Sig_Tab {
     
    114124        /// <summary>
    115125        ///   Looks up a localized string similar to &lt;h2&gt;Signatur generieren&lt;/h2&gt;
    116         ///In diesem Tab wird die komplette PKCS #1-Signatur erstellt. Die Signatur hat folgende Struktur: &apos;00&apos; &apos;01&apos; PS &apos;00&apos; HI HW. &lt;/br&gt;
     126        ///In diesem Tab wird die komplette PKCS#1-Signatur erstellt. Die Signatur hat folgende Struktur: &apos;00&apos; &apos;01&apos; PS &apos;00&apos; HI HW. &lt;/br&gt;
    117127        ///Im Einzelnen bedeutet dies:
    118128        ///&lt;ul&gt;
     
    124134        ///&lt;li&gt;
    125135        ///&lt;strong&gt;&apos;01&apos;&lt;/strong&gt;
    126         ///Block Type. Dieser Block gibt an ob es sich um eine Verschlüsselung mit dem privat [rest of string was truncated]&quot;;.
     136        ///Block Type. Dieser Block gibt an, ob es sich um eine Operation mit dem privaten ode [rest of string was truncated]&quot;;.
    127137        /// </summary>
    128138        internal static string Gen_PKCS1_Sig_Tab {
     
    134144        /// <summary>
    135145        ///   Looks up a localized string similar to &lt;h2&gt;RSA-Schlüsselgenerierung&lt;/h2&gt;
    136         ///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.&lt;/br&gt;
    137         ///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]&quot;;.
     146        ///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.&lt;/br&gt;
     147        ///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]&quot;;.
    138148        /// </summary>
    139149        internal static string KeyGen {
     
    145155        /// <summary>
    146156        ///   Looks up a localized string similar to &lt;h2&gt;RSA-Modul&lt;/h2&gt;
    147         ///Das Modul ist Bestandteil eines RSA-Schlüsselpaares und in dem öffentlichen und privaten Schlüssel gleich. &lt;/br&gt;
     157        ///Der Modul ist Teil des öffentlichen RSA-Schlüssels. Der Modul wird auch bei der Operation mit dem privaten Schlüssel gebraucht.&lt;/br&gt;
    148158        ///
    149         ///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.
     159        ///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.
    150160        ///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.
    151161        ///.
     
    159169        /// <summary>
    160170        ///   Looks up a localized string similar to &lt;h2&gt;RSA öffentlicher Schlüssel&lt;/h2&gt;
    161         ///Der öffentliche Schlüssel (public Key) des RSA-Schlüsselpaares wird genutzt, um die mit dem privaten Schlüssel
    162         ///verschlüsselten, Signaturen zu entschlüsseln. Aus Performance Gründen wird gewöhnlich ein Schlüssel mit einem geringen
    163         ///Hamming-Gewicht genutzt (z.B. 3, 17 oder 65537). Voraussetzung für den Bleichenbacher Angriff ist, dass der
     171        ///Der öffentliche Schlüssel (public key) des RSA-Schlüsselpaares wird genutzt, um die mit dem privaten Schlüssel
     172        ///erstellten Signaturen zu validieren. Aus Performance-Gründen wird gewöhnlich ein öffentlicher Schlüssel mit einem geringen
     173        ///Hamming-Gewicht genutzt (z.B. 3, 17 oder 65537). Voraussetzung für den Bleichenbacher Angriff ist der spezielle Fall, dass der
    164174        ///öffentliche Schlüssel drei ist.
    165         ///
    166175        ///.
    167176        /// </summary>
     
    174183        /// <summary>
    175184        ///   Looks up a localized string similar to &lt;h2&gt;PKCS #1-Signaturgenerierung&lt;/h2&gt;
    176         ///&lt;strong&gt;Um PKCS#1 Signaturen erzeugen zu können muss zuerst ein RSA-Schlüsselpaar, in der entsprechenden Maske,
    177         /// generiert werden&lt;/strong&gt;&lt;/br&gt;
    178         /// &lt;strong&gt;Es muss zuerst der Datenblock generiert werden, bevor die komplette Signatur generiert werden kann!&lt;/strong&gt;
     185        ///&lt;strong&gt;Um PKCS#1-Signaturen erzeugen zu können, muss zuerst ein RSA-Schlüsselpaar in der entsprechenden Maske
     186        /// erzeugt werden&lt;/strong&gt;&lt;/br&gt;
     187        /// &lt;strong&gt;Zuerst muss der Datenblock erzeugt werden, bevor die komplette Signatur generiert werden kann!&lt;/strong&gt;
    179188        /// &lt;/br&gt;&lt;/br&gt;
    180         ///Die PKCS #1-Signaturen basieren auf dem asymetrischen Verschlüsselungsalgorithmus RSA. Daher ist es notwendig einen
    181         ///RSA-Schlüssel zu generieren.&lt;/br&gt;
    182         ///Um eine PKCS#1-Signatur zu generieren wird z [rest of string was truncated]&quot;;.
     189        ///Die PKCS#1-Signaturen basieren auf dem asymmetrischen Verschlüsselungsalgorithmus RSA. Daher ist es notwendig, einen
     190        ///RSA-Schlüssel zu erzeugen.&lt;/br&gt;
     191        ///Um eine PKCS#1-Signatur zu erzeugen, wird zunächst de [rest of string was truncated]&quot;;.
    183192        /// </summary>
    184193        internal static string SigGen {
     
    190199        /// <summary>
    191200        ///   Looks up a localized string similar to &lt;h2&gt;Bleichenbacher Angriff&lt;/h2&gt;
    192         ///&lt;strong&gt;Um den Bleichenbacher Angriff durchführen zu können, muss zuerst ein RSA-Schlüsselpaar,
    193         ///in der entsprechenden Maske, generiert werden&lt;/strong&gt;&lt;/br&gt;
    194         /// &lt;strong&gt;Es muss zuerst der Datenblock generiert werden, bevor die komplette Signatur generiert werden kann!&lt;/strong&gt;
     201        ///&lt;strong&gt;Um den Bleichenbacher Angriff durchführen zu können, muss zuerst ein RSA-Schlüsselpaar in der entsprechenden Maske erzeugt werden&lt;/strong&gt;&lt;/br&gt;
     202        /// &lt;strong&gt;Zuerst muss der Datenblock erzeugt werden, bevor die komplette Signatur generiert werden kann!&lt;/strong&gt;
    195203        /// &lt;/br&gt;&lt;/br&gt;
    196         /// Um eine gefälschte Signatur zu generieren wird zunächste der &lt;a href=&quot;help://Gen_Datablock_Tab&quot;&gt;Datenblock&lt;/a&gt; wie in
    197         /// einer regulären PKCS#1-Signatur generiert. Allerdings unterscheidet [rest of string was truncated]&quot;;.
     204        /// Um eine gefälschte Signatur zu erzeugen, wird zunächst der &lt;a href=&quot;help://Gen_Datablock_Tab&quot;&gt;Datenblock&lt;/a&gt; wie in
     205        /// einer regulären PKCS#1-Signatur generiert. Allerdings unterscheidet sich die &lt;a  [rest of string was truncated]&quot;;.
    198206        /// </summary>
    199207        internal static string SigGenFakeBleichenbacher {
     
    204212       
    205213        /// <summary>
    206         ///   Looks up a localized string similar to &lt;h2&gt;Kühn&lt;/h2&gt;
    207         ///Ihre Wahl der Methode zur Faktorisierung  bestimmt die Laufzeit und den Resourcenverbrauch der Faktorisierung.
    208         ///&lt;ul&gt;
    209         ///&lt;li&gt;
    210         ///&lt;strong&gt;Probedivision&lt;br /&gt;&lt;/strong&gt;
    211         ///Die Probedivision ist das Verfahren mit der größen Laufzeit. Es benötig sehr viel Arbeitsspeicher und Prozessorzeit.
    212         ///Sollte nach 100.000 Versuchen kein Faktor gefunden werden, wird das Verfahren automatisch beendet.
    213         ///&lt;/li&gt;
    214         ///&lt;/ul&gt;
    215         ///.
     214        ///   Looks up a localized string similar to &lt;h2&gt;Angriff mit kuerzeren Schlüsseln&lt;/h2&gt;
     215        ///&lt;strong&gt;Um den Angriff mit kuerzeren Schlüsseln durchführen zu können, muss zuerst ein RSA-Schlüsselpaar in der entsprechenden Maske erzeugt werden&lt;/strong&gt;&lt;/br&gt;
     216        ///&lt;strong&gt;Zuerst muss der Datenblock erzeugt werden, bevor die komplette Signatur generiert werden kann!&lt;/strong&gt;
     217        ///&lt;/br&gt;
     218        ///&lt;/br&gt;
     219        ///Um eine gefälschte Signatur nach der Kuehn Methode zu erzeugen, wird zunächst der &lt;a href=&quot;help://Gen_Datablock_Tab&quot;&gt;Datenblock&lt;/a&gt; generiert. Dies
     220        ///ist gleich zu dem Datenblock e [rest of string was truncated]&quot;;.
    216221        /// </summary>
    217222        internal static string SigGenFakeKuehn {
     
    223228        /// <summary>
    224229        ///   Looks up a localized string similar to &lt;h2&gt;Signaturvalidierung&lt;/h2&gt;
    225         ///Zur Validierung von PKCS #1-Signaturen werden diese Signaturen zunächst mit dem öffentlichen Schlüssel entschlüsselt.
    226         ///Die entschlüsselte Signatur sollte eine Struktur wie &lt;a href=&quot;help://Gen_PKCS1_Sig_Tab&quot;&gt;hier&lt;/a&gt; beschrieben, aufweisen.
    227         ///Bei der Validierung wird als nächster Schritt der &lt;a href=&quot;help://Gen_Datablock_Tab&quot;&gt;Datenblock&lt;/a&gt; ausgelesen.&lt;/br&gt;
    228         ///Dieses extrahieren des Datenblock kann auf eine korrekte oder fehlerhafte Art und Weise geschehen. Die fehlerhafte
    229         ///Impleme [rest of string was truncated]&quot;;.
     230        ///Bei der Validierung einer PKCS#1-Signatur wird eine Operation mit dem öffentlichen Schlüssel durchgeführt.
     231        ///Das Ergebnis dieser Operation sollte eine Struktur aufweisen, wie &lt;a href=&quot;help://Gen_PKCS1_Sig_Tab&quot;&gt;hier&lt;/a&gt; beschrieben.
     232        ///Als nächster Schritt wird der &lt;a href=&quot;help://Gen_Datablock_Tab&quot;&gt;Datenblock&lt;/a&gt; ausgelesen.&lt;/br&gt;
     233        ///Dieses Extrahieren des Datenblock kann auf eine korrekte oder auf eine fehlerhafte Art und Weise geschehen. Die fehlerhafte
     234        ///Implementierung war bis zum [rest of string was truncated]&quot;;.
    230235        /// </summary>
    231236        internal static string SigVal {
     
    249254        ///     &lt;/head&gt;
    250255        ///     &lt;body&gt;
    251         ///     &lt;h2&gt;PKCS#1 Signaturen / Bleichenbacher Angriff&lt;/h2&gt;
     256        ///     &lt;h2&gt;PKCS#1-Signaturen / Bleichenbacher Angriff&lt;/h2&gt;
    252257        ///     &lt;p align=&quot;justify&quot;&gt;
    253         ///     PKCS#1 Signaturen basieren auf dem RSA Verschlüsselungsverfahren. Der Angriff von Daniel Bleichenbacher zielt nicht
     258        ///     PKCS#1-Signaturen basieren auf dem RSA-Verschlüsselungsverfahren. Der Angriff von Daniel Bleichenbacher zielt nicht
    254259        ///     auf das Verschlüsselungsverfahren selbst, sondern auf Implementierung [rest of string was truncated]&quot;;.
    255260        /// </summary>
     
    261266       
    262267        /// <summary>
    263         ///   Looks up a localized string similar to &lt;h2&gt;PKCS #1 / Bleichenbacher Angriff - Hilfe&lt;/h2&gt;
     268        ///   Looks up a localized string similar to &lt;h2&gt;PKCS#1 / Bleichenbacher Angriff - Hilfe&lt;/h2&gt;
    264269        ///Willkommen in der Hilfe des PKCS#1 / Bleichenbacher Angriff Plugins.&lt;/br&gt;
    265         ///Hier finden Sie detaillierte Informationen zu PKCS#1 Signaturen und dem Bleichenbacher Angriff.&lt;/br&gt;&lt;/br&gt;
    266         ///In die verschiedenen Masken dieses Plugins gelangen Sie indem Sie die Navigation auf der linken Seite nutzen. In den verschiedenen Masken
    267         ///wiederum finden Sie mehrere Hilfebuttons. Wenn Sie auf diese klicken, bekommen Sie detailierte Informationen über das jeweilige Thema.
     270        ///Hier finden Sie detaillierte Informationen zu PKCS#1-Signaturen und dem Bleichenbacher Angriff.&lt;/br&gt;&lt;/br&gt;
     271        ///In die verschiedenen Masken dieses Plugins gelangen Sie mit Hilfe der Navigation auf der linken Seite. In den verschiedenen Masken
     272        ///wiederum finden Sie mehrere Hilfebuttons. Wenn Sie auf diese klicken, bekommen Sie detaillierte Informationen über das jeweilige Thema.
    268273        ///.
    269274        /// </summary>
  • trunk/PKCS1/OnlineHelp/HelpFiles/Help.resx

    r1650 r1744  
    113113  </resheader>
    114114  <resheader name="reader">
    115     <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
     115    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
    116116  </resheader>
    117117  <resheader name="writer">
    118     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
     118    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
    119119  </resheader>
    120   <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
     120  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
    121121  <data name="Gen_Bleichenb_Sig_Tab" type="System.Resources.ResXFileRef, System.Windows.Forms">
    122122    <value>de\gen_bleichenb_sig_tab.html;System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8</value>
     
    124124  <data name="Gen_Datablock_Tab" type="System.Resources.ResXFileRef, System.Windows.Forms">
    125125    <value>de\gen_datablock_tab.html;System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8</value>
     126  </data>
     127  <data name="Gen_Kuehn_Iterations" type="System.Resources.ResXFileRef, System.Windows.Forms">
     128    <value>de\gen_kuehn_iterations.html;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8</value>
    126129  </data>
    127130  <data name="Gen_Kuehn_Sig_Tab" type="System.Resources.ResXFileRef, System.Windows.Forms">
  • trunk/PKCS1/OnlineHelp/HelpFiles/de/Gen_Kuehn_Sig_Tab.html

    r1743 r1744  
    11<h2>Kuehn Signatur generieren</h2>
    2 In diesem Tab können Signaturen gefälscht werden nach der Methode wie sie Ulrich Kühn beschrieben hat.
    3 Die Signaturen ähneln denen von Bleichenbacher
     2In diesem Tab können gefälschte Signaturen, nach der Methode wie sie Ulrich Kühn beschrieben hat, erstellt werden.
     3Die Signaturen ähneln in der Struktur denen von <a href="help://Gen_Bleichenb_Sig_Tab">Bleichenbacher</a>, machen sich jedoch die Rechenkraft von
     4Computern 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>
    45
    5 Position nicht wählbar sondern XX Byte als Padding werden genutzt, das kürzest mögliche.
    6 Garbage == FF und nicht berechnet wie bei Bleichenbacher. Bei dieser Implementierung ist die Signatur schon
    7 nach dem Kubikwurzelziehen dargestellt, daher kann der dargestellte Garbage von dem FF Schema abweichen.
    8 1024 Bit Signaturen möglich.
    9 Solange probieren bis dass die Berechnung der dritten Wurzel und das Potenzieren das gleiche Ergebnis liefern.
    10 Dabei werden nur die 46 signifikanten Bytes (von links) verglichen, da sich hier der Paddingstring,
    11 Hashidentifier und Hashwert befinden. Fehlerhafte Implementierungen der Verifikation vergleichen auch nur diese
    12 Bytes und der Rest wird nicht beachtet.
     6Die Unterschiede zu den Bleichenbacher Signaturen sind im Folgenden erläutert:
     7<ul>
     8  <li>
     9    Der Paddingstring hat eine feste Länge von acht Byte (64 Bit). Diese Länge wurde gewählt, da einige fehlerhaften Implementierungen
     10    verschiedene Längen des Paddingstring voraussetzten. Maximal wurden jedoch acht Byte benötigt. Somit ist auch die Position des Hash-Identifiers (HI)
     11    und des Hashwertes (HW) fix.
     12  </li>
     13  <li>Der angehängte Garbage wird nicht berechnet, sondern es werden einfach die restlichen Oktetts mit 'FF' (hexadezimal 0xff) aufgefüllt.</li>
     14</ul>
    1315
    14 Da oft die Kubikwurzel berechnet werden muss, kann es lange dauern. (Limit von 25000 einstellbar)
     16Da der Garbage (GG) nicht berechnet wird, ist eine gefälschte Signatur nicht nur durch Kubikwurzelziehen zu erlangen. Der Ansatz von Kuehn ist, dass
     17man von der oben beschriebenen Struktur die Kubikwurzel zieht und das Ergebnis mit drei potenziert. Vom dem Ergebnis aus der Potenzberechnung wiederum
     18vergleicht man die ersten 46 Bytes (von links) mit der zuvor erstellten Struktur. Die 46 Bytes beinhalten:
     19<ul>
     20  <li>'00' '01' Die führenden Oktetts - 2 Byte Länge</li>
     21  <li>PS Den Paddingstring - 8 Byte Länge</li>
     22  <li>'00' Das trennende Null Oktett - 1 Byte Länge</li>
     23  <li>HI Den Hash-Identifier - 15 Byte Länge (SHA-1)</li>
     24  <li>HW Den Hashwert - 20 Byte Länge (SHA-1)</li>
     25</ul>
    1526
    16 
     27Stimmen die signifikanten 46 Bytes nicht überein, werden die zu signierenden Daten abgeändert. Dadurch ergibt sich ein anderer Hashwert und es wird
     28erneut die Kubikwurzel berechnet, das Ergebnis potenziert und verglichen. Somit wird getestet, ob der Hash-Identifier und der Hashwert beim
     29Kubikwurzelziehen und anschließendem Potenzieren unverändert bleibt.
     30Werden beim Vergleich keine Unterschiede der 46 Bytes erkannt, wird die erstellte Signatur von fehlerhaften Implementierungen als korrekt betrachtet.</br>
     31Da bei jeder Iteration des Algorithmus aufwendige Berechnungen wie Kubikwurzelziehen und Hashwert berechnen durchgeführt werden, kann eine lange Laufzeit
     32zustande kommen. Um dies zu begrenzen kann ein Limit an Iterationen angegeben werden (Eingabefeld "Max. Anzahl an Iterationen").</br></br>
     33Die Darstellung der unverschlüsselten Signatur in diesem Tab stellt die Signatur nach dem Potenzieren der verschlüsselten Signatur dar, so dass es dazu
     34kommen kann, dass der Garbage nicht wie oben beschrieben nur aus 'FF'-Oktetten bestehen.
  • trunk/PKCS1/OnlineHelp/HelpFiles/de/SigGenFakeKuehn.html

    r1659 r1744  
    1 <h2>Kühn</h2>
    2 Hier fehlt noch Text
     1<h2>Angriff mit kuerzeren Schlüsseln</h2>
     2<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>
     3<strong>Zuerst muss der Datenblock erzeugt werden, bevor die komplette Signatur generiert werden kann!</strong>
     4</br>
     5</br>
     6Um eine gefälschte Signatur nach der Kuehn Methode zu erzeugen, wird zunächst der <a href="help://Gen_Datablock_Tab">Datenblock</a> generiert. Dies
     7ist gleich zu dem Datenblock einer regulären PKCS#1-Signatur. Allerdings unterscheidet sich die <a href="help://Gen_Kuehn_Sig_Tab">Struktur</a>
     8der gefälschten Signatur in folgenden Punkten:
     9<ul>
     10  <li>
     11    Der Padding-String wird verkürzt. Somit findet sich der <a href="help://Gen_Datablock_Tab">Datenblock</a>
     12    weiter links in der Signatur. Fehlerhafte Implementierungen der Validierung von Signaturen erkennen dies nicht.
     13    Bei Kuehn wird die Länge des Paddingstring fix gewählt (46 Byte, wenn SHA-1 als Hashalgorithmus gewählt wird)
     14  </li>
     15  <li>Der ungenutzte Platz am Ende der Signatur wird mit dem sog. Garbage, aufgefüllt. Der Garbage besteht aus Oketetten mit dem Wert 'FF'
     16(hexadezimal 0xff).</li>
     17</ul>
  • trunk/PKCS1/OnlineHelp/OnlineHelpActions.cs

    r1650 r1744  
    1818        Gen_Bleichenb_Sig_Tab,
    1919        Gen_Kuehn_Sig_Tab,
     20        Gen_Kuehn_Iterations,
    2021        KeyGen_PubExponent,
    2122        KeyGen_ModulusSize,
  • trunk/PKCS1/PKCS1.csproj

    r1743 r1744  
    4545      <HintPath>..\..\CrypBuild\x86\Debug\CrypPluginBase.dll</HintPath>
    4646    </Reference>
    47     <Reference Include="Emil.GMP, Version=1.0.0.0, Culture=neutral, processorArchitecture=x86">
    48       <SpecificVersion>False</SpecificVersion>
    49       <HintPath>.\Emil.GMP.dll</HintPath>
    50     </Reference>
    5147    <Reference Include="PresentationCore">
    5248      <RequiredTargetFramework>3.0</RequiredTargetFramework>
     
    8177  </ItemGroup>
    8278  <ItemGroup>
    83     <Compile Include="BigNum\BigNum.cs" />
    84     <Compile Include="BigNum\BigNumDec.cs" />
    8579    <Compile Include="Library\BleichenbacherSignature.cs" />
    8680    <Compile Include="Library\GuiLogMsgHandOff.cs" />
     
    327321  </ItemGroup>
    328322  <ItemGroup>
     323    <Content Include="OnlineHelp\HelpFiles\de\Gen_Kuehn_Iterations.html">
     324      <SubType>Designer</SubType>
     325    </Content>
    329326    <Content Include="OnlineHelp\HelpFiles\de\Gen_Datablock_Tab.html" />
    330327    <Content Include="OnlineHelp\HelpFiles\de\Gen_PKCS1_Sig_Tab.html" />
     
    335332      <SubType>Designer</SubType>
    336333    </Content>
    337     <Content Include="OnlineHelp\HelpFiles\de\KeyGen_PubExponent.html" />
     334    <Content Include="OnlineHelp\HelpFiles\de\KeyGen_PubExponent.html">
     335      <SubType>Designer</SubType>
     336    </Content>
    338337    <Content Include="OnlineHelp\HelpFiles\de\KeyGen_ModulusSize.html" />
    339     <Content Include="OnlineHelp\HelpFiles\de\StartControl.html" />
    340     <Content Include="OnlineHelp\HelpFiles\de\SigGenFakeBleichenbacher.html" />
    341     <Content Include="OnlineHelp\HelpFiles\de\SigGenFakeKuehn.html" />
     338    <Content Include="OnlineHelp\HelpFiles\de\StartControl.html">
     339      <SubType>Designer</SubType>
     340    </Content>
     341    <Content Include="OnlineHelp\HelpFiles\de\SigGenFakeBleichenbacher.html">
     342      <SubType>Designer</SubType>
     343    </Content>
     344    <Content Include="OnlineHelp\HelpFiles\de\SigGenFakeKuehn.html">
     345      <SubType>Designer</SubType>
     346    </Content>
    342347    <Content Include="OnlineHelp\HelpFiles\de\KeyGen.html" />
    343348    <Content Include="OnlineHelp\HelpFiles\de\SigGen.html" />
    344349    <Content Include="OnlineHelp\HelpFiles\de\SigVal.html" />
    345350    <Content Include="OnlineHelp\HelpFiles\template.htm" />
    346     <Content Include="WpfControls\Start.htm" />
     351    <Content Include="WpfControls\Start.htm">
     352      <SubType>Designer</SubType>
     353    </Content>
    347354    <Resource Include="Resources\icons\unequal.png" />
    348355    <Resource Include="Resources\icons\equal.png" />
  • trunk/PKCS1/WpfControls/Components/SigGenKuehnControl.xaml

    r1743 r1744  
    3131                    <Label Grid.Row="0" Name="lblRsaKeySize" Margin="5,0,5,5" HorizontalAlignment="Left" VerticalAlignment="Top">RSA-Schlüsselgröße (in Bit):</Label>
    3232                    <Label Grid.Row="1" Name="lblPublicKey" Margin="5,0,5,5" HorizontalAlignment="Left" VerticalAlignment="Top">Öffentlicher Schlüssel:</Label>
    33                     <Label Grid.Row="2" Name="lblIterations" Margin="5,0,5,5" HorizontalAlignment="Left" VerticalAlignment="Top">Anzahl an Iterationen:</Label>
     33                    <Label Grid.Row="2" Name="lblIterations" Margin="5,0,5,5" HorizontalAlignment="Left" VerticalAlignment="Top">Max. Anzahl an Iterationen:</Label>
    3434                </Grid>
    3535                <!-- middle -->
     
    4343                    <Label Grid.Row="0" Name="lblRsaKeySizeRes" Margin="5,0,5,5" HorizontalAlignment="Left" VerticalAlignment="Top" MinWidth="50" MaxWidth="150"></Label>
    4444                    <Label Grid.Row="1" Name="lblPublicKeyRes" Margin="5,0,5,5" HorizontalAlignment="Left" VerticalAlignment="Top" MinWidth="50" MaxWidth="150"></Label>
     45                    <DockPanel Grid.Row="2">
    4546                    <TextBox Grid.Row="2" Name="tbIterations" Margin="5,0,5,5" HorizontalAlignment="Left" VerticalAlignment="Top" MinWidth="50">                       
    4647                        <Binding ElementName="This" Path="Signature.Iterations" UpdateSourceTrigger="PropertyChanged">
     
    5051                        </Binding>
    5152                    </TextBox>
     53                    <Image Name="btnHelpIterations" Cursor="Hand" Source="../../Resources/icons/help.png" Width="16" Height="16" HorizontalAlignment="Right" MouseLeftButtonDown="btn_Help_MouseLeftButtonDown" />
     54                    </DockPanel>
    5255                    <TextBlock Grid.Row="3"  Foreground="Red" FontWeight="Bold" FontSize="10"
    5356                                Text="{Binding ElementName=tbIterations,
  • trunk/PKCS1/WpfControls/Components/SigGenKuehnControl.xaml.cs

    r1743 r1744  
    2121    public partial class SigGenKuehnControl : UserControl
    2222    {
    23         private KuehnSignature m_signature = new KuehnSignature();
     23        private KuehnSignature m_signature = (KuehnSignature)SignatureHandler.getInstance().getKuehnSig();
    2424        public KuehnSignature Signature
    2525        {
     
    4545            Cursor = Cursors.Wait;
    4646
    47             this.Signature = (KuehnSignature)SignatureHandler.getInstance().getKuehnSig();
     47            //this.Signature = (KuehnSignature)SignatureHandler.getInstance().getKuehnSig();
    4848
    4949            if (this.Signature.GenerateSignature())
     
    5555            else
    5656            {
    57                 this.tbError.Text = "Es ist ein Fehler aufgetreten. Signatur konnte nicht erstellt werden.";
     57                this.tbError.Text = "Signatur konnte nicht erstellt werden. Es ist das Limit an Iterationen erreicht worden.";
    5858            }
    5959
     
    7070            this.lblSignatureLength.Content = "(Länge: " + UserControlHelper.GetRtbTextLength(this.rtbResult) * 4 + " bit)";
    7171        }
     72
     73        private void btn_Help_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
     74        {
     75            if (sender == btnHelpIterations)
     76            {
     77                OnlineHelp.OnlineHelpAccess.ShowOnlineHelp(PKCS1.OnlineHelp.OnlineHelpActions.Gen_Kuehn_Iterations);
     78            }
     79            e.Handled = true;
     80        }
    7281    }
    7382}
  • trunk/PKCS1/WpfControls/Start.htm

    r1663 r1744  
    4444        Implementierungen sollten diese fehlerhafte Validierung nicht mehr beinhalten. </br>
    4545        </p>
     46  <p align="justify">
     47  <strong>Angriff mit kürzeren Schlüsseln (Kühn Angriff)</strong></br>
     48  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
     49  macht sich die Rechenkraft von Computer zunutze. Hier wird nicht berechnet wie eine gefälschte Signatur aussehen muss, sondern
     50  es wird ein Algorithmus durchlaufen, bis das entsprechende Ergebnis generiert ist.</br>
     51  </p>
    4652        </body>
    4753</html>
Note: See TracChangeset for help on using the changeset viewer.