You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
245 lines
6.9 KiB
245 lines
6.9 KiB
using System;
|
|
using System.IO;
|
|
using System.Security.Cryptography;
|
|
|
|
public class SupportClass
|
|
{
|
|
public static int ReadInput(Stream sourceStream, ref sbyte[] target, int start, int count)
|
|
{
|
|
byte[] receiver = new byte[target.Length];
|
|
int bytesRead = sourceStream.Read(receiver, start, count);
|
|
for (int i = start; i < (start + bytesRead); i++)
|
|
{
|
|
target[i] = (sbyte) receiver[i];
|
|
}
|
|
return bytesRead;
|
|
}
|
|
|
|
public static int ReadInput(TextReader sourceTextReader, ref sbyte[] target, int start, int count)
|
|
{
|
|
char[] charArray = new char[target.Length];
|
|
int bytesRead = sourceTextReader.Read(charArray, start, count);
|
|
for (int index = start; index < (start + bytesRead); index++)
|
|
{
|
|
target[index] = (sbyte) charArray[index];
|
|
}
|
|
return bytesRead;
|
|
}
|
|
|
|
public static byte[] ToByteArray(string sourceString)
|
|
{
|
|
byte[] byteArray = new byte[sourceString.Length];
|
|
for (int index = 0; index < sourceString.Length; index++)
|
|
{
|
|
byteArray[index] = (byte) sourceString[index];
|
|
}
|
|
return byteArray;
|
|
}
|
|
|
|
public static byte[] ToByteArray(byte[] sbyteArray)
|
|
{
|
|
byte[] byteArray = new byte[sbyteArray.Length];
|
|
for (int index = 0; index < sbyteArray.Length; index++)
|
|
{
|
|
byteArray[index] = sbyteArray[index];
|
|
}
|
|
return byteArray;
|
|
}
|
|
|
|
public static char[] ToCharArray(byte[] byteArray)
|
|
{
|
|
char[] charArray = new char[byteArray.Length];
|
|
byteArray.CopyTo(charArray, 0);
|
|
return charArray;
|
|
}
|
|
|
|
public static char[] ToCharArray(sbyte[] sByteArray)
|
|
{
|
|
char[] charArray = new char[sByteArray.Length];
|
|
sByteArray.CopyTo(charArray, 0);
|
|
return charArray;
|
|
}
|
|
|
|
public static sbyte[] ToSByteArray(byte[] byteArray)
|
|
{
|
|
sbyte[] sbyteArray = new sbyte[byteArray.Length];
|
|
for (int index = 0; index < byteArray.Length; index++)
|
|
{
|
|
sbyteArray[index] = (sbyte) byteArray[index];
|
|
}
|
|
return sbyteArray;
|
|
}
|
|
|
|
public static void WriteStackTrace(Exception throwable, TextWriter stream)
|
|
{
|
|
stream.Write(throwable.StackTrace);
|
|
stream.Flush();
|
|
}
|
|
|
|
public class DigitalSignature
|
|
{
|
|
private string algorithmName;
|
|
private byte[] data;
|
|
private AsymmetricSignatureDeformatter deformatter;
|
|
private AsymmetricSignatureFormatter formatter;
|
|
private HashAlgorithm hashAlgorithm;
|
|
private int objective;
|
|
private int position;
|
|
|
|
protected DigitalSignature()
|
|
{
|
|
}
|
|
|
|
public static SupportClass.DigitalSignature GetInstance(string algorithmName)
|
|
{
|
|
if (!algorithmName.ToLower().Equals("sha1withdsa") && !algorithmName.ToLower().Equals("shawithdsa"))
|
|
{
|
|
throw new Exception("Algorithm not supported");
|
|
}
|
|
return new SupportClass.DigitalSignature { formatter = new DSASignatureFormatter(), deformatter = new DSASignatureDeformatter(), hashAlgorithm = new SHA1Managed(), algorithmName = "SHAwithDSA", objective = 0 };
|
|
}
|
|
|
|
private void Reset()
|
|
{
|
|
this.data = null;
|
|
this.position = 0;
|
|
}
|
|
|
|
public byte[] Sign()
|
|
{
|
|
byte[] realSignature = null;
|
|
if (this.objective != 1)
|
|
{
|
|
throw new Exception("Object was not created for signing");
|
|
}
|
|
realSignature = this.formatter.CreateSignature(this.Data);
|
|
this.Reset();
|
|
return realSignature;
|
|
}
|
|
|
|
public void Signing()
|
|
{
|
|
this.objective = 1;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string result = "Instance of DigitalSignature for ";
|
|
if (this.objective == 1)
|
|
{
|
|
result = result + "signing ";
|
|
}
|
|
else
|
|
{
|
|
result = result + "verification ";
|
|
}
|
|
return (result + "using " + this.AlgorithmName + " algorithm");
|
|
}
|
|
|
|
public void Update(byte[] newData)
|
|
{
|
|
if (this.position == 0)
|
|
{
|
|
this.Data = newData;
|
|
this.hashAlgorithm.TransformBlock(newData, 0, newData.Length, this.Data, 0);
|
|
this.position = this.Data.Length - 1;
|
|
}
|
|
else
|
|
{
|
|
byte[] oldData = this.Data;
|
|
this.Data = new byte[(newData.Length + this.position) + 1];
|
|
oldData.CopyTo(this.Data, 0);
|
|
byte[] hashedNew = newData;
|
|
this.hashAlgorithm.TransformBlock(newData, 0, hashedNew.Length, hashedNew, 0);
|
|
hashedNew.CopyTo(this.Data, oldData.Length);
|
|
this.position = this.Data.Length - 1;
|
|
}
|
|
}
|
|
|
|
public void Update(byte newData)
|
|
{
|
|
byte[] newDataArray = new byte[] { newData };
|
|
this.Update(newDataArray);
|
|
}
|
|
|
|
public void Update(byte[] newData, int offset, int count)
|
|
{
|
|
byte[] newDataArray = new byte[count];
|
|
Array.Copy(newData, offset, newDataArray, 0, count);
|
|
this.Update(newDataArray);
|
|
}
|
|
|
|
public void Verification()
|
|
{
|
|
this.objective = 2;
|
|
}
|
|
|
|
public bool Verify(byte[] signature)
|
|
{
|
|
bool result = false;
|
|
if (this.objective != 2)
|
|
{
|
|
throw new Exception("Object was not created for verification");
|
|
}
|
|
result = this.deformatter.VerifySignature(this.Data, signature);
|
|
this.Reset();
|
|
return result;
|
|
}
|
|
|
|
public string AlgorithmName
|
|
{
|
|
get
|
|
{
|
|
return this.algorithmName;
|
|
}
|
|
}
|
|
|
|
public byte[] Data
|
|
{
|
|
get
|
|
{
|
|
return this.data;
|
|
}
|
|
set
|
|
{
|
|
this.data = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public class KeySupport
|
|
{
|
|
private KeyedHashAlgorithm algorithm;
|
|
|
|
public KeySupport()
|
|
{
|
|
}
|
|
|
|
public KeySupport(KeyedHashAlgorithm algorithm)
|
|
{
|
|
this.algorithm = algorithm;
|
|
}
|
|
|
|
public string GetAlgorithm()
|
|
{
|
|
return this.algorithm.ToString();
|
|
}
|
|
|
|
public byte[] Key
|
|
{
|
|
get
|
|
{
|
|
return this.algorithm.Key;
|
|
}
|
|
}
|
|
}
|
|
|
|
public class PrivateKeySupport : SupportClass.KeySupport
|
|
{
|
|
}
|
|
|
|
public class PublicKeySupport : SupportClass.KeySupport
|
|
{
|
|
}
|
|
}
|
|
|