source: trunk/CrypPlugins/PKCS1/Library/KuehnSig.cs @ 1893

Last change on this file since 1893 was 1778, checked in by schomburg, 11 years ago

renamed some classes for the sake of consistency

File size: 6.0 KB
Line 
1using System;
2using System.Collections.Generic;
3using System.Linq;
4using System.Text;
5using System.IO;
6using Org.BouncyCastle.Utilities.Encoders;
7using Org.BouncyCastle.Math;
8using System.Security.Cryptography;
9using Cryptool.PluginBase;
10
11namespace PKCS1.Library
12{
13    public class KuehnSig : Signature, IGuiLogMsg
14    {
15        private int m_Iterations = 250000;
16        public int Iterations
17        {
18            get { return this.m_Iterations; }
19            set { this.m_Iterations = (int)value; }
20        }
21
22        public KuehnSig()
23        {
24            this.registerHandOff();
25        }
26
27        public override bool GenerateSignature()
28        {
29            this.m_KeyLength = RsaKey.Instance.RsaKeySize; // Länge des RSA Modulus
30
31            // drei Leerzeichen an Msg anhängen
32            string sMsgModifier = "   ";
33            byte[] bMsgModifier = Encoding.ASCII.GetBytes(sMsgModifier);
34            byte[] bMessage = new byte[ Datablock.getInstance().Message.Length + bMsgModifier.Length ];
35            Array.Copy(Datablock.getInstance().Message, bMessage, Datablock.getInstance().Message.Length);
36            Array.Copy(bMsgModifier, 0, bMessage, Datablock.getInstance().Message.Length, bMsgModifier.Length);
37           
38            HashFunctionIdent hashFuncIdent = Datablock.getInstance().HashFunctionIdent; // Die vom User gewählte Hashfunktion
39            byte[] hashIdent = Hex.Decode(Encoding.ASCII.GetBytes(hashFuncIdent.DERIdent)); // ASN.1 codierter Ident-string
40            int significantByteLength = 11 + hashIdent.Length + hashFuncIdent.digestLength/8;           
41
42            // Datenblock wird konstruiert
43            byte[] A = new byte[significantByteLength];
44            A[0] = 0x00;
45            A[1] = 0x01;
46            for (int i = 2; i < 10; i++)
47            {
48                A[i] = 0xFF;
49            }
50            A[10] = 0x00;         
51            Array.Copy(hashIdent, 0, A, 11, hashIdent.Length);
52            // Datenblock noch ohne Hashwert, wird in while Schleife unten hinzugefügt
53
54            // byte array der kompletten Signatur, wird zuerst mit 'FF' gefüllt und dann nachher Datenblock an den Anfang kopiert
55            byte[] S = new byte[this.m_KeyLength / 8];
56            for (int i = A.Length; i < S.Length; i++)
57            {
58                S[i] = 0xFF;
59            }
60
61            BigInteger finalSignature = null;           
62            int iMsgLength = bMessage.Length;
63            bool isEqual = false;
64            int countLoops = 0;
65
66            this.SendGuiLogMsg("Signature Generation started", NotificationLevel.Info);
67            byte[] hashDigest = new byte[0]; // Hashwert wird in dieser var gespeichert
68            BigInteger T = new BigInteger("0"); // hilfsvar
69            byte[] resultArray = new byte[this.m_KeyLength/8];
70
71            while (!isEqual && (countLoops < this.m_Iterations))
72            {
73                hashDigest = Hashfunction.generateHashDigest(ref bMessage, ref hashFuncIdent); // Hashwert wird erzeugt
74                Array.Copy(hashDigest, 0, A, 11 + hashIdent.Length, hashDigest.Length); // erzeugter Hashwert wird in den Datenblock kopiert
75                Array.Copy(A, 0, S, 0, A.Length); // erzeugter Datenblock wird in erzeugte Signatur S kopiert
76
77                finalSignature = MathFunctions.cuberoot4(new BigInteger(S), this.m_KeyLength); // Kubikwurzel ziehen         
78                byte[] test2 = finalSignature.ToByteArray();
79                T = finalSignature.Pow(3); // mit 3 potenzieren       
80                byte[] test = T.ToByteArray();
81                resultArray[0] = 0x00; // erstes byte is 0
82                // durch Konvertierung in BigInteger werden führende Nullen abgeschnitten, daher wird an Stelle 1 in byte array kopiert.
83                Array.Copy(T.ToByteArray(), 0, resultArray, 1, T.ToByteArray().Length);
84
85                isEqual = MathFunctions.compareByteArray(ref resultArray, ref S, significantByteLength); // byte arrays vergleichen, wird in meinen Tests nicht erreicht
86                if (!isEqual)
87                {                                       
88                    int value1 = bMessage[iMsgLength - 1];                                       
89                    if (++value1 >= 256)
90                    {
91                        value1 = 0;
92                        int value2 = bMessage[iMsgLength - 2];
93                        if (++value2 >= 256)
94                        {
95                            value2 = 0;
96                            int value3 = bMessage[iMsgLength - 3];
97                            ++value3;
98                            bMessage[iMsgLength - 3] = (byte)value3;
99                        }
100                        bMessage[iMsgLength - 2] = (byte)value2;
101                    }
102                    bMessage[iMsgLength - 1] = (byte)value1;
103                   
104                    countLoops++;
105                }
106            }
107            if (countLoops != this.m_Iterations)
108            {
109                Datablock.getInstance().Message = bMessage;
110                byte[] returnByteArray = new byte[this.m_KeyLength / 8];
111                Array.Copy(finalSignature.ToByteArray(), 0, returnByteArray, returnByteArray.Length - finalSignature.ToByteArray().Length, finalSignature.ToByteArray().Length);
112
113                this.m_Signature = returnByteArray;
114                this.m_bSigGenerated = true;
115                this.OnRaiseSigGenEvent(SignatureType.Kuehn);
116                return true;
117            }
118            else
119            {
120                this.m_bSigGenerated = false;               
121            }
122            return false;
123        }
124
125        public event GuiLogHandler OnGuiLogMsgSend;
126
127        public void registerHandOff()
128        {
129            GuiLogMsgHandOff.getInstance().registerAt(ref OnGuiLogMsgSend);
130        }
131
132        public void SendGuiLogMsg(string message, NotificationLevel logLevel)
133        {
134            if (null != OnGuiLogMsgSend)
135            {
136                OnGuiLogMsgSend(message, logLevel);
137            }
138        }
139    }
140}
Note: See TracBrowser for help on using the repository browser.