public override CertificatePrivateKey ImportPrivateKey(byte[] keyData)
{
try {
string keyString = Encoding.ASCII.GetString(keyData).Trim();
if (keyString.StartsWith("<DSAKeyValue>")) {
DSACryptoServiceProvider dsa = new DSACryptoServiceProvider();
dsa.FromXmlString(keyString);
return new CertificatePrivateKey(CertificateKeyAlgorithm, dsa);
}
} catch (Exception) {}
return null;
}
public static string CreateSignature(string inputData, String privateKey)
{
// create the crypto-service provider:
DSACryptoServiceProvider dsa = new DSACryptoServiceProvider();
// setup the dsa from the private key:
dsa.FromXmlString(privateKey);
byte[] data = UTF8Encoding.ASCII.GetBytes(inputData);
// get the signature:
byte[] signature = dsa.SignData(data);
return Convert.ToBase64String(signature);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="publicKey">the public key</param>
public NetSparkleDSAVerificator(String publicKey)
{
// 1. try to load this from resource
Stream data = TryGetResourceStream(publicKey) ?? TryGetFileResource(publicKey);
// 2. check the resource
if ( data == null )
throw new Exception("Couldn't find public key for verification");
// 3. read out the key value
using (StreamReader reader = new StreamReader(data))
{
String key = reader.ReadToEnd();
_provider = new DSACryptoServiceProvider();
_provider.FromXmlString(key);
}
}
public static bool VerifySignature(string inputData, string signature, string publicKey)
{
// create the crypto-service provider:
DSACryptoServiceProvider dsa = new DSACryptoServiceProvider();
// setup the provider from the public key:
dsa.FromXmlString(publicKey);
// get the license terms data:
//byte[] data = Convert.FromBase64String(inputData);
byte[] data = UTF8Encoding.ASCII.GetBytes(inputData);
// get the signature data:
byte[] signatureData = Convert.FromBase64String(signature);
// verify that the license-terms match the signature data
if (dsa.VerifyData(data, signatureData) == false)
throw new SecurityException("Signature Not Verified!");
return true;
}
public void CapiSignature ()
{
DSACryptoServiceProvider dsa = new DSACryptoServiceProvider ();
dsa.FromXmlString (CapiXml512);
SignAndVerify ("Capi-512", dsa);
dsa.FromXmlString (CapiXml576);
SignAndVerify ("Capi-576", dsa);
dsa.FromXmlString (CapiXml640);
SignAndVerify ("Capi-640", dsa);
dsa.FromXmlString (CapiXml704);
SignAndVerify ("Capi-704", dsa);
dsa.FromXmlString (CapiXml768);
SignAndVerify ("Capi-768", dsa);
dsa.FromXmlString (CapiXml832);
SignAndVerify ("Capi-832", dsa);
dsa.FromXmlString (CapiXml896);
SignAndVerify ("Capi-896", dsa);
dsa.FromXmlString (CapiXml960);
SignAndVerify ("Capi-960", dsa);
dsa.FromXmlString (CapiXml1024);
SignAndVerify ("Capi-1024", dsa);
}
/// <summary>
/// DSA验证
/// </summary>
/// <param name="CypherText">签名后的Base64字符串</param>
/// <param name="xmlString">密钥(至少含公钥)</param>
/// <param name="signString">签名串</param>
public static bool VerifyString(string CypherText, string xmlString, string signString)
{
DSACryptoServiceProvider dsa = new DSACryptoServiceProvider();
dsa.FromXmlString(xmlString);
if (!string.IsNullOrEmpty(CypherText))
{
byte[] bEnc = System.Convert.FromBase64String(CypherText);
byte[] bText = System.Text.Encoding.UTF8.GetBytes(signString.ToCharArray());
DSASignatureDeformatter DSADeformatter = new DSASignatureDeformatter(dsa);
DSADeformatter.SetHashAlgorithm("SHA1");
return DSADeformatter.VerifySignature(bEnc, bText);
}
return false;
}
//#region 文件处理
///// <summary>
///// 加密文件
///// </summary>
///// <param name="inName">来源文件</param>
///// <param name="outName">输出文件</param>
///// <param name="xmlString">密钥(至少含公钥)</param>
//public static void EncryptFile(string inName, string outName, string xmlString)
//{
// DSACryptoServiceProvider dsa = new DSACryptoServiceProvider();
// dsa.FromXmlString(xmlString);
// FileStream fin = new FileStream(inName, FileMode.Open, FileAccess.Read);
// using (FileStream fout = new FileStream(outName, FileMode.OpenOrCreate, FileAccess.Write))
// {
// fout.SetLength(0);
// long rdlen = 0; //This is the total number of bytes written.
// int len; //This is the number of bytes to be written at a time.
// byte[] bin = new byte[FileReadStep];
// while (rdlen < fin.Length)
// {
// len = fin.Read(bin, 0, FileReadStep);
// byte[] bs = dsa.Encrypt(bin, false);
// fout.Write(bs, 0, bs.Length);
// rdlen += len;
// }
// fin.Close();
// }
//}
///// <summary>
///// 解密文件
///// </summary>
///// <param name="inName">来源文件</param>
///// <param name="outName">输出文件</param>
///// <param name="xmlString">密钥(公钥私钥俱有)</param>
//public static void DecryptFile(string inName, string outName, string xmlString)
//{
// DSACryptoServiceProvider dsa = new DSACryptoServiceProvider();
// dsa.FromXmlString(xmlString);
// FileStream fin = new FileStream(inName, FileMode.Open, FileAccess.Read);
// using (FileStream fout = new FileStream(outName, FileMode.OpenOrCreate, FileAccess.Write))
// {
// fout.SetLength(0);
// long rdlen = 0; //This is the total number of bytes written.
// int len; //This is the number of bytes to be written at a time.
// byte[] bin = new byte[FileReadStep];
// while (rdlen < fin.Length)
// {
// len = fin.Read(bin, 0, FileReadStep);
// byte[] bs = dsa.Decrypt(bin, false);
// fout.Write(bs, 0, bs.Length);
// rdlen += len;
// }
// fin.Close();
// }
//}
//#endregion
#region 字符串处理
/// <summary>
/// DSA签名
/// </summary>
/// <param name="PlainText">原始字符串</param>
/// <param name="xmlString">密钥(公钥私钥俱有)</param>
/// <returns>Base64编码后的已签名字符串</returns>
public static string SignString(string PlainText, string xmlString)
{
DSACryptoServiceProvider dsa = new DSACryptoServiceProvider();
dsa.FromXmlString(xmlString);
if (!string.IsNullOrEmpty(PlainText))
{
byte[] bText = System.Text.Encoding.UTF8.GetBytes(PlainText.ToCharArray());
DSASignatureFormatter DSAFormatter = new DSASignatureFormatter(dsa);
DSAFormatter.SetHashAlgorithm("SHA1");
byte[] bEnc = DSAFormatter.CreateSignature(bText);
return System.Convert.ToBase64String(bEnc);
}
return string.Empty;
}
static void Main(string[] args)
{
try
{
// check if we have some parameters
if (args.Count() < 1)
{
Usage();
return;
}
// check what parameter we have
switch (args[0].ToLower())
{
case "/genkey_pair":
{
// show headline
ShowHeadLine();
// verify if output file exists
if (File.Exists(_dsaPrivKey) || File.Exists(_dsaPubKey))
{
Console.WriteLine("Error: Output files are currently exists");
Environment.ExitCode = -1;
return;
}
// start key generation
Console.WriteLine("Generating key pair with 1024 Bits...");
DSACryptoServiceProvider prv = new DSACryptoServiceProvider();
Console.WriteLine("Storing private key to " + _dsaPrivKey);
using (StreamWriter sw = new StreamWriter(_dsaPrivKey))
{
sw.Write(prv.ToXmlString(true));
}
Console.WriteLine("Storing public key to " + _dsaPubKey);
using (StreamWriter sw = new StreamWriter(_dsaPubKey))
{
sw.Write(prv.ToXmlString(false));
}
Console.WriteLine("");
}
break;
case "/sign_update":
{
if (args.Count() != 3)
{
Usage();
Environment.ExitCode = -1;
return;
}
// get parameter
String binary = args[1];
String privKey = args[2];
if (!File.Exists(binary))
{
Console.Error.WriteLine("Target binary " + binary + " does not exists");
Environment.ExitCode = -1;
return;
}
if (!File.Exists(privKey))
{
Console.Error.WriteLine("Private key file does not exists");
Environment.ExitCode = -1;
return;
}
// Reading private key
String key = null;
using (StreamReader reader = new StreamReader(privKey))
{
key = reader.ReadToEnd();
}
DSACryptoServiceProvider prv = new DSACryptoServiceProvider();
prv.FromXmlString(key);
// open stream
Byte[] hash = null;
using (Stream inputStream = File.OpenRead(binary))
{
hash = prv.SignData(inputStream);
}
String base64Hash = Convert.ToBase64String(hash);
Console.WriteLine(base64Hash);
}
break;
case "/verify_update":
{
if (args.Count() != 4)
{
Usage();
Environment.ExitCode = -1;
return;
}
// get parameter
String binary = args[1];
String pubKey = args[2];
String sign = args[3];
sign = sign.TrimStart('"');
sign = sign.TrimEnd('"');
AppLimit.NetSparkle.NetSparkleDSAVerificator dsaVerif = new AppLimit.NetSparkle.NetSparkleDSAVerificator(pubKey);
if (dsaVerif.VerifyDSASignature(sign, binary))
Console.WriteLine("Binary " + binary + " is valid");
else
Console.WriteLine("Binary " + binary + " is NOT valid");
}
break;
default:
Usage();
break;
}
}
catch (Exception e)
{
Console.WriteLine("Something went wrong :-(");
Console.WriteLine(e.StackTrace);
}
}
/// <summary>
/// Validates the signature that follows the Licence data
/// </summary>
/// <param name="hashValue">Hash value</param>
/// <param name="signedHashValue">Signed hash value</param>
/// <param name="xmlKeyInfo">Public Key</param>
/// <param name="hashAlg">Hash Algorithm</param>
/// <returns>True if signature is valid</returns>
private static bool DSAVerifyHash(byte[] hashValue, byte[] signedHashValue, string xmlKeyInfo, string hashAlg)
{
DSACryptoServiceProvider.UseMachineKeyStore = false;
using (DSACryptoServiceProvider DSA = new DSACryptoServiceProvider())
{
DSA.FromXmlString(xmlKeyInfo);
DSASignatureDeformatter DSAFormatter = new DSASignatureDeformatter(DSA);
DSAFormatter.SetHashAlgorithm(hashAlg);
return DSAFormatter.VerifySignature(hashValue, signedHashValue);
}
}
public void MonoSignature ()
{
DSACryptoServiceProvider dsa = new DSACryptoServiceProvider ();
dsa.FromXmlString (MonoXml512);
SignAndVerify ("Mono-512", dsa);
dsa.FromXmlString (MonoXml576);
SignAndVerify ("Mono-576", dsa);
dsa.FromXmlString (MonoXml640);
SignAndVerify ("Mono-640", dsa);
dsa.FromXmlString (MonoXml704);
SignAndVerify ("Mono-704", dsa);
dsa.FromXmlString (MonoXml768);
SignAndVerify ("Mono-768", dsa);
dsa.FromXmlString (MonoXml832);
SignAndVerify ("Mono-832", dsa);
dsa.FromXmlString (MonoXml896);
SignAndVerify ("Mono-896", dsa);
dsa.FromXmlString (MonoXml960);
SignAndVerify ("Mono-960", dsa);
dsa.FromXmlString (MonoXml1024);
SignAndVerify ("Mono-1024", dsa);
}
internal static bool VerifyLocalKeyfile(string filename, out AuthInfo authinfo)
{
StreamReader reader = null;
string data = "";
authinfo = null;
try {
reader = new StreamReader(filename);
data = reader.ReadToEnd();
reader.Close();
} catch (Exception exc) {
MessageBox.Show("Offline key authorization failure: Could not read keyfile.\n\n\n" + exc.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return false;
}
Regex rx = new Regex(@"\s*Keyfile(\n*|\s*)?" +
@"(?<inner>" +
@"(?>" +
@"\{(?<LEVEL>)" +
@"|" +
@"\};(?<-LEVEL>)" +
@"|" +
@"(?!\{|\};)." +
@")+" +
@"(?(LEVEL)(?!))" +
@")"
, RegexOptions.IgnoreCase | RegexOptions.Singleline);
Match topmatch = rx.Match(data);
if (!topmatch.Success) {
MessageBox.Show("Offline key authorization failure: Could not find valid 'keyfile' block.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return false;
}
string keyfile_data = topmatch.Groups["inner"].Value;
// Once we have the top matched group, parse each line in it
rx = new Regex(@"\s*\b(?<name>[A-Z]*)\b\s*=\s*((" + "\"" + @"\s*(?<single>.*?)\s*" + "\"" + @"\s*;)|(\{(?<multi>.*?)\};))", RegexOptions.Singleline | RegexOptions.IgnoreCase);
// 1 = name
// 4 = normal definition
// 6 = multiline definition
string version = "";
string name = "";
string expires = "";
string machinecode = "";
string featurebit = "";
string hash = "";
string signature = "";
string email = "";
foreach(Match m in rx.Matches(keyfile_data)) {
switch(m.Groups["name"].Value.ToLower()) {
case "version":
version = m.Groups["single"].Value;
break;
case "name":
name = m.Groups["single"].Value;
break;
case "expires":
expires = m.Groups["single"].Value;
break;
case "machinecode":
machinecode = m.Groups["single"].Value;
break;
case "featurebit":
featurebit = m.Groups["single"].Value;
break;
case "hash":
hash = m.Groups["single"].Value;
break;
case "keysignature":
signature = m.Groups["multi"].Value;
break;
case "email":
email = m.Groups["single"].Value;
break;
}
}
// Clean up signature
signature = signature.Replace(" ", "");
signature = signature.Replace("\t", "");
signature = signature.Replace("\n", "");
signature = signature.Replace("\r", "");
// Check field validity
if (version == "" || expires == "" || machinecode == "" || featurebit == "" || hash == "" || name == "" || email == "" || signature == "") {
MessageBox.Show("Offline key authorization failure: Keyfile construction incomplete.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return false;
}
// Check version
if (version != "1.00") {
MessageBox.Show("Offline key authorization failure: Incorrect version (Expected '1.00')", "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return false;
}
// Check expiration date
try {
DateTime dt = DateTime.Parse(expires);
if (DateTime.Now.Ticks >= dt.Ticks) {
MessageBox.Show("Offline key authorization has expired. Please visit www.torquedev.com to request a new offline authorization file.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return false;
}
} catch (Exception exc) {
MessageBox.Show("Offline key authorization failure: Unable to verify date stamp. Error returned was: " + exc.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return false;
}
// Check if the machine codes match
if (machinecode != CConfig.GetHardKey()) {
MessageBox.Show("Offline key authorization failure: Machine code mismatch.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return false;
}
// Verify hash of data
string sighash = CConfig.SHA1(version + name + machinecode + expires + featurebit + email);
if (sighash != hash) {
MessageBox.Show("Offline key authorization failure: Checksum mismatch.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return false;
}
// Verify signature by first loading the public key into memory
DSA dsa = new DSACryptoServiceProvider();
try {
dsa.FromXmlString(CVerify.PublicKey);
} catch (Exception exc) {
MessageBox.Show("Offline key authorization failure: Unable to load DSA public key. Error returned was: " + exc.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return false;
}
// Verify the data against the signature
try {
if (!dsa.VerifySignature(Convert.FromBase64String(hash), Convert.FromBase64String(signature))) {
MessageBox.Show("Offline key authorization failure: File signature is invalid.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
dsa.Clear();
return false;
} else {
// Signature checked out. Create the passback reference
authinfo = new AuthInfo(version, name, expires, machinecode, featurebit, hash, signature, email);
return true;
}
} catch (Exception exc) {
MessageBox.Show("Offline key authorization failure: DSA verification failure. Error returned was: " + exc.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
dsa.Clear();
return false;
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="mode">The security mode of the validator. Control what parts has to be exist</param>
/// <param name="publicKey">the public key as string (will be prefered before the file)</param>
/// <param name="publicKeyFile">the public key file</param>
public NetSparkleDSAVerificator(SecurityMode mode, String publicKey = null, String publicKeyFile = "NetSparkle_DSA.pub")
{
_securityMode = mode;
String key = publicKey;
if (string.IsNullOrEmpty(key))
{
// TODO: Loading Ressources don't work
Stream data = TryGetResourceStream(publicKeyFile);
if (data == null)
data = TryGetFileResource(publicKeyFile, data);
if (data != null)
{
using (StreamReader reader = new StreamReader(data))
{
key = reader.ReadToEnd();
}
}
}
if (!string.IsNullOrEmpty(key))
{
try
{
_provider = new DSACryptoServiceProvider();
_provider.FromXmlString(key);
}
catch
{
_provider = null;
}
}
}
public void CapiXmlImportExport ()
{
DSACryptoServiceProvider dsa = new DSACryptoServiceProvider ();
dsa.FromXmlString (CapiXml512);
AssertEquals ("Capi-Xml512", CapiXml512, dsa.ToXmlString (true));
dsa.FromXmlString (CapiXml576);
AssertEquals ("Capi-Xml576", CapiXml576, dsa.ToXmlString (true));
dsa.FromXmlString (CapiXml640);
AssertEquals ("Capi-Xml640", CapiXml640, dsa.ToXmlString (true));
dsa.FromXmlString (CapiXml704);
AssertEquals ("Capi-Xml704", CapiXml704, dsa.ToXmlString (true));
dsa.FromXmlString (CapiXml768);
AssertEquals ("Capi-Xml768", CapiXml768, dsa.ToXmlString (true));
dsa.FromXmlString (CapiXml832);
AssertEquals ("Capi-Xml832", CapiXml832, dsa.ToXmlString (true));
dsa.FromXmlString (CapiXml896);
AssertEquals ("Capi-Xml896", CapiXml896, dsa.ToXmlString (true));
dsa.FromXmlString (CapiXml960);
AssertEquals ("Capi-Xml960", CapiXml960, dsa.ToXmlString (true));
dsa.FromXmlString (CapiXml1024);
AssertEquals ("Capi-Xml1024", CapiXml1024, dsa.ToXmlString (true));
}
public DSASigningService(Key key)
{
Debug.Assert(key.Format.Algorithm == AlgorithmName);
_provider = new DSACryptoServiceProvider(key.Format.BitSize.signed());
_provider.FromXmlString(System.Text.Encoding.UTF8.GetString(key.Data));
}
public void CapiVerify ()
{
byte[] hash = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13 };
DSACryptoServiceProvider dsa = new DSACryptoServiceProvider ();
dsa.FromXmlString (CapiXml512);
byte[] sign512 = { 0xCA, 0x11, 0xA4, 0xCD, 0x5B, 0xBA, 0xA1, 0xC9, 0x8C, 0xEF, 0x9A, 0xB8, 0x84, 0x09, 0x96, 0xD0, 0x1B, 0x39, 0x6D, 0x1C, 0xE1, 0xB2, 0x0E, 0xD3, 0xCE, 0xCF, 0x6A, 0x48, 0xDC, 0x22, 0x40, 0xDC, 0xCD, 0x61, 0x25, 0x7F, 0x9E, 0x1B, 0x79, 0x89 };
Assert.IsTrue (dsa.VerifySignature (hash, sign512), "Capi-512-Verify");
sign512[0] = 0x00;
Assert.IsFalse (dsa.VerifySignature (hash, sign512), "Capi-512-VerBad");
dsa.FromXmlString (CapiXml576);
byte[] sign576 = { 0x10, 0x77, 0xE9, 0x4C, 0x29, 0xB0, 0xF4, 0x0E, 0x3B, 0xB7, 0x8E, 0x3A, 0x40, 0x22, 0x63, 0x70, 0xF3, 0xA5, 0xB7, 0x4A, 0x5C, 0x85, 0xB5, 0xF3, 0x4B, 0x1C, 0x4A, 0x92, 0xDD, 0x1D, 0xED, 0x63, 0x26, 0xC2, 0x42, 0x20, 0xBE, 0x33, 0x55, 0x57 };
Assert.IsTrue (dsa.VerifySignature (hash, sign576), "Capi-576-Verify");
sign576[0] = 0x00;
Assert.IsFalse (dsa.VerifySignature (hash, sign576), "Capi-576-VerBad");
dsa.FromXmlString (CapiXml640);
byte[] sign640 = { 0x4C, 0x04, 0xAC, 0xE0, 0x84, 0x04, 0x5A, 0x1D, 0x9D, 0x61, 0xA1, 0x62, 0xBE, 0x11, 0xEA, 0x0D, 0x1C, 0x21, 0xC7, 0x55, 0x2C, 0x7C, 0x84, 0x4F, 0x22, 0xE9, 0xA1, 0xF1, 0x2C, 0x83, 0x13, 0x90, 0xAE, 0x36, 0xFD, 0x59, 0x32, 0x21, 0xAE, 0x0F };
Assert.IsTrue (dsa.VerifySignature (hash, sign640), "Capi-640-Verify");
sign640[0] = 0x00;
Assert.IsFalse (dsa.VerifySignature (hash, sign640), "Capi-640-VerBad");
dsa.FromXmlString (CapiXml704);
byte[] sign704 = { 0xA2, 0x75, 0x32, 0xE0, 0x4B, 0xCA, 0x92, 0x51, 0x84, 0xAC, 0x7C, 0xDE, 0x97, 0xB8, 0xC3, 0x25, 0xD7, 0xF8, 0xA7, 0xE0, 0x76, 0x42, 0x7E, 0x5E, 0x5E, 0x3F, 0x82, 0xDB, 0x87, 0xBF, 0xC9, 0xCC, 0xD9, 0xA2, 0x8E, 0xA2, 0xFE, 0xD3, 0x48, 0x30 };
Assert.IsTrue (dsa.VerifySignature (hash, sign704), "Capi-704-Verify");
sign704[0] = 0x00;
Assert.IsFalse (dsa.VerifySignature (hash, sign704), "Capi-704-VerBad");
dsa.FromXmlString (CapiXml768);
byte[] sign768 = { 0x92, 0x27, 0x89, 0x4B, 0xB2, 0xDF, 0xE9, 0x98, 0x5A, 0xC5, 0x78, 0x5E, 0xBD, 0x51, 0x6D, 0x10, 0x30, 0xEC, 0x14, 0x95, 0x6E, 0xEB, 0xA6, 0x5F, 0x3E, 0x47, 0x47, 0x86, 0x19, 0xD0, 0xF2, 0x9B, 0x70, 0x98, 0x97, 0x07, 0x04, 0x0C, 0x13, 0xC6 };
Assert.IsTrue (dsa.VerifySignature (hash, sign768), "Capi-768-Verify");
sign768[0] = 0x00;
Assert.IsFalse (dsa.VerifySignature (hash, sign768), "Capi-768-VerBad");
dsa.FromXmlString (CapiXml832);
byte[] sign832 = { 0xC7, 0x10, 0x86, 0x86, 0x4A, 0x19, 0xBC, 0x8E, 0xC5, 0x0E, 0x53, 0xC0, 0x9E, 0x70, 0x2C, 0xFD, 0x4B, 0x9B, 0xBD, 0x79, 0x46, 0x8E, 0x9F, 0x64, 0x41, 0xF9, 0xBB, 0xDD, 0x3B, 0x93, 0x63, 0x82, 0x7B, 0x9B, 0x5B, 0x12, 0x9B, 0xAA, 0x90, 0xAD };
Assert.IsTrue (dsa.VerifySignature (hash, sign832), "Capi-832-Verify");
sign832[0] = 0x00;
Assert.IsFalse (dsa.VerifySignature (hash, sign832), "Capi-832-VerBad");
dsa.FromXmlString (CapiXml896);
byte[] sign896 = { 0x7F, 0x0F, 0x5F, 0xC4, 0x44, 0x38, 0x65, 0xD7, 0x0B, 0x03, 0xD1, 0xAC, 0x77, 0xA2, 0xA2, 0x47, 0x37, 0x37, 0x42, 0xA2, 0x97, 0x23, 0xDA, 0x7F, 0xEC, 0xD5, 0x78, 0x3D, 0x5E, 0xDA, 0xA0, 0x02, 0xD6, 0x2D, 0x4B, 0xFA, 0x79, 0x7B, 0x7A, 0x87 };
Assert.IsTrue (dsa.VerifySignature (hash, sign896), "Capi-896-Verify");
sign896[0] = 0x00;
Assert.IsFalse (dsa.VerifySignature (hash, sign896), "Capi-896-VerBad");
dsa.FromXmlString (CapiXml960);
byte[] sign960 = { 0x63, 0x77, 0x39, 0xE5, 0x03, 0xD2, 0x33, 0xF5, 0xFE, 0x16, 0xE4, 0x7E, 0x49, 0x4E, 0x72, 0xA0, 0x1B, 0x8D, 0x4D, 0xEC, 0x55, 0x15, 0x72, 0x1C, 0x22, 0x37, 0x4B, 0x64, 0xEB, 0x02, 0x3E, 0xC5, 0xCF, 0x32, 0x07, 0xC5, 0xD3, 0xA2, 0x02, 0x0A };
Assert.IsTrue (dsa.VerifySignature (hash, sign960), "Capi-960-Verify");
sign960[0] = 0x00;
Assert.IsFalse (dsa.VerifySignature (hash, sign960), "Capi-960-VerBad");
dsa.FromXmlString (CapiXml1024);
byte[] sign1024 = { 0x1C, 0x5A, 0x9D, 0x82, 0xDD, 0xE0, 0xF5, 0x65, 0x74, 0x48, 0xFB, 0xD6, 0x27, 0x92, 0x98, 0xEA, 0xC6, 0x7F, 0x4F, 0x7C, 0x49, 0xFC, 0xCF, 0x46, 0xEB, 0x62, 0x27, 0x05, 0xFC, 0x9C, 0x40, 0x74, 0x5B, 0x13, 0x7E, 0x76, 0x9C, 0xE4, 0xF6, 0x53 };
Assert.IsTrue (dsa.VerifySignature (hash, sign1024), "Capi-1024-Verify");
sign1024[0] = 0x00;
Assert.IsFalse (dsa.VerifySignature (hash, sign1024), "Capi-1024-VerBad");
}
public void MonoXmlImportExport ()
{
DSACryptoServiceProvider dsa = new DSACryptoServiceProvider ();
dsa.FromXmlString (MonoXml512);
Assert.AreEqual (MonoXml512, dsa.ToXmlString (true), "Mono-Xml512");
dsa.FromXmlString (MonoXml576);
Assert.AreEqual (MonoXml576, dsa.ToXmlString (true), "Mono-Xml576");
dsa.FromXmlString (MonoXml640);
Assert.AreEqual (MonoXml640, dsa.ToXmlString (true), "Mono-Xml640");
dsa.FromXmlString (MonoXml704);
Assert.AreEqual (MonoXml704, dsa.ToXmlString (true), "Mono-Xml704");
dsa.FromXmlString (MonoXml768);
Assert.AreEqual (MonoXml768, dsa.ToXmlString (true), "Mono-Xml768");
dsa.FromXmlString (MonoXml832);
Assert.AreEqual (MonoXml832, dsa.ToXmlString (true), "Mono-Xml832");
dsa.FromXmlString (MonoXml896);
Assert.AreEqual (MonoXml896, dsa.ToXmlString (true), "Mono-Xml896");
dsa.FromXmlString (MonoXml960);
Assert.AreEqual (MonoXml960, dsa.ToXmlString (true), "Mono-Xml960");
dsa.FromXmlString (MonoXml1024);
Assert.AreEqual (MonoXml1024, dsa.ToXmlString (true), "Mono-Xml1024");
}
private static void Sign(IList<string> args)
{
if (args.Count != 3)
{
Usage();
Environment.Exit(-1);
}
// get parameter
var artifact = args[1];
var privKey = args[2];
if (!File.Exists(artifact))
{
ShowErrorMessage(string.Format("\tArtifact {0} doesn't exist", artifact));
}
if (!File.Exists(privKey))
{
ShowErrorMessage(string.Format("\tPrivate key {0} doesn't exist", privKey));
}
string key;
using (var reader = new StreamReader(privKey))
{
key = reader.ReadToEnd();
}
var prv = new DSACryptoServiceProvider();
prv.FromXmlString(key);
byte[] hash;
using (Stream inputStream = File.OpenRead(artifact))
{
hash = prv.SignData(inputStream);
}
var base64Hash = Convert.ToBase64String(hash);
Console.WriteLine(base64Hash);
}
public void MonoVerify ()
{
byte[] hash = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13 };
DSACryptoServiceProvider dsa = new DSACryptoServiceProvider ();
dsa.FromXmlString (MonoXml512);
byte[] sign512 = { 0x53, 0x44, 0x0A, 0xD7, 0x43, 0x3C, 0x1F, 0xC7, 0xCE, 0x9C, 0xAE, 0xDC, 0xFC, 0x61, 0xD5, 0xCE, 0xC9, 0x5C, 0x8D, 0x13, 0x0F, 0x66, 0x15, 0xCB, 0x9F, 0x94, 0x19, 0x18, 0x63, 0x40, 0x6D, 0x3E, 0x16, 0xA8, 0x3E, 0x9B, 0x8A, 0xC2, 0xA5, 0x38 };
Assert.IsTrue (dsa.VerifySignature (hash, sign512), "Mono-512-Verify");
sign512[0] = 0x00;
Assert.IsFalse (dsa.VerifySignature (hash, sign512), "Mono-512-VerBad");
dsa.FromXmlString (MonoXml576);
byte[] sign576 = { 0xAC, 0xC8, 0xA3, 0x22, 0x3D, 0x77, 0xE1, 0x13, 0xFD, 0x65, 0x72, 0xE0, 0xA5, 0xF5, 0x94, 0xD6, 0x70, 0x70, 0x40, 0xA9, 0x10, 0x1E, 0x1D, 0xEA, 0x51, 0x68, 0x32, 0x2A, 0x24, 0x47, 0x22, 0x8D, 0xC0, 0xD0, 0x8A, 0x5A, 0x0E, 0x98, 0x5F, 0x2C };
Assert.IsTrue (dsa.VerifySignature (hash, sign576), "Mono-576-Verify");
sign576[0] = 0x00;
Assert.IsFalse (dsa.VerifySignature (hash, sign576), "Mono-576-VerBad");
dsa.FromXmlString (MonoXml640);
byte[] sign640 = { 0x5E, 0x6E, 0x1F, 0x38, 0xCA, 0x0D, 0x01, 0x01, 0xBE, 0x5E, 0x8B, 0xAB, 0xCE, 0xD2, 0x42, 0x80, 0x4A, 0xBD, 0x74, 0x60, 0x56, 0x4B, 0x16, 0x4A, 0x71, 0xBC, 0xC3, 0x82, 0xE1, 0x54, 0x0D, 0xB0, 0x67, 0xB6, 0xB6, 0x71, 0x46, 0xA9, 0x01, 0x44 };
Assert.IsTrue (dsa.VerifySignature (hash, sign640), "Mono-640-Verify");
sign640[0] = 0x00;
Assert.IsFalse (dsa.VerifySignature (hash, sign640), "Mono-640-VerBad");
dsa.FromXmlString (MonoXml704);
byte[] sign704 = { 0x27, 0x33, 0x45, 0xC5, 0x41, 0xC7, 0xD6, 0x5D, 0x68, 0x32, 0x50, 0x4C, 0xB3, 0x4B, 0x59, 0xCF, 0x49, 0xD1, 0x61, 0x82, 0xCF, 0x73, 0x20, 0x20, 0x3E, 0x09, 0xA3, 0x49, 0xAA, 0x22, 0x1D, 0x1D, 0x27, 0xBA, 0x9F, 0xDD, 0xE2, 0x7D, 0xCD, 0x82 };
Assert.IsTrue (dsa.VerifySignature (hash, sign704), "Mono-704-Verify");
sign704[0] = 0x00;
Assert.IsFalse (dsa.VerifySignature (hash, sign704), "Mono-704-VerBad");
dsa.FromXmlString (MonoXml768);
byte[] sign768 = { 0xCA, 0x53, 0x91, 0x99, 0xAE, 0x1B, 0x97, 0xE5, 0x3B, 0x08, 0x78, 0x92, 0xD1, 0x2E, 0x0D, 0xAC, 0xB7, 0x82, 0xFB, 0xA3, 0x84, 0xEE, 0x9B, 0x5E, 0x12, 0x6C, 0x16, 0x6D, 0x97, 0xC1, 0xCF, 0x9A, 0xA9, 0xCF, 0x6A, 0x6E, 0x08, 0x45, 0xA7, 0x19 };
Assert.IsTrue (dsa.VerifySignature (hash, sign768), "Mono-768-Verify");
sign768[0] = 0x00;
Assert.IsFalse (dsa.VerifySignature (hash, sign768), "Mono-768-VerBad");
dsa.FromXmlString (MonoXml832);
byte[] sign832 = { 0x7F, 0x1C, 0xC5, 0xA4, 0xDB, 0x95, 0x27, 0xD3, 0x23, 0x6E, 0xCE, 0xBC, 0xC0, 0x9D, 0x82, 0x02, 0x6E, 0xA0, 0x80, 0x5D, 0x53, 0x54, 0x3D, 0x1B, 0x1C, 0x54, 0xDD, 0x1F, 0xD5, 0x7E, 0x07, 0x60, 0xDD, 0x2A, 0xB2, 0x96, 0x3C, 0x36, 0xB3, 0x60 };
Assert.IsTrue (dsa.VerifySignature (hash, sign832), "Mono-832-Verify");
sign832[0] = 0x00;
Assert.IsFalse (dsa.VerifySignature (hash, sign832), "Mono-832-VerBad");
dsa.FromXmlString (MonoXml896);
byte[] sign896 = { 0x36, 0x90, 0xA2, 0x4C, 0xDA, 0xDC, 0x6C, 0xF3, 0x83, 0xFE, 0xA8, 0x14, 0xFB, 0x01, 0x69, 0x5F, 0xFA, 0xFA, 0x71, 0xA6, 0x6F, 0xBE, 0x96, 0xB7, 0x11, 0xE7, 0xDE, 0xC7, 0x71, 0x10, 0x83, 0xEE, 0x34, 0x18, 0x4E, 0x88, 0xC1, 0xE0, 0xF9, 0x0A };
Assert.IsTrue (dsa.VerifySignature (hash, sign896), "Mono-896-Verify");
sign896[0] = 0x00;
Assert.IsFalse (dsa.VerifySignature (hash, sign896), "Mono-896-VerBad");
dsa.FromXmlString (MonoXml960);
byte[] sign960 = { 0xCE, 0xE8, 0x52, 0x32, 0x9B, 0x30, 0xB5, 0x22, 0x6C, 0x21, 0x34, 0xC6, 0x09, 0xD8, 0xA8, 0x6D, 0x00, 0x87, 0x0F, 0x87, 0x21, 0x50, 0x18, 0x99, 0xED, 0x2A, 0xD3, 0xA5, 0x82, 0x8D, 0x38, 0x63, 0x21, 0xDA, 0xE1, 0x94, 0x65, 0xE1, 0x6E, 0x72 };
Assert.IsTrue (dsa.VerifySignature (hash, sign960), "Mono-960-Verify");
sign960[0] = 0x00;
Assert.IsFalse (dsa.VerifySignature (hash, sign960), "Mono-960-VerBad");
dsa.FromXmlString (MonoXml1024);
byte[] sign1024 = { 0x67, 0x73, 0x4D, 0x6C, 0x0E, 0xB2, 0x85, 0xC6, 0x97, 0x5F, 0x09, 0x42, 0xEA, 0xDB, 0xC6, 0xE1, 0x6D, 0x84, 0xA0, 0x15, 0x63, 0x6C, 0xE3, 0x83, 0xA5, 0xCB, 0x58, 0xC6, 0x51, 0x3C, 0xB4, 0xD2, 0x6B, 0xA0, 0x70, 0xCE, 0xD9, 0x8D, 0x96, 0xCA };
Assert.IsTrue (dsa.VerifySignature (hash, sign1024), "Mono-1024-Verify");
sign1024[0] = 0x00;
Assert.IsFalse (dsa.VerifySignature (hash, sign1024), "Mono-1024-VerBad");
}
//Верифицируем - проверяем документ
private void button7_Click(object sender, EventArgs e)
{
// создаем объект выбранного заказа
// определяем, выбран ли хотя бы один заказ
if (dataGridView1.SelectedRows.Count == 0)
return;
else
{
//получение номера текущего выбранного заказа
nom = (int)dataGridView1.SelectedRows[0].Cells["НомерЗаказа"].Value;
// проверка, имеется ли цифровая подпись выбранного чека,
// т.е. имеется ли соответствующий файл
if (!File.Exists("Zakaz" + nom + ".dat"))
{
MessageBox.Show("Ещё не создана цифровая подпись!");
return;
}
else
{
// создаем объект выбранного заказа аналогично предыдущей функции
// (объект с класса Zakaz)
MessageBox.Show(nom.ToString());
//получение номера текущего выбранного заказа
date = (DateTime)dataGridView1.SelectedRows[0].Cells["ДатаЗаказа"].Value;
// поиск заказа по ключу
DataRow dr = ds.Tables["Заказы"].Rows.Find(new object[] { (object)nom, (object)date });
// создаем объект заказа для последующей сериализации
Zakaz c = new Zakaz((int)dr["IDЗаказчика"], (int)dr["IDИсполнителя"], (int)dr["НомерЗаказа"], (DateTime)dr["ДатаЗаказа"], (string)dr["Предмет/Тема"], (int)dr["Стоимость"]);
// проводим генерацию хэш-значения для объекта c
// бинарная сериализация объекта для формирования цифровой подписи
BinaryFormatter ser = new BinaryFormatter();
// создаем поток для сериализации объекта в оперативной памяти
MemoryStream ms = new MemoryStream();
ser.Serialize(ms, c);
// получаем массив байт, определяющий объект чека
byte[] message = new byte[ms.Length];
ms.Read(message, 0, (int)ms.Length);
// создаем провайдер для хэширования
SHA1 sha1 = new SHA1CryptoServiceProvider();
// проводим хэширование
byte[] hashMessage = sha1.ComputeHash(message);
// работа с цифровой подписью - считываем подпись и
// ключ из файла и осуществляем верификацию
// читаем данные из файла-подписи
BinaryReader br = new BinaryReader(new FileStream("Zakaz" + nom + ".dat", FileMode.Open));
// читаем ключ для шифрования
string key = br.ReadString();
// читаем данные подписи
int n_sign = br.ReadInt32();
byte[] b_sign = br.ReadBytes(n_sign);
br.Close();
// импортируем параметры в провайдер шифрования
DSACryptoServiceProvider dsa = new DSACryptoServiceProvider();
dsa.FromXmlString(key);
// проводим верификацию подписей
// первый параметр - сгенерированный хэш объекта
// второй параметр - ключ
// третий параметр - цифровая подпись
if (dsa.VerifyHash(hashMessage, "1.3.14.3.2.26", b_sign))
{
MessageBox.Show("Успешная верификация!");
}
else
{
MessageBox.Show("Заказ был изменен. Ошибка верификации!");
}
}
}
}
/// <summary>
/// Método verifica si firma digital es correcta.
/// </summary>
/// <param name="pClavePublica">Cadena clave pública.</param>
/// <param name="pFirmaDigital">Array byte de firma digital.</param>
/// <param name="pClaveHash">Array byte clave hash.</param>
/// <returns>
/// Resultado booleano de verificación.
/// </returns>
private static bool ComprobarFirmaDigitalDSA(string pClavePublica, byte[] pFirmaDigital, byte[] pClaveHash)
{
// Instancia servicio de criptación DSA.
DSACryptoServiceProvider vServicioCriptorDSA = new DSACryptoServiceProvider();
// Asigna clave pública a servicio criptor.
vServicioCriptorDSA.FromXmlString(pClavePublica);
// Instancia por medio de servicio criptor a formateador de firma por medio de DSA.
DSASignatureDeformatter vFormateadorFirmaDSA = new DSASignatureDeformatter(vServicioCriptorDSA);
// Indica el algoritmo hash a utilizar.
vFormateadorFirmaDSA.SetHashAlgorithm(ALGORITMO);
// Verifica si firma digital es correcto y asigna resultado a una variable booleana.
bool vFirmaEsCorrecta = vFormateadorFirmaDSA.VerifySignature(pClaveHash, pFirmaDigital);
// Retorna resultado.
return vFirmaEsCorrecta;
}
/// <summary>
/// Método crea firma digital.
/// </summary>
/// <param name="pClaveHash">Array byte de clave hash.</param>
/// <param name="pClavesXML">Claves xml pública y privada.</param>
/// <returns>
/// Firma digital.
/// </returns>
private static byte[] CrearFirmaDigitalDSA(byte[] pClaveHash, string pClavesXML)
{
// Instancia servicio criptor DSA.
DSACryptoServiceProvider vServicioCriptorDSA = new DSACryptoServiceProvider();
// Asignamos las claves públicas y privadas a servicio criptor.
vServicioCriptorDSA.FromXmlString(pClavesXML);
// Instancia por medio de servicio criptor a formateador de firma por medio de DSA.
DSASignatureFormatter vFormateadorFirmaDSA = new DSASignatureFormatter(vServicioCriptorDSA);
// Indica el algoritmo hash a utilizar.
vFormateadorFirmaDSA.SetHashAlgorithm(ALGORITMO);
// Creamos la firma digital y se retorna.
return vFormateadorFirmaDSA.CreateSignature(pClaveHash);
}
/*private void GenerateLicense() {
DSA dsa = new DSACryptoServiceProvider();
dsa.FromXmlString(PrivateKey);
string vfyhash =
"Sam Bacsa" +
"netMercs Group" +
"Unlimited" +
"CMS-102022-00UL" +
"Never" +
"1.2" +
"1.3";
// Grab all the featurebits
foreach (bool val in _features.Values)
vfyhash += val.ToString();
// Hash it and get the result
string hash = Convert.ToBase64String(dsa.CreateSignature(Convert.FromBase64String(CConfig.SHA1(vfyhash))));
}*/
private bool VerifyLicense()
{
// Verifies the loaded license details to see if they
// check out
g.LogDebug("LicenseManager::VerifyLicense: Enter");
g.LogDebug("LicenseManager::VerifyLicense: Loading DSA object and public key");
DSA dsa = new DSACryptoServiceProvider();
dsa.FromXmlString(PublicKey);
g.LogDebug("LicenseManager::VerifyLicense: Object loaded. Key is " + PublicKey);
string vfyhash = _user + _company + _limit + _serial + ((_expires.Year == 1) ? "Never" : _expires.ToString())
+ _version.ToString() + _version_limit.ToString();
// Load the feature bits
foreach (bool val in _features.Values)
vfyhash += val.ToString();
g.LogDebug("LicenseManager::VerifyLicense: vfyhash is " + vfyhash);
g.LogDebug("LicenseManager::VerifyLicense: Verifying signature");
bool result = dsa.VerifySignature(
Convert.FromBase64String(CConfig.SHA1(vfyhash)),
Convert.FromBase64String(_signature)
);
g.LogDebug("LicenseManager::VerifyLicense: Result of signature verification is: " + result.ToString());
g.LogDebug("LicenseManager::VerifyLicense: Leave");
return result;
}
public static String GetPublicKey(String privateKey)
{
DSACryptoServiceProvider dsa = new DSACryptoServiceProvider();
dsa.FromXmlString(privateKey);
return dsa.ToXmlString(false);
}