DE69506675T2 - Verfahren zur Ausführung von modularen Reduktion nach der Montgomery-Methode - Google Patents

Description

• Die Erfindung betrifft ein Verfahren zur Durchführung einer modularen Reduktion nach dem Verfahren von Montgomery. Dieses Verfahren ermöglicht es, modulare Operationen auf einem endlichen Körper GF(2n) (Galois-Körper) ohne Divisionen durchführen zu können.
• Üblicherweise werden modulare Operationen auf GF(2n) in der Kryptographie für Anwendungen wie Authentifizierung von Nachrichten, Identifizierung eines Anwenders und Austausch von Schlüsseln verwendet. Derartige Anwendungsbeispiele sind z. B. in der französischen Patentanmeldung beschrieben, die unter der Nummer 2 679 054 veröffentlicht wurde.
• Kommerziell erhältlich sind integrierte Schaltkreise für diese Anwendungen, z. B. von SGS-THOMSON MICROELECTRONICS S. A. mit der Bezeichnung ST16CF54, der um eine Einheit aus Zentraleinheit- arithmetischer Coprozessor aufgebaut ist und für die Verarbeitung von Modulo-Operationen ausgelegt ist. Der verwendete Coprozessor erlaubt die Durchführung von modularen Operationen mit binären Datenwerten, die in m Worten à k Bits codiert sind, wobei k = 32 und m = 8 oder 16, wobei auf das Verfahren von Montgomery zurückgegriffen wird. Er ist Gegenstand einer europäischen Patentanmeldung mit der Veröffentlichungsnummer 0 601 907 A2 und ist in Fig. 1 dargestellt (diese Figur entspricht der Fig. 2 der genannten europäischen Patentanmeldung).
• Die Basisoperation, Pfield genannt, besteht darin, aus drei binären Datenwerten A (Multiplikand), B (Multiplikator) und N (Modul), die in einer ganzen Zahl n Bits codiert sind, durchzuführen, so daß P(A, B)N = A · B · I mod N gilt, wobei I ein binärer Datenwert, der in n Bits codiert ist, ist, so daß I = 2-n mod N. Selbstverständlich gilt n = m · k.
• Der Schaltkreis ermöglicht außerdem bei Erweiterung eine modulare Reduktion durchzuführen, d. h. C mod N zu berechnen, wobei C ein binärer Datenwert ist, der in m Worten à k Bits codiert ist.
• Das durchgeführte Verfahren ist das folgende:
• - Erzeugen von H = 2n mod N,
• - Erzeugen von P(C, H)N.
• Das Verfahren zur modularen Reduktion, das durch den in Fig. 1 dargestellten Schaltkreis abgearbeitet wird, umfaßt die folgenden Schritte:
• 1. Berechnen eines Parameters H (H = 2m·k mod N) und eines Parameters J&sub0;, codiert in k Bits, wobei J&sub0; = -N&sub0;&supmin;¹ mod 2k gilt und N&sub0; das Wort mit dem geringsten Gewicht von Modulo N ist, und Abspeichern von J&sub0; in einem Register 17 mit k Bits,
• 2. Laden des Parameters H und von Modulo N in die jeweiligen Register 10 und 12 mit n Bits, wobei n = m · k, und Initialisieren eines Registers 11 mit n Bits auf Null, wobei der Inhalt dieses Registers mit S bezeichnet wird und S ein binärer variabler Datenwert ist, der in n Bits codiert ist,
• 3. Abarbeiten einer Schleife, die mit i indiziert ist, wobei i zwischen 1 und m liegt, wobei jede i-te Iteration die folgenden Operationen umfaßt:
• a) Übertragen des i-ten Wortes Ci-1 des Datenwertes M aus einem Register 16 an eine Speicherkippstufe 21,
• b) Erzeugen eines Wertes I(i) - S(i-1) + H · Ci-1 mit S(0) = 0 und S(i-1) der aktualisiert genannte Wert von S, der im folgenden definiert wird durch:
• I - Verschieben nach rechts des Inhalts des Registers 10 zum Eingang eines ersten seriell- parallelen Multiplikatorschaltkreises 19 mit Rückschleifen des Ausgangs des Registers 10 an seinen Eingang,
• II - Multiplizieren der Bits von H mit Ci-1,
• III - Verschieben nach rechts des Inhalts des Registers 12 mit Rückschleifen des Ausgangs an den Eingang,
• IV - Bestimmen des aktualisierten Wertes von S(i-1) als Wert, der in dem Register 11 nach der (i- 1)-ten Iteration abgespeichert wird, wenn dieser kleiner als N ist, und, wenn dieser größer ist, indem seriell N von diesem in einem ersten seriellen Subtraktionsschaltkreis 28 abgezogen wird, wobei der sich dabei ergebende Wert der aktualisierte Wert von S(i-1) wird, und
• V - Verschieben nach rechts des Inhalts des Registers 11 und Bit für-Bit-Addieren des Wertes der Multiplikation H · Ci-1 zu dem aktualisierten Wert von S(i-1) in einem ersten seriellen Additionsschaltkreis 30;
• c) Multiplizieren des Wortes mit dem geringsten Gewicht von X(i), X&sub0;(i), mit J&sub0; in einem zweiten seriell-parallelen Multiplikationsschaltkreis 20 und Eintrag des Wertes X&sub0;(i) · J&sub0; mod 2k = Y&sub0;(i) in ein Register 18 und gleichzeitiges Verzögern von N und X(i) um k Zyklen in Verzögerungsschaltkreisen 32 und 34;
• d) Berechnen eines Wertes Z(i) = X(i) + Y&sub0;(i) · N durch:
• I - Multiplizieren von Y&sub0;(i) mit N, verzögert um k Zyklen, in dem zweiten Multiplikatorschaltkreis 20 und
• II - Addieren von X(i) zu dem Wert Y&sub0;(i) · N in einem zweiten seriellen Additionsschaltkreis 31,
• e) Verwerfen des Wortes mit dem geringsten Gewicht von Z(i) und Speichern der restlichen Worte, d. h. Z(i)/2k, in dem Register 11,
• f) Bit für-Bit-Vergleichen von Z(i)/2k mit N mit dem Ziel, den aktualisierten Wert von S(i) der folgenden Iteration zu bestimmen, wie es oben beschrieben wurde, wobei dieser Vergleich durchgeführt wird durch Bit für-Bit-Subtraktion von Z(i)/2k und N in einem zweiten seriellen Subtraktionsschaltkreis 29, wobei N um zusätzliche k Zyklen verzögert wird,
• g) wobei das i-te Wort des Multiplikanden C in das Register 16 zu irgendeinem Zeitpunkt während der obigen Operationen geladen wird;
• 4. Verwerfen bei der m-ten Iteration des Wortes mit dem geringsten Gewicht von Z(m) und Eintragen der übrigen Worte, d. h. Z(m)/2k, in das Register 10,
• 5. Ausgeben des in dem Register 10 abgespeicherten Ergebnisses bei der letzten Iteration, unter Umständen unter Subtraktion von N durch einen dritten seriellen Subtraktionsschaltkreis 27, wenn Z(m)/2k ≥ N.
• Allgemein nennt man Zyklusdauer oder Zyklus die Periode des Taktsignals, das die Funktion des Schaltkreises nach Fig. 1 synchronisiert, wobei man die notwendige Zeit für die Verarbeitung einer modularen Reduzierung grundsätzlich aufteilen kann in:
• - n · (n + 1) Zyklen für die Berechnung von H,
• - n Zyklen für den Schritt 2,
• - m · (n + 2 · k + x) Zyklen für die Schritte 3 und 4 zusammen, wobei x eine ganze Zahl ist,
• - n Zyklen für den Schritt 5.
• In der Praxis hängt x von der Initialisierung des Schaltkreises ab, d. h. grundsätzlich von der Einrichtung von Steuersignalen (für Multiplexer zum Beispiel), um eine kohärente Funktion des Schaltkreises zu gewährleisten. In der Praxis kann man z. B. von x = 7 ausgehen.
• Was den ersten Schritt betrifft, so wird die Berechnung des Parameters J&sub0; durch die Zentraleinheit durchgeführt (Software-Verfahren).
• Man hat H · I² = 1 mod N, was ein exaktes Ergebnis zuläßt, d. h. gleich C mod N bei dem Schritt S des modularen Multiplikationsverfahrens, das oben beschrieben wurde.
• Im übrigen wird die Berechnung von H mit Hilfe des Coprozessors nach dem folgenden Verfahren durchgeführt, bei dessen Beschreibung auf Fig. 2 Bezug genommen wird, wobei diese Fig. 2 der Fig. 9 in der genannten europäischen Patentanmeldung entspricht.
• Um H zu berechnen, geht man wie folgt vor (siehe auch die Beschreibung auf Seite 20, Zeile 47 bis Seite 25, Zeile 52 der genannten europäischen Patentanmeldung):
• 1. Laden von N in das Register 12 und Initialisieren des Registers 10 auf B(0) = 0,
• 2. gleichzeitig:
• - Verschieben nach rechts und Bit für-Bit-Subtraktion von B(0) und N in einem seriellen Subtrahierer 27 mit Verschieben nach links um eine Einheit des Ergebnisses R(0) = B(0) - N mod 2m·k, wobei das Verschieben in dem Subtrahierer erfolgt, indem ein erstes Bit auf 0 ausgegeben wird,
• - Laden von B(1) = 2 · R(0) in das Register 10,
• - Bit für-Bit-Subtraktion von 2 · R(0) und N, um festzustellen, ob B(1) &ge; oder < N, wobei diese Subtraktion in einem zweiten Subtrahierer 40 einschließlich eines Tests des Ergebnisses der Subtraktion in einem Schaltkreis 44 erfolgt,
• - wenn B(1) &ge; N, Laden von B(2) = B(1) - N und anderenfalls von B (2) = B (1) in das Register 10.
• Es ergibt sich B(2) = H = 2n mod N.
• Man kennt außerdem andere Verfahren, die das Verfahren von Montgomery verwenden. In IEE PROCEEDING E COMPUTERS & DIGITAL TECHNIQUES, Band 141, Nr. 5, September 1994, STEVENAGE GB, Seite 314-316, KOC "Montgomery reduction with even modules" wird ein Verfahren vorgestellt, das bei Rechnern eingesetzt werden kann, das aber nicht auf integrierte Schaltkreise umsetzbar ist.
• Der Erfinder hat versucht, das Verfahren zur modularen Reduktion aus EP-601 907 zu verbessern.
• Tatsächlich unterliegt der Coprozessor, so wie er momentan verwendet wird, Einschränkungen in bezug auf die Funktion, nämlich:
• - es ist nicht möglich, binäre Datenwerte mit anderen Größen als n Bits zu verarbeiten, d. h. in der Praxis wird nicht die übliche Größe von Datenwerten berücksichtigt, und
• - eine Durchführung modularer Operationen ist mit geraden Modulen nicht möglich, d. h. die Berechnung von J&sub0; ist nur möglich, wenn N&sub0; ungerade ist.
• Die Erfindung schlägt die Verwendung der Einheit aus Zentraleinheit und Coprozessor in der Form vor, daß sich diese Einschränkungen überwinden lassen.
• Das Verfahren, das zur modularen Reduktion nach dem Verfahren von Montgomery durchgeführt wird, bei welchem:
• - ein binärer Datenwert C in c Bits codiert ist, die aufgeteilt sind auf m' Worte mit k Bits, wobei m' und k ganze Zahlen sind und für m' gilt
• m' · k &ge; c > (m' - 1) · k,
• - ein binärer Datenwert N, der von Null verschieden ist, auf n Bits codiert ist,
• ist dadurch gekennzeichnet, daß zum Erzeugen von C mod N die Schritte Erzeugen eines binären Datenwertes J&sub0;(N'), wobei N' ein binärer Datenwert ist, der auf n Bit codiert ist, so daß N' ein Bit mit geringstem Gewicht hat, das 1 ist, und N = N' · , wobei a eine ganze Zahl &ge; 0 ist, Erzeugen wenigstens eines binären Datenwertes H der Form 2f(C, N), wobei f(C, N) eine ganze Zahl ist, die die Größe von C und die Zahl an Bits mit geringstem Gewicht von N darstellt, die 0 sind, und Ausgeben einerseits von C am parallelen Eingang eines Multiplikationsschaltkreises (19) mit einem seriellen Eingang, einem parallelen Eingang und einem seriellen Ausgang, und andererseits von H am seriellen Eingang des gleichen Multiplikationsschaltkreises durchgeführt werden.
• Erfindungsgemäß wird außerdem vorgeschlagen, um C mod N zu erzeugen, wobei das Bit von N mit dem geringsten Gewicht 0 ist, die folgenden Schritte durchzuführen:
• E1 - Erzeugen eines binären Datenwertes H = 2m'·k-a mod N',
• E3 - Ausgeben von C, codiert in m' · k Bits, an den Paralleleingang des Multiplikationsschaltkreises (19) und von H, codiert in n Bits, an den seriellen Eingang des gleichen Multiplikationsschaltkreises, um einen Datenwert P(C, H)N' = C · 2-a mod N' zu erhalten,
• E4 - Erzeugen von 2a · P(C, H)N' = C mod N.
• Mit diesem Verfahren ist es möglich, modulare Reduktionen mit einem geraden Modul und einer beliebigen Größe des Datenwertes C durchzuführen.
• Erfindungsgemäß wird außerdem zum Erzeugen C mod N vorgeschlagen, die folgenden Schritte durchzuführen:
• E1 - Erzeugen eines binären Datenwertes H = 2m'·k-a mod N',
• E3 - Ausgeben von C, codiert in m' · k Bits, an den Paralleleingang des Multiplikationsschaltkreises (19) und von H, codiert in n Bits, an den seriellen Eingang des gleichen Multiplikationsschaltkreises, um eine Dateneinheit P(C, H)N' = C · 2-a mod N' zu erhalten.
• Mit diesen Verfahren ist es möglich, eine modulare Reduktion für ein ungerades Modul und eine beliebige Größe von C durchzuführen.
• Die Erfindung ergibt sich neben weiteren Einzelheiten und Vorteilen in der folgenden Beschreibung von bevorzugten Ausführungsformen der Erfindung, die lediglich als Beispiel dienen und nicht einschränkend gemeint sind, wobei Bezug genommen wird auf die beigefügten Zeichnungen, bei denen:
• Fig. 1 ein Schaltschema zeigt, das die Umsetzung von modularen Operationen nach dem Verfahren von Montgomery ermöglicht,
• Fig. 2 einen Schaltkreis zeigt, der die Berechnung eines Fehlerkorrekturparameters gemäß der Erfindung ermöglicht.
• Fig. 1 zeigt einen Logikschaltkreis 1 zur modularen Verarbeitung.
• In der Praxis ist dieser Schaltkreis 1 mit einer (nicht dargestellten) Zentraleinheit verbunden, die seine Steuerung über einen (nicht dargestellten) Sequenziererschaltkreis ermöglicht.
• Er umfaßt:
• - drei Schieberegister 10, 11 und 12 mit seriellem Eingang und Ausgang. Diese Register umfassen jeweils eine gleiche Zahl n an Zellen, wobei n = m · k. Diese Register können unterteilbar sein, z. B. in Register mit n/2 Zellen und in Register mit k Bits bei den Registern 10 und 12.
• - Multiplexer 13, 14 und 15, die jeweils vor den Registern 10, 11 und 12 angeordnet sind. Man wird ebenfalls Multiplexer vor die Unterteilungen positionieren, wenn diese existieren,
• - drei Register 16, 17 und 18, die jeweils k Zellen enthalten. Diese Register 16 und 17 und 18 sind Register mit parallelem Ausgang und seriellem Eingang,
• - zwei Multiplikationsschaltkreise 19 und 20, die jeweils einen seriellen Eingang, einen parallelen Eingang und einen seriellen Ausgang haben. Der parallele Eingang des Multiplikationsschaltkreises 19 ist mit dem Ausgang des Registers 16 über eine Speicherkippstufe 21 mit k Zellen verbunden. Der parallele Eingang des Multiplikationsschaltkreises 20 ist mit einem der Ausgänge der Register 17 oder 18 über eine Speicherkippstufe 22 mit k Zellen verbunden. Diese Kippstufe 22 ist ihrerseits mit einem der Ausgänge der Register 17 und 18 über einen Multiplexer mit zwei parallelen Eingängen und einem parallelen Ausgang verbunden.
• - Multiplexer 24, 25, 25', 26, 36 und 38,
• - einen Demultiplexer 39,
• - serielle Subtraktionsschaltkreise 27, 28 und 29,
• - serielle Additionsschaltkreise 30 und 31.
• - Verzögerungsschaltkreise 32, 33 und 34 zum Verzögern bei der Weiterleitung von binären Datenwerten um k Zyklen,
• - einen Schaltkreis 35 zum Speichern des Vergleichsergebnisses.
• Weitere Einzelheiten findet man in der genannten europäischen Patentanmeldung (EP-0 601 907 A2) und insbesondere in Fig. 3 dieser Anmeldung sowie in den Abschnitten der Beschreibung, die sich darauf beziehen: Seite 15, Zeile 54 bis Seite 16, Zeile 13 und Seite 17, Zeile 50 bis Seite 18, Teile 55.
• Der Schaltkreis nach Fig. 1 erlaubt die Umsetzung der Erfindung.
• Fig. 2 zeigt einen Schaltkreis, der umfaßt:
• - die zwei Schieberegister 10 und 12, den Subtraktionsschaltkreis 27, den Multiplexer 36,
• - zwei Multiplexer mit zwei Eingängen 41 und 42, deren jeweilige Ausgänge jeweils mit den Eingängen der Register 10 und 12 verbunden sind,
• - einen seriellen Subtraktionsschaltkreis 40,
• - ein NICHT-UND-Gatter 43 mit zwei Eingängen,
• - einen Schaltkreis 44 zum Speichern des Vergleichsergebnisses.
• Die Subtraktionsschaltkreise 27 und 40 haben zwei serielle Eingänge und einen seriellen Ausgang.
• Der Subtraktionsschaltkreis 27 hat einen ersten Eingang, der mit dem Ausgang des Registers 10 verbunden ist, und sein Ausgang ist mit einem ersten Eingang des Subtraktionsschaltkreises 40 verbunden. Der Subtraktionsschaltkreis 40 ist über seinen zweiten Eingang mit dem Ausgang des Registers 12 verbunden und über seinen Ausgang mit einem invertierenden Eingang des Gatters 43 verbunden.
• Der andere (nicht invertierende) Eingang des Gatters 43 ist mit dem Ausgang des Subtraktionsschaltkreises 27 verbunden. Sein Ausgang ist mit einem Eingang des Schaltkreises 44 verbunden. Dieser Schaltkreis 44 hat einen weiteren Eingang, um ein Reinitialisierungssignal RES zu empfangen.
• Der Multiplexer 36 hat zwei Eingänge und einen Ausgang. Sein Ausgang ist mit dem zweiten Eingang des Subtraktionsschaltkreises 28 verbunden. Seine Eingänge sind jeweils mit dem Ausgang des Registers 12 und Masse (Potential, das logisch 0 entspricht) verbunden. Der Multiplexer 36 verbindet selektiv je nach Zustand eines Auswahlsignals SC, das vom Schaltkreis 44 ausgegeben wird (z. B. mit dem ersten Eingang, wenn SC = 0, und mit dem zweiten Eingang, wenn SC = 1), seinen Ausgang mit seinem ersten oder seinem zweiten Eingang.
• Der Multiplexer 41 ist über seine Eingänge jeweils mit dem Ausgang des Subtraktionschaltkreises 27 und mit Masse verbunden.
• Der Multiplexer 42 ist über seine Eingänge jeweils mit dem Ausgang des Registers 12 und mit einem Eingangsanschluß verbunden, um seriell einen binären Datenwert zu empfangen (in der Praxis Modulo N).
• Der Schaltkreis nach Fig. 2 wird verwendet, um einen Fehlerkorrekturparameter H zu erzeugen, der einen binären Datenwert darstellt.
• Man möchte eine Operation der modularen Reduktion durchführen, genannt C mod N, d. h. einen binären Datenwert aus der Manipulation von zwei anderen binären Datenwerten erzeugen.
• Mehrere verfahren sind denkbar.
• Es sei angenommen, daß zu einem ersten Zeitpunkt gilt:
• - C und N sind binär codierte Datenwerte,
• - N = N' · 2a, wobei
• - N gerade (das Bit mit dem geringsten Gewicht ist Null),
• - N', das ein binär codierter Datenwert ist, ist ungerade (das Bit mit dem geringsten Gewicht ist eins), und
• - a ist eine ganze Zahl größer oder gleich 1,
• - N ist in l verwertbaren Bits codiert, wobei 1 eine ganze Zahl ist, die nicht Null ist, und u · k &ge; l > (u - 1) · k gilt und u eine ganze Zahl ungleich Null ist, so daß u &ge; m. N' ist daher in l - a verwertbaren Bits codiert.
• - C ist in c verwertbaren Bits und m' Worten codiert, wobei:
• - c irgendeine ganze Zahl ist,
• - m' irgendeine ganze Zahl ist, so daß m' · k &ge; c > (m' - 1) · k,
• - m" eine ganze Zahl ist, so daß m" · m &ge; m' > (m" - 1) · m,
• - v eine ganze Zahl ungleich Null ist, so daß v - u &ge; m' > (v - 1) · u,
• - w eine ganze Zahl ist, so daß w · l &ge; c > (w - 1) · l.
• Unter verwertbarer Größe oder Zahl von verwertbaren Bits eines binären Datenwertes versteht man die minimale Anzahl von Bits, die notwendig und ausreichend ist, um einen Datenwert darzustellen, d. h. die minimale Zahl von Bits, so daß das Bit mit dem größten Gewicht gleich 1 ist.
• Üblicherweise bestimmt man a, l, u v, c, m', m" und w mit Hilfe der Zentraleinheit, die mit dem Coprozessor zusammenhängt, und dem sie die binären Daten zur Verarbeitung weitergibt.
I - Unterteilung von C in Datenwerte mit n Bits
• Ein erstes Verfahren besteht darin, davon auszugehen, daß C in einer ganzen Zahl von Bits codiert ist, die ein Vielfaches von n sei, und daß N' in n Bits codiert ist.
I.1 - Verfahren
• Wenn m' > m (d. h. m" > 1), so kann man schreiben:
• C = &Sigma;i Ci · 2i·n, wobei i als Index zwischen 0 und m" - 1 liegt und Ci ein binärer Datenwert ist, der in n Bits codiert ist.
• Man stellt fest, daß bei Cm"-1 die (m" · n - c) Bits mit dem größten Gewicht Null sind.
• Man leitet aus der obigen Definition von C ab:
• C mod N = (&Sigma;i Ci · 2i·n) mod N = (&Sigma;i (Ci · 2i·n mod N)) mod N = [(&Sigma;i (Ci · 2i·n-a mod N')) mod N'] · 2a.
• Es reicht, die folgenden Schritte abzuarbeiten:
• E0 - Erzeugung von J&sub0;(N'), ein Datenwert, der binär in k Bits codiert ist,
• E1 - für i zwischen 1 und m" - 1 Durchführen der folgenden Operationen:
• - Erzeugen eines binären Datenwertes Hi = 2(i+1)·n-a mod N' - 2f(C, N) mod N' mit f(C, N) = (i + 1) · n - a,
• - Ausgeben von Hi codiert in n Bits am seriellen Eingang des Multiplikationsschaltkreises 19, und von Ci , codiert in n Bits am parallelen Eingang des gleichen Multiplikationsschaltkreises, so daß sich ergibt:
• P(Ci, Hi)N' = Ci · 2i·n-a mod N',
• - Verschieben des Ergebnisses nach links um a Bits, um Ci · 2i·n mod N zu erhalten, und Abspeichern dieses Ergebnisses,
• E2 - bei i = 0 Abspeichern von C&sub0;, wenn C&sub0; < N, oder von C&sub0; - N, wenn C&sub0; &ge; N,
• E3 - Durchführen einer modularen Addition der abgespeicherten Ci und von C&sub0; oder C&sub0; - N, um C mod N zu erhalten.
• Üblicherweise werden die Schritte E0, E2 und E3 durch die Zentraleinheit durchgeführt (Software-Verfahren). Bei dem Schritt E1 werden die Schaltkreise verwendet, die in den Fig. 1 und 2 dargestellt sind, um Hi und Ci · 2i·n-a mod N', zu berechnen.
• Das Verschieben nach links von P(Ci, Hi)N', das auf das Erzeugen von 2a · P(Ci, Hi)N' hinausläuft, kann entweder reell in einem Register oder fiktiv in der Zentraleinheit durchgeführt werden.
• Man kann einen speziell verdrahteten Schaltkreis verwenden, der zur Durchführung von den Schritten E2 und E3 entwickelt wurde. Nichtsdestotrotz wird die Oberfläche der Gruppe aus Zentraleinheit und Coprozessor besser genutzt.
• Wenn c &ge; n, wird selbstverständlich nur der Schritt E2 ausgeführt.
I.2 - Erzeugen von Ci · 2i·n-a mod N', wobei i zwischen 1 und m" - 1 liegt.
• Um Ci · 2i·n-a mod N' zu erzeugen, arbeitet man die folgenden Schritte ab:
• Bei i zwischen 1 und m" - 1:
• R1 - Laden des Parameters Hi in das Register 10 und von Modulo N' in das Register 12 und Initialisieren des Registers 11 auf Null, wobei der Inhalt dieses Registers 11 mit S bezeichnet wird und S ein variabler binärer Datenwert ist, der in n Bits codiert ist,
• R2 - Abarbeiten einer Schleife, die mit s indiziert ist, wobei s zwischen 1 und m' variiert, wobei jede s-te Iteration die folgenden Operationen beinhaltet:
• a) Übertragen des s-ten Wortes Ci,s-1 von Ci in dem Register 16 zu einer Speicherkippstufe 2',
• b) Erzeugen eines Wertes X(s) = S(s-1) + H -Ci,s-1, wobei S(0) = 0 (n Bits auf Null) und S(s-1) der aktualisiert genannte Wert von S ist, der nachfolgend definiert wird durch:
• I - Verschieben nach rechts des Inhalts des Registers 10 zum Eingang des seriell-parallelen Multiplikationsschaltkreises 19 mit Rückschleifen des Ausgangs des Registers 10 an seinen Eingang,
• II - Multiplizieren der Bits von Hi mit Ci,s-1,
• III - Verschieben nach rechts des Inhalts des Registers 12 mit Rückschleifen des Ausgangs dieses Registers an seinen Eingang,
• IV - Bestimmen des aktualisierten Wertes von S(s- 1) als der Wert, der in dem Register 11 nach der (s-1)-ten Iteration abgelegt wird, wenn dieser kleiner als N' ist, und wenn er größer ist, durch serielles Subtrahieren von N' von diesem in dem Subtraktionsschaltkreis z. B., wobei der Ergebniswert der aktualisierte Wert von S(s-1) ist, und
• V - Verschieben nach rechts des Inhalts des Registers 11 und Bit für-Bit-Addieren des Multiplikationswertes Hi · Ci,s-1 zu dem aktualisierten Wert von S(s-1) in dem Additionsschaltkreis 30,
• c) Multiplizieren des Wortes mit dem geringsten Gewicht von X(s), X&sub0;(s) mit J&sub0; zu dem Multiplikationsschaltkreis 20 und Eintragen des Wertes X&sub0;(s) · J&sub0; mod 2k = Y&sub0;(s) in das Register 18 und gleichzeitiges Verzögern von N' und X(s) um k Zyklen in den Verzögerungsschaltkreisen 32 und 34,
• d) Berechnen eines Wertes Z(s) = X'(s) + Y&sub0;(s) · N' durch:
• I - Multiplizieren von Y&sub0;(s) mit N', verzögert um k Zyklen, in dem Multiplikationsschaltkreis 20 und,
• II - Bit für-Bit-Addieren von X(s) zu dem Wert Y&sub0;(s) · N' in dem Additionsschaltkreis 31,
• e) Verwerfen des Wortes, das das geringste Gewicht von Z(s) hat und Abspeichern der übrigen Worte, d. h. T(s)/2k in dem Register 11,
• f) Bit für-Bit-Vergleichen von Z(s)/2k mit N', um den aktualisierten Wert S(s) der folgenden Iteration zu bestimmen, wie es oben beschrieben wurde, wobei dieser Vergleich durchgeführt wird durch Bit für- Bit-Subtraktion von Z(s)/2k und N' in dem Subtraktionsschaltkreis 29, wobei N' um zusätzliche k Zyklen in dem Verzögerungsschaltkreis 33 verzögert wurde,
• g) wobei das s-te Wort von C in das Register 16 zu irgendeinem Zeitpunkt während der obigen Operationen geladen wird;
• R3 - Ignorieren des Wortes mit dem geringsten Gewicht von Z(m) und Eintragen der übrigen Worte, d. h. Z(m)/2k in das Register 10 bei der m-ten Iteration,
• R4 - Ausgeben des Ergebnisses, das in dem Register 10 bei der letzten Iteration abgelegt wurde, eventuell unter Subtraktion von N' in dem Subtraktionsschaltkreis 27, falls notwendig,
I.3 Erzeugen von Hi, wobei i zwischen 1 und m" - 1 liegt.
• Um Hi = 2(i+1)·n-a mod N' zu erzeugen, kann man das bereits existierende Verfahren verwenden (d. h. auf der Grundlage nur von Subtraktionen), indem (i + 1) · n - 1 + 1 Subtraktionen nacheinander durchgeführt werden.
• Man geht wie folgt vor:
• H1 - Laden von Modulo N' in das Register 12 und Initialisieren des Registers 10 auf B(0) = 0 (in Bits auf 0),
• H2 - Ausgeben von N' des Registers 12 durch Verschieben nach rechts mit Rückschleifen an seinen Eingang um 1 - a Bits, um ein Bit mit höchstem Gewicht gleich 1 in dem Register 12 zu erhalten,
• H3 - Erzeugen und Abspeichern eines Datenwertes B(1) = 2 · (B(0) - N"), codiert in n Bits mit N" = N'· 2n-1+a, wobei N" dem im Register 12 gespeicherten Datenwert entspricht, durch
• - Ausgeben von N" und B(0) durch Verschieben nach rechts in den Registern 10 und 12 des Inhalts dieser Register, wobei der Eingang des Registers 10 mit dem Ausgang des Subtraktionsschaltkreises 27 verbunden ist und der Eingang des Registers 12 mit seinem Ausgang verbunden ist,
• - Bit für-Bit-Subtraktion von Bits von N" und B(0) in dem Subtraktionsschaltkreis 27 je nach ihrem Ausgang mit Verschieben nach links um eine Einheit des Ergebnisses, das mit R(0) = B(0) - N" bezeichnet wird, wobei das Verschieben in dem Subtrahierer erfolgt, in dem ein erstes Bit auf 0 ausgegeben wird,
• - Ablegen des Ergebnisses der Subtraktion nach Verschieben, mit B(1) = 2 · R(0) bezeichnet, in das Register 10
• - Bit für-Bit-Subtraktion von B(1) und N" in dem Subtraktionsschaltkreis 40, um zu bestimmen, ob B(1) &ge; oder < N", und Erzeugen von SC = 0 für B(1) &ge; N" bzw. SC = 1 für B(1) < N" durch den Schaltkreis 44,
• H4 - Abarbeiten einer Schleife, die mit dem Index s indiziert ist, wobei s eine ganze Zahl zwischen 1 und (i + 1) · n-l ist, wobei jede Iteration die folgenden Operationen umfaßt:
• - wenn B(i) < N", dann Laden in das Register 10 von B(s + 1) = 2 · (B(s) - 0) = 2 · B(s) nach Verschieben nach links um eine Einheit und Bit für-Bit-Vergleichen von B(s + 1) und N",
• - andernfalls Bit für-Bit-Subtraktion von N" und B(s) mit Verschieben nach links um eine Einheit des Ergebnisses und Laden in das Register 10 von B (s + 1) = 2 · (B (s) - N") und-Bit für-Bit-Vergleichen von B(s + 1) und N",
• H5 - wenn B((i + 1) · n - l + 1) &ge; N": Bit für-Bit-Subtraktion von B((i + 1) · n - l + 1) und N" und Laden des Ergebnisses in das Register 10 mit Verschieben nach rechts um eine Einheit des Resultats.
• Man hat 2n+(i+1)·n-l mod N" in dem Register 10.
• H6 - Verschieben nach rechts um n - l + a Bits in den Registern 10 und 12. Diese Register enthalten dann jeweils 2n+i·n-a mod N' und N'.
I.4 - Modifiziertes Berechnen von H.
• Man sieht, daß je größer m" ist, desto größer ist die Zahl der Subtraktionen. In dieser Sicht verschlechtert sich die Rechenzeit, wobei jede Subtraktion n Zyklen benötigt, um die n Bits zu verschieben, die in den Registern 10 und 12 abgelegt sind.
• Eine Variante ist denkbar, die darin besteht, die Subtraktionen nur für den Fehlerkorrekturparameter H&sub1; in Zusammenhang mit i = 1 durchzuführen, dann die Fehlerkorrekturparameter Hi, die mit den größeren Indizes zusammenhängen, zu erhalten, indem die Operationen Pfield durchgeführt werden.
• Man geht wie folgt vor:
• - Erzeugen von H&sub1; = 22·n-a mod N' (2 · n - l + 1 Subtraktionen),
• - bei i > 1:
• - Berechnen von p (i) = Ent [log&sub2; (i · n/ (n - a))] + 1 in der Zentraleinheit (Software-Verfahren), wobei Ent den Operator "ganzzahliger Anteil" bezeichnet,
• - Abarbeiten von p(i) Operationen Pfield mit Hilfe des Schaltkreises nach Fig. 1 (es sei auf die Beschreibung Seite 19, Zeile 50 bis Seite 20, Zeile 45 der genannten europäischen Patentanmeldung verwiesen):
• Hi,t = P(Hi, t-1, Hi, t-1)N' = 2n+2exp(t)·(n-a)mod N',
• wobei t der Index zwischen 1 und p (i) ist und Hi,0 = H&sub1; gilt.
• Man erhält:
• Hi,p(i) 2n+2exp(p(i))·(n-a) mod N', wobei exp die Exponentialfunktion bedeutet,
• - Berechnen von r = 2p(i) · (n - a) - i · n + a in der Zentraleinheit (Software-Verfahren), wenn r > n, Abspeichern von Hi,p(i), dann Berechnen von 2n-r mod N' durch adäquate Kombination von Pfield Operationen.
• Die Berechnung von 2n-r mod N' erfolgt auf die folgende Art und Weise:
• - adäquate Auswahl von binären Datenwerten Di = 2-x(i)·n+y(i)·a mod N', die zusammengehörige Paare aus ganzen Zahlen (x(i), y(i)) bilden,
• - Abarbeiten von Operationen P(Di, Dj)N' = 2-(x(i)+x(j)+1)·n+(y(i)+y(1))·a mod N' zum Bestimmen von 2n-r mod N' = 2-x-n+y·a mod N'.
• - Ausgeben des Datenwertes Hi, p(i), wenn n - r &ge; 0 (oder von 2n-r mod N', wenn n - r < 0), codiert in n Bits, an den seriellen Ausgang des Multiplikationsschaltkreises 19 und paralleles Ausgeben von 2n-r (oder von Hi, p(i), wenn n - r < 0), codiert in n Bits, an den parallelen Eingang des gleichen Multiplikationsschaltkreises, um Hi zu erhalten.
• Man hat so Hi - 2(i+1)·n-a mod N'.
II - Teilen von M in Datenwerte mit 1 Bits.
• Ein weiteres Verfahren besteht darin, C in eine ganze Zahl von Bits zu unterteilen, die ein Vielfaches von 1 sei.
II.1 Verfahren
• Wenn w > 1, kann man schreiben C = &Sigma;i Ci · 2i·l, wobei i zwischen 0 und w - 1 variiert wird.
• Man folgert daraus:
• C mod N = (&Sigma;i Ci · 2i·1) mod N
• = (&Sigma;i(Ci · 2i·l mod N)) mod N
• = [(&Sigma;i(Ci · 2i·l-a mOd N')) mod N'] · 2a.
• Es reicht, die folgenden Schritte abzuarbeiten:
• E0 - Erzeugen von J&sub0;(N'), wobei der Datenwert binär in k Bits codiert ist,
• E1 - für i zwischen 1 und w - 1 Durchführen der folgenden Operationen:
• - Erzeugen von Hi = 2n+i·l-a mod N' = 2f(C, N) mod N' mit f(C, N) = n + i · l - a,
• - Ausgeben von Ci, codiert in n Bits, am parallelen Eingang des Multiplikationsschaltkreises 19 und von H&sub1;, codiert in n Bits, am seriellen Eingang desselben Multiplikationsschaltkreises, um Ci · 2i·l-a mod N' zu erhalten,
• - Verschieben des Ergebnisses nach links um a Bits, um Ci · 2i·l mod N zu erhalten, und Abspeichern des Ergebnisses,
• E2 - bei i = 0 Abspeichern von C&sub0;, wenn C&sub0; < N, und von C&sub0; - N, wenn C&sub0; &ge; N,
• E3 - Durchführen einer modularen Addition der gespeicherten Ci und C&sub0; oder C&sub0; - N, um C mod N zu erhalten.
• Zum Durchführen der Berechnung von Hi und Ci · 2i·l-a mod N' verfährt man analog wie bei dem vorherigen Verfahren.
II.2 - Erzeugen von Ci · 2i·l-a mod N', wobei i zwischen 1 und w - 1 variiert.
• Zum Berechnen von den Werten Ci · 2i·l-a mod N' geht man nach den folgenden Schritten vor:
• Bei i zwischen 1 und w - 1:
• R1 - Laden des Parameters Hi = 2n+i·l-a mod N' in das Register 10 und von Modulo N' in das Register 12 und Initialisieren des Registers 11 mit n Bits auf Null, wobei der Inhalt dieses Registers 11 mit S bezeichnet wird, wobei S ein variabler binärer Datenwert ist, der in n Bits codiert ist,
• R2 - Durchführen einer Schleife, die mit s indiziert ist, wobei s zwischen 1 und m variiert, wobei jede s-te Iteration die folgenden Schritte umfaßt:
• a) Übertragen des s-ten Wortes Ci, s-1 des Datenwertes Ci des Registers 16 an die Speicherkippstufe 21,
• b) Erzeugen eines Wertes X(s) = S(s - 1) + Hi · Ci, s-1 mit S(0) = 0 (n Bits auf Null) und S (s - 1) als aktualisiert genanntem Wert von S, der im folgenden definiert wird durch:
• I - Verschieben nach rechts des Inhalts des Registers 10 zum Eingang des seriell-parallelen Multiplikationsschaltkreises 19 mit Rückschleifen des Ausgangs des Registers 10 an seinen Eingang,
• II - Multiplizieren der Bits von Hi mit Ci, s-1,
• III - Verschieben nach rechts des Inhalts des Registers 12 mit Rückschleifen des Ausgangs dieses Registers an seinen Eingang,
• IV - Bestimmen des aktualisierten Wertes von S(s - 1) als der Wert, der in dem Register 11 nach der (s-1)-ten Iteration abgelegt ist, wenn dieser kleiner als N' ist, und wenn er größer ist, durch serielle Subtraktion von N' davon in dem Subtraktionsschaltkreis 28, wobei der sich ergebende Wert der aktualisierte Wert von S(s - 1) ist, und
• V - Verschieben nach rechts des Inhalts des Registers 11 und Bit für-Bit-Addieren des Wertes der Multiplikation Hi · Ci, s-1 mit dem aktualisierten Wert von S(s - 1) in dem Additionsschaltkreis 30,
• c) Multiplizieren in dem Multiplikationsschaltkreis 20 des Wortes mit dem geringsten Gewicht von X(s), X&sub0;(s), mit J&sub0; und Eintragen des Wertes X&sub0;(s) · J&sub0; mod 2k = Y&sub0;(s) in dem Register 18 und gleichzeitiges Verzögern von N' und X(s) um k Zyklen in den Verzögerungsschaltkreisen 32 und 34,
• d) Berechnen eines Wertes Z(s) = X(s) + Y&sub0;(s) · N' durch:
• I - Multiplizieren von Y&sub0;(s) mit N', das um k Zyklen verzögert ist, in dem Multiplikationsschaltkreis 20, und
• II - Bit für-Bit-Addieren von X(s) zu dem Wert Y&sub0;(s) · N' in dem Additionsschaltkreis 31,
• e) Verwerfen des Wortes mit dem geringsten Gewicht von Z(s) und Abspeichern der restlichen Worte, d. h. Z(s)/2k, in dem Register 11,
• f) Bit für-Bit-Vergleichen von Z(s)/2k mit N' mit dem Ziel, den aktualisierten Wert S(s) der folgenden Iteration auf die oben beschriebene Art und Weise zu bestimmen, wobei dieser Vergleich durch Bit für- Bit-Subtraktion von Z(s)/2k und N' in den Subtraktionsschaltkreis 29 erfolgt, wobei N' um zusätzliche k Zyklen in dem Verzögerungsschaltkreis 33 verzögert wurde,
• g) wobei das s-te Wort von Ci in das Register 16 zu irgendeinem Zeitpunkt während der obigen Operationen abgelegt wird;
• R3 - bei der m-ten Iteration Verwerfen des Wortes mit dem geringsten Gewicht von Z(m) und Eintragen der restlichen Worte, d. h. Z(m)/2k, in dem Register 10,
• R4 - Ausgeben des in dem Register 10 gespeicherten Ergebnisses bei der letzten Iteration, u. U. nach Abzug von N', falls nötig, mittels Subtraktionsschaltkreis 27.
II.3 - Erzeugen von Hi, wobei i zwischen 1 und w - 1 variiert.
• Um Hi = 22+i·l-a mod N' zu erzeugen, kann man das bereits existierende Verfahren verwenden (d. h. auf der Basis lediglich von Subtraktionen), indem man nacheinander i · l + n - l + 1 Subtraktionen durchführt.
• Man geht auf die folgende Art und Weise vor:
• H1 - Laden von Modulo N' in das Register 12 und Initialisieren des Registers 10 auf B(0) = 0 (n Bits auf 0),
• H2 - Ausgeben von N, des Registers 12 durch Verschieben nach rechts mit Rückschleifen an seinen Eingang um 1 - a Bits, um ein Bit mit höchstem Gewicht in dem Register 12 zu haben, das 1 ist,
• H3 - Erzeugen und Abspeichern eines Datenwertes B(1) = 2 · (B(0) - N"), codiert in n Bits mit N" = N' · 2n-1+a, was dem binären Datenwert in dem Register 12 entspricht, durch
• - Ausgeben von N" und B(0) durch Verschieben nach rechts in den Registern 10 und 12 des Inhalts dieser Register, wobei der Eingang des Registers 10 mit dem Ausgang des Subtraktionsschaltkreises 27 und der Eingang des Registers 12 mit seinem Ausgang verbunden ist,
• - Bit für-Bit-Subtraktion je nach ihrem Ausgang von Bits von N" und B(0) in dem Subtraktionsschaltkreis 27 mit Verschieben nach links um eine Einheit des Ergebnisses, das mit R(0) = B(0) - N" bezeichnet wird, wobei das Verschieben in dem Subtrahierer unter Ausgabe eines ersten Bits auf 0 erfolgt,
• - Ablegen des Ergebnisses der Subtraktion nach Verschieben, mit B(1) = 2 · R(0) bezeichnet, in das Register 10,
• - Bit für-Bit-Subtraktion von B(1) und N" in dem Subtraktionsschaltkreis 40, um zu bestimmen, ob B(1) &ge; oder < N" und Erzeugen von SC = 0 für B(1) &ge; N" bzw. SC = 1 für B(1) < N" in dem Schaltkreis 44,
• H4 - Durchführen einer Schleife, die mit dem Index i indiziert ist, wobei i eine ganze Zahl zwischen 1 und n + i · 1 - 1 ist, wobei jede i-te Iteration die folgenden Operationen umfaßt:
• - wenn B(i) < N", dann Laden in das Register 10 von B (s + 1) = 2 · (B(s) - 0) = 2 · B (s) nach Verschieben nach links um eine Einheit und Bit für-Bit-Vergleichen von B(s + 1) und N",
• - andernfalls Bit für-Bit-Subtraktion von N" und B(s) mit Verschieben nach links um eine Einheit und Laden in das Register 10 von B (s + 1) = 2 · (B (s) - N") und Bit für-Bit-Vergleichen von B(s + 1) und N",
• H5 - wenn B(n + i · l - l + 1) &ge; N": Bit für-Bit-Subtraktion von B(n + i · l - l + 1) und N" und Laden des Ergebnisses in das Register 10 mit Verschieben nach rechts um eine Einheit des Ergebnisses.
• Man hat 22·n+i·l-1 mod N" in dem Register 10.
• H6 - Verschieben nach rechts um n - l + a Bits in den Registern 10 und 12. Diese Register enthalten dann jeweils 2n+i·l-a mod N' und N'.
II.4 - Modifiziertes Erzeugen von H.
• Eine Variante ist denkbar, die analog zu der bereits beschriebenen ist:
• - Erzeugen von H&sub1; = 2n+l-a mod N' (n + 1 Subtraktionen),
• - bei i > 1:
• - Berechnen von p(i) = Ent[log&sub2;(i · l/(l - a))] + 1
• - Durchführen von p(i) Operationen Pfield mit Hilfe des Schaltkreises nach Fig. 1:
• Hi, t = P(Hi, t-1, Hi, t-1)N' = 2n+2exp(t)·(l-a) mod N' wobei t ein Index zwischen 1 und p (i) ist und Hi, &sub0; = H&sub1;.
• Man erhält:
• Hi, p(i) = 2n+2exp(p(i))·(l-a) mod N', wobei exp die Exponentialfunktion ist,
• - Berechnen von r = 2p(i) · (l - a) - i · l + a in einer Zentraleinheit (Software-Verfahren), wenn r > m, Abspeichern von Hi, p(i), dann Berechnen von 2n-r mod N' durch adäquate Kombinationen von Pfield- Multiplikationen.
• Die Berechnung von 2n-r mod N' erfolgt auf die folgende Art und Weise:
• - adäquate Auswahl von Di = 2-x(i)·n+y(i)·a mod N', die zu den Paaren ganzer Zahlen (x(i), y(i)) gehören,
• - Folge von Berechnungen von P(Di, Dj)N' = 2-(x(i)+x(j)+1)·n+(y(i)+y(j))·a mod N' zum Erhalten von 2n-r mod N' = 2-x·n+y·a mod N'
• - Ausgeben von Hi, p(i), wenn n - r &ge; 0 (oder von 2n-r mod N', wenn n - r < 0), codiert in n Bits, an den seriellen Eingang des Multiplikationsschaltkreises 19 und Parallelausgeben von 2n-r (oder von Hi, p(i) wenn n - r < 0), codiert in n Bits, an den parallelen Eingang desselben Multiplikationsschaltkreises, um Hi zu erhalten.
• Man hat somit Hi = 2n+i·1-a mod N'.
III - Sukzessive Ausgabe von Worten von C an den Multiplikationsschaltkreis.
• Es sei:
• - N codiert in u · k Bits, wobei u · k - l Bits mit dem höchsten Gewicht auf Null sind, und
• - C in m' · k Bits codiert, wobei m' · k - c Bits mit dem größten Gewicht Null sind.
• Tatsächlich reichen u Worte mit k Bits, um N sicher zu bestimmen. Desgleichen reichen m' Worte mit k Bits, um C sicher zu bestimmen.
• Der Erfinder schlägt zwei Arten der Modifikation vor:
• - Das Register 16 m'-mal zu verwenden, d. h. nur eine einzige Operation Pfield durchzuführen, indem nacheinander alle Worte von C ausgegeben werden,
• - Berechnen des Fehlerkorrekturparameters H in Zusammenhang mit dieser Operation.
III.1 - Verfahren.
• Es reicht, die folgenden Schritte auszuführen:
• E0 - Erzeugen von J&sub0;(N') mit Hilfe der Zentraleinheit,
• E1 - Erzeugen von H = 2m'·k-a mod N' = 2f(C, N) mod N', wobei f(C, N) = m' · k - a, unter Verwendung des Coprozessors,
• E3 - Ausgeben von C, codiert in m' · k Bits, an den seriellen Eingang des Multiplikationsschaltkreises 19 und von H, codiert in m Bits, an den parallelen Eingang desselben Multiplikationsschaltkreises, um P (C, H)N' = C · 2-a mod N' zu erhalten,
• E4 - Verschieben des Resultates nach links um a Bits, um 2a · P(C, H)N' = C mod N zu erhalten (wobei dieser Schritt in der Zentraleinheit durchgeführt werden kann).
• In der Praxis ist die verwendbare Größe von H kleiner oder gleich der verwendbaren Größe von N', d. h. kleiner oder gleich der Größe von N und daher kleiner oder gleich n.
III.2 - Erzeugen von C · 2-a mod N'.
• Man geht auf die folgende Art vor:
• R1 - Laden des Parameters H in das Register 10 und von Modulo N' in das Register 12 und Initialisieren des Registers 11 mit n Bits auf Null, wobei der Inhalt dieses Registers 11 mit S bezeichnet wird, wobei S ein variabler binärer Datenwert ist, der in n Bits codiert ist,
• R2 - Durchführen einer Schleife, die mit s indiziert ist und bei der s zwischen 1 und m' variiert, wobei jede s-te Iteration die folgenden Operationen umfaßt:
• a) Übertragen des s-ten Wortes Cs-1 von C in dem Register 16 an die Speicherkippstufe 21,
• b) Erzeugen eines Wertes X(s) = S(s - 1) + H · Ss-1 mit S(O) = 0 (n Bits auf Null) und S(s-1) als aktualisiert genanntem Wert von S, das im Nachfolgenden definiert wird durch:
• I - Verschieben nach rechts des Inhalts des Registers 10 zum Eingang des seriell-parallelen Multiplikationsschaltkreises 19 mit Rückschleifen des Ausgangs des Registers 10 an seinen Eingang,
• II - Multiplizieren der Bits von H mit Cs-1,
• III - Verschieben nach rechts des Inhalts des Registers 12 mit Rückschleifen des Ausgangs dieses Registers an seinen Eingang,
• IV - Bestimmen des aktualisierten Wertes von S(s - 1) als derjenige Wert, der in dem Register 11 nach der (s-1)-ten Iteration abgelegt wird, wenn dieser kleiner als N ist, und wenn er größer ist, indem seriell N von diesem in dem Subtraktionsschaltkreis 28 abgezogen wird, wobei der Ergebniswert der aktualisierte Wert von S(s - 1) ist, und
• V - Verschieben nach rechts des Inhalts des Registers 11 und Bit für-Bit-Addieren des Wertes der Multiplikation H · Cs-1 zu dem aktualisierten Wert von S(s - 1) in dem Additionsschaltkreis 30.
• c) Multiplizieren des Wortes mit dem geringsten Gewicht von X(s), X&sub0;(s), mit J&sub0; in dem Multiplikationsschaltkreis 20 und Eingeben des Wertes X&sub0;(s) · J&sub0; mod 2k = Y&sub0;(s) in das Register 18 und gleichzeitiges Verzögern von N' und X(s) um k Zyklen in den Verzögerungsschaltkreisen 32 und 34,
• d) Berechnen eines Wertes Z(s) = X(s) + Y&sub0;(s) · N' durch:
• I - Multiplizieren von Y&sub0;(s) mit N', verzögert um k Zyklen, in dem Multiplikationsschaltkreis 20 und
• II - Bit für-Bit-Addieren von X(s) zu dem Wert Y&sub0;(s) · N' in dem Additionsschaltkreis 32,
• e) Verwerfen des Wortes mit dem geringsten Gewicht von Z(s) und Abspeichern der übrigen Worte, d. h. Z(s)/2k, in das dritte Register 11,
• f) Bit für-Bit-Vergleichen von Z(s)/2k mit N', um den aktualisierten Wert S(s) der folgenden Iteration zu bestimmen, wie es oben beschrieben wurde, wobei dieser Vergleich durch Bit für-Bit-Subtraktion von Z(s)/2k und N' erfolgt, wobei N' um zusätzliche k Zyklen in dem Verzögerungsschaltkreis 33 verzögert ist,
• g) wobei das s-te Wort von C in dem Register 16 zu irgendeinem Zeitpunkt während der obigen Operationen abgelegt worden ist;
• R3 - Ignorieren des Wortes mit dem geringsten Gewicht von Z(m') und Eintragen der übrigen Worte, d. h. Z(m')/2k, in das Register 10 bei der m'-ten Iteration,
• R4 - Ausgeben des Ergebnisses, das in dem Register 10 bei der letzten Iteration abgelegt worden ist, eventuell mit Subtraktion von N', falls notwendig.
• R5 - Verschieben des Ergebnisses um a Bits nach links.
• Das oben beschriebene Verfahren erlaubt es, die Zahl von notwendigen Schritten für die Erzeugung von C mod N zu minimieren.
• Man verringert somit in hohem Maße die Rechenzeit.
III.3 - Erzeugen von H = 2m'·k-a mod N'.
• Es sei angenommen, daß die nutzbare Größe von N' u Worte mit k Bits sei.
• Die Zahl der verwendbaren Bits von N' ist l' = l - a.
• Man geht auf die folgende Art und Weise vor:
• H1 - Laden von Modulo N' in das Register 12 und Initialisieren des Registers 10, wobei der Inhalt des Registers B(0) (n Bits auf 0) genannt wird, und Initialisieren des Registers 44 (d. h. Erzeugen eines Signals RES, so daß SC = 0),
• H2 - Ausgeben von N' des Registers 12 durch Verschieben nach rechts mit Rückschleifen an seinen Eingang um 1 - a Bits, wobei 1 - a die Zahl der verwendbaren Bits von N' ist, um ein Bit mit höchstem Gewicht gleich 1 im Register 12 zu haben,
• H3 - Erzeugen und Abspeichern eines Datenwertes B(1) = 2 · (B(0) - N"), codiert in n Bits mit N" = N' · 2n-1+a, wobei N" dem binären Datenwert im Register 22 entspricht, durch
• - Ausgeben von N" und B(0) durch Verschieben nach rechts in den Registern 10 und 12 des Inhalts dieser Register, wobei der Eingang des Registers 10 mit dem Ausgang des Subtraktionsschaltkreises 27 und der Eingang des Registers 12 mit seinem Ausgang verbunden ist,
• - Bit für-Bit-Subtraktion von Bits von N" und B(0) je nach ihrem Ausgang in dem Subtraktionsschaltkreis 27 mit Verschieben nach links um eine Einheit des Ergebnisses, das mit R(0) = B(0) - N" bezeichnet wird,
• - Ablegen des Ergebnisses der Subtraktion nach Verschieben, mit B(1) = 2 · R(0) bezeichnet, in das Register 10,
• - Bit für-Bit-Subtraktion von B(1) und N" in dem Subtraktionsschaltkreis 40, um zu bestimmen, ob B(1) &ge; oder < N", und Erzeugen von SC = 0 bei B (1) &ge; N" und SC = 1 bei B(1) < N" in dem Schaltkreis 44,
• H4 - Erzeugen eines Datenwertes Hint = 2t mod N" mit t = n - 1 + a + u · k + (m' - u) - k/2r, wobei r eine ganze Zahl ist, so daß k/2r eine ganze Zahl ist, durch:
• Durchführen einer Schleife, die mit dem Index i indiziert ist, wobei i eine ganze Zahl zwischen 1 und t - n ist, wobei jede i-te Iteration die folgenden Operationen umfaßt:
• - wenn B(i) < N", dann Laden in das Register 10 von B(i + 1) = 2 · (B(i) - 0) = 2 · B(i) nach Verschieben nach links von B(i) um eine Einheit und Bit für- Bit-Vergleichen von B(i + 1) und N",
• - andernfalls Bit für-Bit-Subtraktion von N" und B(i) mit Verschieben nach links um eine Einheit des Ergebnisses und Laden in das zweite Register von B(i + 1) = 2 - (B(i) - N") und-Bit für-Bit-Vergleichen von B(i + 1) und N",
• H5 - wenn B(t - n + 1) &ge; N": Bit für-Bit-Subtraktion von B(t - n + 1) und N" in dem Subtraktionsschaltkreis 27, was 2 · (B(t - n + 1) - N") ergibt und Laden in das Register 10 von B(t - n + 1) - N", was ein Verschieben nach rechts um eine Einheit erfordert,
• H6 - Verschieben nach rechts um n - l + a Bits in den Registern 10 und 12.
• Man hat damit N' in dem Register 12.
• H7 - Erzeugen des Parameters H durch Durchführen von r Pfield-Operationen
• Hint(j) = P(Hint(j - 1), Hint (j - 1))N' mit j als Index zwischen 1 und r, und Hint (0) = B(t - n + 1) · 2l-n-a oder (B(t - n + 1) - N") · 2l-n-a,
• Hint(0) befindet sich in dem Register 10 nach dem Verschieben in dem Schritt H6.
• Man hat somit Hint(r) = 2m'·k mod N'.
• H8 - Erzeugen des Parameters H durch Durchführen einer Pfield-Operation:
• H = P(Hint(r), 2u·k-a)N', wobei Hint(r) an einen seriellen Eingang des Multiplikationsschaltkreises 19 ausgegeben wird und 2u·k-a an den parallelen Eingang desselben Multiplikationsschaltkreises ausgegeben wird.
• Man erhält so H = 2m'·k-a mod N'.
• Man hat selbstverständlich davon auszugehen, daß die r + 1 Operationen Pfield in demselben Sinne wie bei dem oben beschriebenen Verfahren durchgeführt werden. Das bedeutet, daß man an den parallelen Eingang des Multiplikationsschaltkreises 19 bei jeder Operation u Worte mit k Bis ausgibt.
IV - Modulare Reduktion für ein ungerades Modul.
• Man adaptiert die oben beschriebenen Verfahren in dem Abschnitt III.
• Es reicht, auf die folgende Art und Weise vorzugehen:
• - Berechnen von J&sub0;(N) mit Hilfe der Zentraleinheit,
• - Berechnen von H = 2m'·k mod N = 2f(C, N) mod N mit f(C, N) = m' · k unter Verwendung des Coprozessors,
• - Ausgeben von C, codiert in m' · k Bits, an den seriellen Eingang des Multiplikationsschaltkreises 19 und von H, codiert in n Bits, an den parallelen Eingang desselben Multiplikationsschaltkreises, um P(C, H)N = C mod N zu erhalten.
• In der Praxis ist die verwendbare Größe von H kleiner oder gleich der verwendbaren Größe von N, d. h. kleiner oder gleich der Größe von N und daher kleiner oder gleich n.
IV.1 - Erzeugen von C mod N.
• Man geht auf die folgende Art und Weise vor:
• R1 - Laden des Parameters H in das Register 10 und von Modulo N in das Register 12 und Initialisieren des Registers 11 mit n Bits auf Null, wobei der Inhalt des Registers 11 mit S bezeichnet wird, wobei S ein variabler binärer Datenwert ist, der in n Bit codiert ist,
• R2 - Durchführen einer Schleife, der mit s indiziert ist und bei der s zwischen 1 und m' variiert, wobei jede s-te Iteration die folgenden Operationen umfaßt:
• a) Übertragen des s-ten Wortes Cs-l von C in dem Register 16 an eine Speicherkippstufe,
• b) Erzeugen eines Wertes X(s) = S(s-1) + H · Cs-1 mit S(0) = 0 (n Bits auf Null) und S(s - 1) als aktualisiert genanntem Wert von 5, das im folgenden definiert wird durch:
• I - Verschieben nach rechts des Inhalts des Registers 10 zum Eingang des seriell-parallelen Multiplikationsschaltkreises 19 mit Rück schleifen des Ausgangs des Registers 10 an seinen Eingang,
• II - Multiplizieren der Bits von H mit Cs-1,
• III - Verschieben nach rechts des Inhalts des Registers 12 mit Rückschleifen des Ausgangs dieses Registers an seinen Eingang,
• IV - Bestimmen des aktualisierten Wertes von S(s - 1) als derjenige Wert, der in dem Register 11 nach der (s-1)-ten Iteration abgelegt wird, wenn dieser kleiner als N ist, und wenn er größer ist, indem seriell N von diesem in dem Subtraktionsschaltkreis 28 abgezogen wird, wobei der Ergebniswert der aktualisierte Wert von S(s - 1) ist, und
• V - Verschieben nach rechts des Inhalts des Registers 11 und Bit für-Bit-Addieren des Wertes der Multiplikation H · Cs-1 zu dem aktualisierten Wert von S(s - 1) in dem Additionsschaltkreis 30,
• c) Multiplizieren des Wortes mit dem geringsten Gewicht von X(s), X&sub0;(s), mit J&sub0; in dem Multiplikationsschaltkreis 20 und Eingeben des Wertes X&sub0;(s) · J&sub0; mod 2k = Y&sub0;(s) in das Register 18 und gleichzeitiges Verzögern von N und X(s) um k Zyklen in den Verzögerungsschaltkreisen 32 und 34,
• d) Berechnen eines Wertes Z(s) = X(s) + Y&sub0;(s) · N durch:
• I - Multiplizieren von Y&sub0;(s) mit N, verzögert um k Zyklen, in dem Multiplikationsschaltkreis 20 und
• II - Bit für-Bit-Addieren von X(s) zu dem Wert Y&sub0;(s) · N in dem Additionsschaltkreis 31,
• e) Verwerfen des Wortes mit dem geringsten Gewicht von Z(s) und Abspeichern der übrigen Worte, d. h. Z(s)/2k, in dem dritten Register 11,
• f) Bit für-Bit-Vergleichen von Z(s)/2k mit N, um den aktualisierten Wert S(s) der folgenden Iteration zu bestimmen, wie es oben beschrieben wurde, wobei dieser Vergleich durch Bit für-Bit-Subtraktion von Z(s)/2k und N in dem Subtraktionsschaltkreis 29 erfolgt, wobei N um zusätzliche k Zyklen in dem Verzögerungsschaltkreis 33 verzögert ist,
• g) wobei das s-te Wort von C in dem Register 16 zu irgendeinem Zeitpunkt während der obigen Operationen abgelegt worden ist;
• R3 - Ignorieren des Wortes mit dem geringsten Gewicht von Z(m') und Eintragen der übrigen Worte, d. h. Z(m')/2k, in das Register 10 bei der m'-ten Iteration,
• R4 - Ausgeben des Ergebnisses, das in dem Register 10 bei der letzten Iteration abgelegt worden ist, eventuell mit Subtraktion von N mittels Subtraktionsschaltkreis 27 falls notwendig.
IV.2 - Erzeugen von H = 2m'·k mod N.
• Man geht davon aus, daß die verwendbare Größe von N u Worte mit k Bits ist.
• Die Zahl der verwendbaren Bits von N ist 1.
• Man geht auf die folgende Art und Weise vor:
• H1 - Laden von Modulo N in das Register 12 und Initialisieren des Registers 10, wobei der Inhalt des zweiten Registers B(0) (n Bits auf o) genannt wird, und Initialisieren des Registers 44 (d. h. Erzeugen eines Signals RES, so daß SC = 0),
• H2 - Ausgeben von N des Registers 12 durch Verschieben nach rechts mit Rückschleifen an seinen Eingang um 1 Bits, wobei 1 die Zahl der verwendbaren Bits von Modulo N ist, um ein Bit mit dem höchsten Gewicht auf 1 in dem Register 12 zu haben,
• H3 - Erzeugen und Abspeichern eines Datenwertes B(1) = 2 · (B(0) - N'), codiert in n Bits mit N' = N · 2n-1, wobei N' dem binären Datenwert in dem Register 12 entspricht, durch
• - Ausgeben von N' und B(0) durch Verschieben nach rechts in den Registern 10 und 12 des Inhalts dieser Register, wobei der Eingang des Registers 10 mit dem Ausgang des Subtraktionsschaltkreises 27 und der Eingang des Registers 12 mit seinem Ausgang verbunden ist,
• - Bit für-Bit-Subtraktion von Bits von N' und B(0) je nach ihrem Ausgang in dem Subtraktionsschaltkreis 27 mit Verschieben nach links um eine Einheit des Ergebnisses, das mit R(0) = B(0) - N' bezeichnet wird,
• - Ablegen des Ergebnisses der Subtraktion nach Verschieben, mit B(1) = 2 · R(0) bezeichnet, in das Register 10,
• - Bit für-Bit-Subtraktion von B(1) und N' in dem Subtraktionsschaltkreis 40, um zu bestimmen, ob B(1) &ge; oder < N', und Erzeugen von SC = 0 bei B(1) &ge; N' und SC = 1 bei B(1) < N' durch den Schaltkreis 44,
• H4 - Erzeugen eines Datenwertes Hint = 2t mod N' mit t = n - l + u · k + (m' - u) · k/2r, wobei r eine ganze Zahl ist, so daß k/2r eine ganze Zahl ist, durch:
• Durchführen einer Schleife, die mit dem Index i indiziert ist, wobei i eine ganze Zahl zwischen 1 und t - n ist, wobei jede i-te Iteration die folgenden Operationen umfaßt:
• - wenn B(i) < N', dann Laden in das Register 10 von B(i + 1) = 2 · (B(i) - 0) = 2 · B(i) nach Verschieben nach links von B(i) um eine Einheit und Bit für- Bit-Vergleichen von B(i + 1) und N',
• - andernfalls Bit für-Bit-Subtraktion von N' und B(i) mit Verschieben nach links um eine Einheit des Ergebnisses und Laden in das Register 10 von B(i + 1) = 2 · (B(i) - N') und Bit für-Bit-Vergleichen von B(i + 1) und N',
• H5 - wenn B(t - n + 1) &ge; N': Bit für-Bit-Subtraktion von B(t - n + 1) und N' in dem Subtraktionsschaltkreis 27, was 2 · (B(t - n + 1) - N' ergibt und Laden in das Register 10 von B(t - n + 1) - N', was ein Verschieben nach rechts um eine Einheit erfordert,
• H6 - Verschieben nach rechts um n - 1 Bits in den Registern 10 und 12.
• Man hat daher N in dem Register 12.
• H7 - Erzeugen des Parameters H durch Durchführen von r Pfield-Operationen:
• Hint(j) = P(Hint(j - 1), Hint (j - 1))N mit j als Index zwischen 1 und r, und Hint(0) = B(t - n + 1) · 21-n oder (B(t - n + 1) - N") · 2l-n, wobei Hint(0) = 2t' mod N mit t' = u · k + (m' - u) · k/2r.
• Hint(0) befindet sich in dem Register 10 nach dem Verschieben in Schritt H6.
• Man erhält so Hint(r) = H = 2m'·k mod N.
• Man muß selbstverständlich davon ausgehen, daß die r Operationen Pfield in demselben Sinne durchgeführt werden wie bei dem oben beschriebenen Verfahren. Das bedeutet, daß man an dem parallelen Eingang des Multiplikationsschaltkreises 19 bei jeder Operation u Worte mit k Bits ausgibt.
• In bezug auf den Schaltkreis, wie er beim Stand der Technik existiert, muß man selbstverständlich den Sequenzierer schaltkreis modifizieren, der notwendige Steuersignale für die Funktion des in Fig. 1 dargestellten Schaltkreises erzeugt. So muß man insbesondere bei dem letzten beschriebenen Verfahren einen programmierbaren Zähler verwenden, um einerseits die Verwendung des Registers 16, damit man die variable Anzahl der Verwendungen dieses Registers benutzen kann, und andererseits die Verschiebungen in den Registern beim Erzeugen von H in Abhängigkeit von der Zahl von verwendbaren Bits von Modulo N (oder von N', wenn N gerade ist) zu verwalten.
• In dem Schaltkreis, wie er im Stand der Technik existiert, verwendet man die Register 10, 11 und 12, die in Register mit 8 oder 16 Worten à 32 Bit konfigurierbar sind. Wenn man die Rechenzeit noch weiter verringern möchte, die für eine modulare Operation benötigt wird, kann man Register, die zwischen 1 und 16 Worten à 32 Bit konfigurierbar sind, verwenden, d. h. in der Praxis m = u wählen. Dazu reicht es, zusätzliche Multiplexer in dem Rechenschaltkreis auf Höhe der Register 10, 11 und 12 hinzuzufügen. Dadurch wird es möglich, daß allerdings auf Kosten des Umfangs die notwendige Zeit für die Verschiebungen in den Registern 10, 11 und 12 verringert wird.
• Ein Vorteil der Möglichkeit der modularen Reduktion mit geradem oder ungeradem Modul ist die Anwendung, die besonders beim Durchführen der Verschlüsselung nach dem RSA-Verfahren vorteilhaft ist.
RSA-Verfahren.
• Bei dem RSA-Verschlüsselungsverfahren müssen Berechnungen vom Typ C = MD mod N durchgeführt werden, wobei M eine zu verschlüsselnde oder entschlüsselnde Nachricht ist, N ein Modul, so daß N = P · Q, mit P und Q als Primzahlen, und D die Bedingung erfüllt D · E = 1 mod ((P - 1) · (Q - 1)), wobei E bekannt ist.
• Ein Algorithmus zum Durchführen der Berechnung ist der folgende:
• A = (M mod p) D mod (P &supmin; 1) mod P
• B = (M mod Q) D mod (Q &supmin; 1) mod Q
• U = Q&supmin;¹ mod P
• Wenn A < B mod P, dann gilt:
• C = (((A + P - (B mod P) · U) mod P) · Q + B.
• Andernfalls gilt:
• C = (((A - (B mod P)) · U) mod P) · Q + B.
• Dieser Algorithmus beinhaltet also:
• - 2 modulare Reduktionen,
• - 2 modulare Potenzierungen,
• - 1 modulare Multiplikation.
• Man kann die Erfindung einsetzen, um zu berechnen:
• - D mod (P - 1) und D mod (Q - 1), wobei P - 1 und Q - 1 gerade Zahlen sind,
• - M mod P und M mod Q, wobei P und Q ungerade Zahlen sind.
Suche nach Primzahlen.
• Das RSA-Verfahren, das oben beschrieben wurde, erfordert es, zwei Primzahlen P und Q festzulegen. Um eine zu einfache a posteriori-Bestimmung dieser Zahlen zu verhindern, ist es wünschenswert, sehr große Zahlen zu suchen, z. B. codiert in 256 Bits.
• Eine bekannte Technik zum Auswählen von Primzahlen, die sehr groß sind, besteht darin, eine Zufallszahl zu suchen und den größten gemeinsamen Teiler pgcd (plus grand diviseur commun) dieser Zahl und des Ergebnisses der Multiplikation einer großen Zahl (z. B. 100) mit den ersten Primzahlen zu suchen. Diese Technik erfordert die Durchführung von Divisionen, und der Schaltkreis 1 ist daher nicht für diese Durchführung geeignet.
• Der Erfinder schlägt ein anderes Verfahren vor. Es wird nicht mehr das pgcd der gewählten Zufallszahl und des Produkts von 100 (zum Beispiel) mit den ersten Primzahlen berechnet, sondern es wird nacheinander die modulare Reduktion der Zufallszahl mit jeder der 100 ersten Primzahlen durchgeführt.
• Dieses Verfahren ist in der Praxis nur denkbar, wenn die notwendige Zeit zum Durchführen einer modularen Reduktion reduziert wird. Die Erfindung erlaubt es, an die Durchführung dieses Verfahrens zu denken, da mit den neuen Verfahren zur Berechnung der Fehlerkorrektur und der modularen Reduktion, wie sie in Abschnitt III entwickelt wurden, Zeitgewinne ermöglicht werden; es ist nützlich hier, die Register als 1 Wort mit k Bits (z. B. k = 32) zu konfigurieren.
• Im übrigen verwendet man beim Stand der Technik nur Register mit 256 oder 512 Bits. In der Praxis bedeutet dies bei der Durchführung von Operationen in vernünftiger Zeit, daß man Primzahlen wählen muß, die in der gleichen Zahl an Bits codiert sind. Das stellt jedoch ein Problem der Sicherheit gegenüber versuchsweiser Bestimmung von diesen Zahlen durch nicht autorisierte Personen dar.
• Der Erfinder schlägt daher vor, die verwendeten Register zu modifizieren, z. B. indem modulare Register verwendet werden, die wahlweise 32, 256, (256 + n), 384, (384 + n), 512 oder (512 + n) Zellen haben, wobei n eine ganze Zahl ist. Man nimmt z. B. n = 32.
• Man orientiert sich bei der Wahl an dem Modul, das in 512, 768 und 1024 Bits codiert ist.
• Die Wahl der modularen Register, wie sie oben definiert ist, ermöglicht:
• - in dem allgemeinen Rahmen der modularen Operationen die Zahl der Verschiebungen in den Registern zu minimieren, indem sehr flexibel eine Anpassung an die verwendbaren Größen der verarbeiteten Datenwerte erfolgt,
• - in dem speziellen Rahmen der Durchführung von der RSA- Codierung unterschiedliche Größen für P und Q wählen zu können. Zum Beispiel kann man, wenn man ein Modulo N = P · Q in 512 Bit codiert haben möchte, P in 254 Bits und Q in 258 Bits wählen. Man wird ein Register mit 256 Zellen für die Berechnungen mit P und von 256 + n = 288 Zellen für die Berechnungen mit Q wählen. Mit dem Schaltkreis nach dem Stand der Technik wäre man genötigt, ein Register mit 512 Zellen für die Berechnungen mit Q zu verwenden, was die Dauer der Berechnungen festlegt.
• Die Erfindung ist besonders vorteilhaft, sobald man sie durchführen kann (was die Verfahren betrifft), ohne daß man die existierenden Schaltkreise, die in Fig. 1 und 2 dargestellt sind, modifizieren muß. Man modifiziert lediglich den Sequenziererschaltkreis, der es ermöglicht, die unter schiedlichen Steuersignale zu erzeugen, die für die Funktion dieser Schaltkreise notwendig sind. Insbesondere kann man die verwendbaren Größen von Modulo N und der Operanden berücksichtigen. Es ist von Vorteil, wenn man zur Verwendung der Verfahren gemäß der Erfindung, wie es oben angedeutet wurde, den Schaltkreis 1 modifiziert.
• In Fig. 2 ist vorgeschlagen worden, daß man die Ressourcen des Schaltkreises in Fig. 2 nutzt. Das erlaubt es, die Gesamtgröße des Coprozessors zu minimieren. Selbstverständlich kann man einen Schaltkreis verwenden, der lediglich für die Berechnung von H dient.
• Auch wenn die Erfindung in bezug auf ein bevorzugtes Ausführungsbeispiel beschrieben wurde, versteht es sich von selbst, daß verschiedene Varianten möglich sind, ohne daß man den Rahmen der Erfindung, der durch die Ansprüche gesteckt ist, verläßt.

Claims (11)

1. Verfahren zum Durchführen einer modularen Reduktion nach dem Montgomery-Verfahren mit einem integrierten Schaltkreis, bei welchem:

- eine binäre Dateneinheit C codiert ist in c Bits, die aufgeteilt sind auf m' Worte mit k Bits, wobei m' und k ganze Zahlen sind und für m' gilt

m' · k &ge; c > (m' - 1) · k,

- eine binäre Dateneinheit N, die von Null verschieden ist, die codiert ist auf n Bits, ·

dadurch gekennzeichnet, daß zum Erzeugen von C mod N man die Schritte zum Erzeugen einer binären Dateneinheit J&sub0;(N') = -N'&sub0;&supmin;¹ mod 2k durchführt, wobei N' eine binäre Dateneinheit ist, die auf n Bit codiert ist, so daß N' ein Bit mit geringstem Gewicht 1 hat und N = N' · 2a, wobei a eine ganze Zahl &ge; 0 ist, zum Erzeugen wenigstens einer binären Dateneinheit H der Form 2f(C, N), wobei f(C, N) eine ganze Zahl ist, die die Größe von C und die Zahl an Bits mit geringem Gewicht von N darstellt, die 0 sind, und zum Ausgeben einerseits von C am parallelen Eingang eines Multiplikationsschaltkreises (19) mit einem seriellen Eingang, einem parallelen Eingang und einem seriellen Ausgang, und andererseits von H am seriellen Eingang des gleichen Multiplikationsschaltkreises.

2. Verfahren nach Anspruch 1, dadurch gekennzeichnet, daß man zum Erzeugen von C mod N, wobei das Bit mit dem geringsten Gewicht von N gleich 0 ist, die folgenden Schritte durchführt:

E1 - Erzeugen einer binären Dateneinheit H = 2m' · k &supmin; a mod N',

E3 - Ausgeben von C, codiert auf m' · k Bits, an den Paralleleingang des Multiplikationsschaltkreises (19) und von H, codiert auf n Bits, an den seriellen Eingang des gleichen Multiplikationsschaltkreises, um eine Dateneinheit P(C, H)N' = C · 2-a mod N' zu erhalten,

E4 - Erzeugen von 2a · P(C, H)N' = C mod N.

3. Verfahren nach Anspruch 2, dadurch gekennzeichnet, daß man zum Erzeugen von P(C, H)N' = C · 2-a mod N' die folgenden Schritte durchführt:

R1 - Laden des Parameters H in ein erstes Register (10) und von Modulo N' in ein zweites Register (12) und Initialisieren eines dritten Registers (11) auf Null, wobei der Inhalt dieses dritten Registers (11) mit S bezeichnet wird und S eine variable binäre Dateneinheit ist, die auf n Bits codiert ist,

R2 - Durchführen einer Schleife, die mit s indiziert ist, wobei s zwischen 1 und m' variiert, wobei jede s-te Iteration die folgenden Operationen beinhaltet:

a) Übertragen des s-ten Wortes Cs-1 von C in einem vierten Register (16) zu einem parallelen Eingang des Multiplikationsschaltkreises,

b) Erzeugen eines Wertes X(s) = S(s-1) + H · Cs-1, wobei S(0) = 0 und S(s-1) der aktualisiert genannte Wert von S ist, der nachfolgend definiert wird durch:

I - Verschieben nach rechts des Inhalts des ersten Registers (10) zum seriellen Eingang des Multiplikationsschaltkreises (19) mit Rückschleifen des Ausgangs dieses Registers an seinen Eingang,

II - Multiplizieren der Bits von H mit Cs-1,

III - Verschieben nach rechts des Inhalts des zweiten Registers (12) mit Rückschleifen des Ausgangs dieses Registers an seinen Eingang,

IV - Bestimmen des aktualisierten Wertes von S(s-1) als der Wert, der in dem dritten Register (11) nach der (s-1)-ten Iteration abgelegt wurde, wenn dieser kleiner als N' ist, und wenn er größer ist, durch serielles Subtrahieren von N' von diesem, wobei der Ergebniswert der aktualisierte Wert von S(s-1) ist, und

V - Verschieben nach rechts des Inhalts des dritten Registers (11) und Bit für-Bit- Addieren des Multiplikationswertes H · Cs-1 zu dem aktualisierten Wert von S(s-1),

c) Multiplizieren des Wortes mit dem geringsten Gewicht von X(s), X&sub0;(s) mit J&sub0; und Eintragen des Wertes X&sub0;(s) · J&sub0; mod 2k = Y&sub0;(s) in ein viertes Register (18) und gleichzeitiges Verzögern von N' und X(s) um k Zyklen,

d) Berechnen eines Wertes Z(s) = X(s) + Y&sub0;(s) · N' durch:

I - Multiplizieren von Y&sub0;(s) mit N', verzögert um k Zyklen, und

II - Bit für-Bit-Addieren von X(s) zu dem Wert Y&sub0;(s) · N',

e) Verwerfen des Wortes, das das geringste Gewicht hat von Z(s) und Abspeichern der übrigen Worte, d. h. T(s)/2k in dem dritten Register (11),

f) Bit für-Bit-Vergleichen von Z(s)/2k mit N', um den aktualisierten Wert S(s) der folgenden Iteration zu bestimmen, wie es oben beschrieben wurde, wobei dieser Vergleich durchgeführt wird durch Bit für-Bit-Subtraktion von Z(s)/2k und N', wobei N' um zusätzliche k Zyklen verzögert wurde,

g) wobei das s-te Wort von C in das vierte Register (16) zu irgendeinem Zeitpunkt während der obigen Operationen geladen wird;

R3 - Ignorieren des Wortes mit dem geringsten Gewicht von Z(m') und eintragen der übrigen Worte, d. h. Z(m')/2k in das erste Register (10) bei der m'-ten Iteration,

R4 - Ausgeben des Ergebnisses, das in dem ersten Register (19) bei der letzten Iteration abgelegt wurde, eventuell unter Subtraktion von N', falls notwendig,

R5 - Verschieben des Ergebnisses um a Bits nach links.

4. Verfahren nach einem der Ansprüche 2 oder 3, dadurch gekennzeichnet, daß man zum Erzeugen von H die folgenden Schritte durchführt:

H1 - Laden von Modulo N' in ein erstes Register (12) und Initialisieren eines zweiten Registers (10), wobei der Inhalt des zweiten Registers B(0) genannt wird,

H2 - Ausgeben von N' des ersten Registers (12) durch Verschieben nach rechts mit Rückschleifen an seinen Eingang um 1 - a Bits, wobei 1 die Zahl der verwendbaren Bits von N ist,

H3 - Erzeugen und Abspeichern einer Dateneinheit B(1) = 2 · (B(0) - N"), codiert auf n Bits mit N" - N' · 2n-1+a durch

- Ausgeben von N" und B(0) durch Verschieben nach rechts in dem ersten und zweiten Register (10, 12) des Inhalts dieser Register, wobei der Eingang des ersten Registers (12) mit seinem Ausgang verbunden ist,

- Bit für-Bit-Subtraktion von Bits von N" und B(0) mit Verschieben nach links um eine Einheit des Ergebnisses, das mit R(0) = B(0) - N" bezeichnet wird,

- Ablegen des Ergebnisses der Subtraktion nach Verschieben, mit B(1) = 2 · R(0) bezeichnet, in das zweite Register (10),

- Bit für-Bit-Subtraktion von B(1) und N", um zu bestimmen, ob B(1) &ge; oder < N",

H4 - Erzeugen einer Dateneinheit Hint = 2t mod N" mit t = n - l + a + u · k + (m' - u) · k/2r, wobei r eine ganze Zahl ist, so daß k/2r eine ganze Zahl ist, und u eine ganze Zahl ungleich Null ist, so daß u · k &ge; l > (u - 1) · k durch:

Durchführen einer Schleife, die mit dem Index i indiziert ist, wobei i eine ganze Zahl zwischen 1 und t - n ist, wobei jede i-te Iteration die folgenden Operationen umfaßt:

- wenn B(i) < N", dann Laden in das zweite Register (10) von B(i + 1) = 2 · (B(i) - 0) = 2 · B(i) nach Verschieben nach links von B(i) um eine Einheit und Bit für-Bit-Vergleichen von B(i+1) und N",

- andernfalls Bit für-Bit-Subtraktion von N" und B(i) mit Verschieben nach links um eine Einheit des Ergebnisses und Laden in das zweite Register von B(i+1) = 2 · (B(i) - N") und-Bit für-Bit-Vergleichen von B(i+1) und N",

H5 - wenn B(t-n+1) &ge; N": Bit für-Bit-Subtraktion von B(t-n+1) und N" und Laden in das Register (10) von B (t-n+1) - N",

H6 - Verschieben nach rechts um n - l + a Bits in dem ersten und zweiten Register (10, 12)

H7 - Durchführen von r Pfield-Operationen:

Hint(j) = P(Hint(j - 1), Hint(j - 1))N' mit j als Index zwischen 1 und r, und Hint(0) = B(t - n + 1) · 21-n-a H8 oder (B(t - n + 1) - N") · 2l-n-a,

H8 - Erzeugen des Parameters H durch Durchführen einer Pfield-Operation:

H = P(Hint(r), 2u·k-a)N'.

5. Verfahren nach Anspruch 1, bei welchem N' = N, dadurch gekennzeichnet, daß man zum Erzeugen von C mod N die folgenden Schritte durchführt:

E1 - Erzeugen einer binären Dateneinheit N = 2m'·k mod N,

E3 - Ausgeben von C, codiert in m' · k Bits, an den seriellen Eingang des Multiplikationsschaltkreises (19) und von H, codiert in n Bits, an den parallelen Eingang desselben Multiplikationsschaltkreises, um P(C, H)N = C mod N zu erhalten.

6. Verfahren nach Anspruch 5, dadurch gekennzeichnet, daß man zum Erzeugen von P(C, H)N = C mod N die folgenden Schritte durchführt:

R1 - Laden des Parameters H in ein erstes Register (10) und von Modulo N in ein zweites Register (12) und Initialisieren eines dritten Registers (11) auf Null, wobei der Inhalt dieses dritten Registers (11) mit S bezeichnet wird, wobei 5 eine variable binäre Dateneinheit ist, die auf n Bit codiert ist,

R2 - Durchführen einer Schleife, die mit s indiziert ist und bei der s zwischen 1 und m' variiert, wobei jede s-te Iteration die folgenden Operationen umfaßt:

a) Übertragen des s-ten Wortes Cs-1 von C in einem vierten Register (16) an einen parallelen Eingang des Multiplikationsschaltkreises,

b) Erzeugen eines Wertes X(s) = S(s-1) + H · Ss-1 mit S&sub0; = 0 und S(s-1) als aktualisiert genannten Wert von S, das im Nachfolgenden definiert wird durch:

I - Verschieben nach rechts des Inhalts des ersten Registers (10) zum seriellen Eingang des Multiplikationsschaltkreises (19) mit Rückschleifen des Ausgangs dieses Registers an seinen Eingang,

II - Multiplizieren der Bits von H mit Cs-1,

III - Verschieben nach rechts des Inhalts des zweiten Registers (12) mit Rückschleifen des Ausgangs dieses Registers an seinen Eingang,

IV - Bestimmen des aktualisierten Wertes von S(s-1) als derjenige Wert, der in dem dritten Register (11) nach der (s-1)-ten Iteration abgelegt wurde, wenn dieser kleiner als N ist, und wenn er größer ist, indem seriell N von diesem abgezogen wird, wobei der Ergebniswert der aktualisierte Wert von S(s-1) ist, und

V - Verschieben nach rechts des Inhalts des dritten Registers (11) und Bit für Bit Addieren des Wertes der Multiplikation H · Cs-1 mit dem aktualisierten Wert von S(s-1),

c) Multiplizieren des Wortes mit dem geringsten Gewicht von X(s), X&sub0;(s) mit J&sub0; und Eingeben des Wertes X&sub0;(s) · J&sub0; mod 2k = Y&sub0;(s) in ein viertes Register (18) und gleichzeitiges Verzögern von N und X(s) um k Zyklen,

d) Berechnen eines Wertes Z(s) = X(s) + Y&sub0;(s) · N durch:

I - Multiplizieren von Y&sub0;(s) mit N, verzögert um k Zyklen, und

II - Bit für-Bit-Addieren von X(s) zu dem Wert Y&sub0;(s) · N,

e) Verwerfen des Wortes mit dem geringsten Gewicht von Z(s) und Abspeichern der übrigen Worte, d. h. Z(s)/2k in einem dritten Register (11),

f) Bit für-Bit-Vergleichen von Z(s)/2k mit N, um den aktualisierten Wert S(s) der folgenden Iteration zu bestimmen, wie es oben beschrieben wurde, wobei dieser Vergleich durch Bit für-Bit- Subtraktion von Z(s)/2k und N erfolgt, wobei N um zusätzliche k Zyklen verzögert ist,

g) wobei das s-te Wort von C in dem vierten Register (16) zu irgendeinem Zeitpunkt während der obigen Operationen abgelegt worden ist;

R3 - Ignorieren des Wortes mit dem geringsten Gewicht von Z(m') und Eintragen der übrigen Worte, d. h. Z(m')/2k in das erste Register (10) bei der m'-ten Iteration,

R4 - Ausgeben des Ergebnisses, das in dem ersten Register (10) bei der letzten Iteration abgelegt worden ist, eventuell mit Subtraktion von N, falls notwendig.

7. Verfahren nach einem der Ansprüche 5 oder 6, dadurch gekennzeichnet, daß zum Erzeugen von H die folgenden Schritte durchgeführt werden:

H1 - Laden von Modulo N in ein erstes Register (12) und Initialisieren eines zweiten Registers (10), wobei der Inhalt des zweiten Registers B(0) genannt wird,

H2 - Ausgeben von N des ersten Registers (12) durch Verschieben nach rechts mit Rückschleifen an seinen Eingang um 1 Bits, wobei 1 die Zahl der verwendbaren Bits von N ist,

H3 - Erzeugen und Abspeichern einer Dateneinheit B(1) = 2 · (B(0) - N'), codiert auf n Bits mit N' = N · 2n-1 durch

- Ausgeben von N' und B(0) durch Verschieben nach rechts in dem ersten und zweiten Register (10, 12) des Inhalts dieser Register, wobei der Eingang des ersten Registers (12) mit seinem Ausgang verbunden ist,

- Bit für-Bit-Subtraktion von Bits von N' und B(0) mit Verschieben nach links um eine Einheit des Ergebnisses, das mit R(0) = B(0) - N' bezeichnet wird,

- Ablegen des Ergebnisses der Subtraktion nach Verschieben, mit B(1) = 2 · R(0) bezeichnet, in das zweite Register (10),

- Bit für-Bit-Subtraktion von B(1) und N', um zu bestimmen, ob B(1) &ge; oder < N',

H4 - Erzeugen einer Dateneinheit Hint = 2t mod N' mit t = n - l + u · k + (m' - u) · k/2r, wobei r eine ganze Zahl ist, so daß k/2r eine ganze Zahl ist, und u eine ganze Zahl ungleich Null ist, so daß u · k &ge; l > (u - 1) · k durch:

Durchführen einer Schleife, die mit dem Index i indiziert ist, wobei i eine ganze Zahl zwischen 1 und t - n ist, wobei jede i-te Iteration die folgenden Operationen umfaßt:

- wenn B(i) < N', dann Laden in das zweite Register (10) von B(i + 1) = 2 · (B(i) - 0) = 2 · B(i) nach Verschieben nach links von B(i) um eine Einheit und Bit für-Bit-Vergleichen von B(i+1) und N',

- andernfalls Bit für-Bit-Subtraktion von N' und B(i) mit Verschieben nach links um eine Einheit des Ergebnisses und Laden in das zweite Register von B(i+1) = 2 · (B(i) - N') und Bit für-Bit-Vergleichen von B(i+1) und N',

H5 - wenn B(t-n+1) &ge; N': Bit für-Bit-Subtraktion von B(t-n+l) und N' und Laden in das Register (10) von B (t-n+l) - N',

H6 - Verschieben nach rechts um n - l Bits in dem ersten und zweiten Register (10, 12)

H7 - Erzeugen des Parameters H durch Durchführen von r Pfield-OPerationen:

Hint(j) = P(Hint(j-1), Hint(j-1))N mit j als Index zwischen 1 und r, und Hint (0) = B(t-n+1) · 2l-n oder (B(t-n+1) - N') · 2l-n.

8. Verfahren nach Anspruch 1, dadurch gekennzeichnet, daß zum Erzeugen von C mod N, wobei das Bit mit dem geringsten Gewicht von N gleich 0 ist, die folgenden Schritte durchgeführt werden:

E1 - Durchführen einer Schleife, die mit i indiziert wird, wobei i zwischen 1 und m" - 1 variiert und m" eine ganze Zahl ist, so daß m" · m &ge; m' > (m" - 1) · m, und m die Bedingung erfüllt n = m · k, wobei jede i-te Iteration die folgenden Operationen umfaßt:

- Erzeugen einer binären Dateneinheit Hi = 2(i+1) · n-a mod N', codiert auf n Bits,

- Ausgeben von Hi am seriellen Eingang des Multiplikationsschaltkreises (19) und Ausgeben einer Dateneinheit Ci, so daß C = &Sigma;i Ci · 2i·n am parallelen Eingang dieses gleichen Multiplikationsschaltkreises gilt, um P(Ci, Hi)N' = Ci · 2i·n-a mod N' zu erhalten,

- Verschieben des Ergebnisses, um Ci · 2i·n mod N zu erhalten und Abspeichern dieses Ergebnisses,

E2 - Abspeichern von C&sub0;, wenn C&sub0; < N, und von C&sub0; - N, wenn C&sub0; &ge; N, für i = 0,

E3 - Erzeugen des gewünschten Ergebnisses durch modulare Addition der gespeicherten Ci und C&sub0; oder C&sub0; - N.

9. Verfahren nach Anspruch 8, dadurch gekennzeichnet, daß zum Erzeugen von Hi = 2(i+1)·n-a mod N' die folgenden Schritte durchgeführt werden:

- Erzeugen von H&sub1; = 22·n-a mod N',

- bei i > 1:

- Erzeugen von Hi, p(i) = 2n+2exp(p(i)) · (n-a) mod N mit p(i) = Ent [log&sub2;(i·n/(n-a))] + 1, wobei Ent den Operator "ganzzahliger Anteil" bezeichnet,

- bei r > n Erzeugen von 2n-r mod N',

- Ausgeben von Hi,p(i), wenn n - r &ge; 0 (oder von 2n-r mod N', wenn n - r < 0), in n Bits codiert, an den seriellen Eingang des Multiplikationsschaltkreises (19) und paralleles Ausgeben von 2n-r (oder von Hi,p(i), wenn n - r < 0), codiert in n Bits, an den parallelen Ausgang des gleichen Multiplikationsschaltkreises.

10. Verfahren nach Anspruch 1, dadurch gekennzeichnet, daß zum Erzeugen von C mod N, wobei das Bit mit dem geringsten Gewicht von N gleich 0 ist, die folgenden Schritte durchgeführt werden:

E1 - Durchführen einer Schleife, die mit i indiziert ist, wobei i zwischen 1 und w - 1 variiert, wobei w eine ganze Zahl ist, so daß w · l &ge; c > (w - 1) · l und l die Zahl der verwendbaren Bits von N ist, wobei jede i-te Iteration die folgenden Operationen umfaßt:

- Erzeugen einer binären Dateneinheit Hi = 2n+i·l-a mod N', codiert in n Bits,

- Ausgeben von Hi am seriellen Eingang des Multiplikationsschaltkreises (19) und Ausgeben einer Dateneinheit Ci, so daß C = &Sigma;i Ci · 2i·l, an den parallelen Eingang des gleichen Multiplikationsschaltkreises, um P (Ci, Hi)N' = Ci · 2i·l-a mod N' zu erhalten,

- Verschieben des Ergebnisses, um Ci · 2i·l mod N zu erhalten, und Abspeichern dieses Ergebnisses,

E2 - bei i = 0 Abspeichern von C&sub0;, wenn C&sub0; < N, und von C&sub0; - N, wenn C&sub0; &ge; N,

E3 - Erzeugen des gewünschten Ergebnisses durch modulare Addition von Ci, die abgespeichert sind, und C&sub0; oder C&sub0; - N.

11. Verfahren nach Anspruch 10, dadurch gekennzeichnet, daß zum Erzeugen von Hi = 2n+i·l-a mod N' die folgenden Schritte durchgeführt werden:

- Erzeugen von H&sub1; = 2n+l-a mod N',

- bei i > 1:

- Erzeugen von Hi,p(i) = 2n+2exp(p(i)) · (l-a) mod N' mit p(i) = Ent[log&sub2;(i·l/(l-a))] + 1, wobei Ent den Operator "ganzzahliger Teil" bezeichnet,

- bei r > n Erzeugen von 2n-r mod N',

- Ausgeben von Hi,p(i) bei n - r &ge; 0 (oder von 2n-r mod N', wenn n - r < 0), codiert in n Bits, an den seriellen Eingang des Multiplikationsschaltkreises (19) und parallel Ausgeben von 2n-r (oder von Hi,p(i), wenn n - r < 0), codiert in n Bits, an den parallelen Eingang des gleichen Multiplikationsschaltkreises.