public override void SetKey(AsymmetricAlgorithm key)
{
if (key == null)
throw new ArgumentNullException(nameof(key));
_dsaKey = (DSA)key;
}
public DSASignatureFormatter(AsymmetricAlgorithm key) : this()
{
if (key == null)
throw new ArgumentNullException(nameof(key));
_dsaKey = (DSA)key;
}
internal bool VerifySignature(System.Security.Cryptography.DSA dsa)
{
DSASignatureDeformatter deformatter = new DSASignatureDeformatter(dsa);
deformatter.SetHashAlgorithm("SHA1");
return(deformatter.VerifySignature(this.Hash, this.Signature));
}
public DSASignatureDeformatter(AsymmetricAlgorithm key) : this()
{
if (key == null)
{
throw new ArgumentNullException("key");
}
this._dsaKey = (DSA) key;
}
public override void SetKey(AsymmetricAlgorithm key)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
this._dsaKey = (DSA) key;
}
public void SetUp ()
{
if (rsa == null) {
rsa = RSA.Create ();
rsa.ImportParameters (AllTests.GetRsaKey (true));
}
if (dsa == null)
dsa = DSA.Create ();
}
public void SetUp ()
{
sig = new SignatureDescription();
// key generation is VERY long so one time is enough
if (dsa == null)
dsa = DSA.Create ();
if (rsa == null)
rsa = RSA.Create ();
}
// Set the key to use to compute the signature.
public override void SetKey(AsymmetricAlgorithm key)
{
if(!(key is DSA))
{
throw new CryptographicException
(_("Crypto_NeedsDSA"));
}
keyContainer = (DSA)key;
}
/// <summary>
/// Initializes this instance of an DSA signature algorithm.
/// </summary>
/// <param name="dsa">DSA cryptographic service provider to use.</param>
private void InitializeAlgorithm(System.Security.Cryptography.DSA dsa)
{
this.dsa = dsa;
//Compute the identity.
DSAParameters parameters = dsa.ExportParameters(false);
this.identity = new DSAIdentity(parameters);
}
public override void SetKey (AsymmetricAlgorithm key)
{
if (key != null) {
// this will throw a InvalidCastException if this isn't
// a DSA keypair
dsa = (DSA) key;
}
else
throw new ArgumentNullException ("key");
}
public void SetUp ()
{
shaSignature [0] = 0x51;
md5Signature [0] = 0xB4;
if (rsa == null)
rsa = RSA.Create ();
if (dsa == null)
dsa = DSA.Create ();
}
/// <summary>
/// Create a public key block from a private key.
/// </summary>
/// <param name="privateKey">The <see cref="DSA" /> PrivateKey.</param>
/// <returns>The <see cref="DSACryptoServiceProvider" /> PublicKey.</returns>
public static DSACryptoServiceProvider make_pubkey(DSA privateKey)
{
var publicKey = new DSACryptoServiceProvider(1024);
publicKey.ImportParameters(privateKey.ExportParameters(false));
if (!publicKey.PublicOnly)
{
publicKey.Dispose();
throw new Exception("PublicKey contains PrivateKey information, cancelling.");
}
return publicKey;
}
public override void SetKey (AsymmetricAlgorithm key)
{
if (key != null) {
// this will throw a InvalidCastException if this isn't
// a DSA keypair
dsa = (DSA) key;
}
#if NET_2_0
else
throw new ArgumentNullException ("key");
#else
// null is accepted in 1.0/1.1
#endif
}
public DSASignatureAlgorithm(System.Security.Cryptography.DSA dsa)
{
InitializeAlgorithm(dsa);
}
internal DSAWrapper(DSA wrapped)
{
Debug.Assert(wrapped != null);
_wrapped = wrapped;
}
public DSAKeyValue ()
{
dsa = (DSA)DSA.Create ();
}
// Constructors.
public DSASignatureFormatter()
{
keyContainer = null;
}
// Constructors.
public DSASignatureDeformatter()
{
keyContainer = null;
}
public void SetUp ()
{
#if NET_2_0
dsa = new NonAbstractDSAForUnitTests ();
#else
dsa = new DSACryptoServiceProvider ();
#endif
}
/// <summary>创建用于执行不对称算法的默认加密对象。</summary>
/// <returns>一个加密对象，用于执行不对称算法。</returns>
/// <PermissionSet>
/// <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="UnmanagedCode" />
/// </PermissionSet>
public static DSA Create()
{
return(DSA.Create("System.Security.Cryptography.DSA"));
}
public void FixtureSetUp ()
{
// key generation is VERY long so one time is enough
dsa = DSA.Create ();
rsa = RSA.Create ();
}
internal bool VerifySignature (DSA dsa)
{
if (signatureOID != "1.2.840.10040.4.3")
throw new CryptographicException ("Unsupported hash algorithm: " + signatureOID);
DSASignatureDeformatter v = new DSASignatureDeformatter (dsa);
// only SHA-1 is supported
string hashName = "SHA1";
v.SetHashAlgorithm (hashName);
ASN1 sign = new ASN1 (signature);
if ((sign == null) || (sign.Count != 2))
return false;
// parts may be less than 20 bytes (i.e. first bytes were 0x00)
byte[] part1 = sign [0].Value;
byte[] part2 = sign [1].Value;
byte[] sig = new byte [40];
Buffer.BlockCopy (part1, 0, sig, (20 - part1.Length), part1.Length);
Buffer.BlockCopy (part2, 0, sig, (40 - part2.Length), part2.Length);
return v.VerifySignature (GetHash (hashName), sig);
}
static public byte[] Encode (DSA dsa)
{
DSAParameters param = dsa.ExportParameters (true);
return ASN1Convert.FromUnsignedBigInteger (param.X).GetBytes ();
}
internal bool VerifySignature (DSA dsa)
{
// signatureOID is check by both this.Hash and this.Signature
DSASignatureDeformatter v = new DSASignatureDeformatter (dsa);
// only SHA-1 is supported
v.SetHashAlgorithm ("SHA1");
return v.VerifySignature (this.Hash, this.Signature);
}
public DSASignatureDeformatter(AsymmetricAlgorithm key) : this() {
if (key == null)
throw new ArgumentNullException("key");
Contract.EndContractBlock();
_dsaKey = (DSA) key;
}
//
// public methods
//
public override void SetKey(AsymmetricAlgorithm key) {
if (key == null)
throw new ArgumentNullException("key");
Contract.EndContractBlock();
_dsaKey = (DSA) key;
}
static public byte[] ToCapiPublicKeyBlob (DSA dsa)
{
DSAParameters p = dsa.ExportParameters (false);
int keyLength = p.P.Length; // in bytes
// header + P + Q + G + Y + count + seed
byte[] blob = new byte [16 + keyLength + 20 + keyLength + keyLength + 4 + 20];
blob [0] = 0x06; // Type - PUBLICKEYBLOB (0x06)
blob [1] = 0x02; // Version - Always CUR_BLOB_VERSION (0x02)
// [2], [3] // RESERVED - Always 0
blob [5] = 0x22; // ALGID
blob [8] = 0x44; // Magic
blob [9] = 0x53;
blob [10] = 0x53;
blob [11] = 0x31;
byte[] bitlen = GetBytesLE (keyLength << 3);
blob [12] = bitlen [0];
blob [13] = bitlen [1];
blob [14] = bitlen [2];
blob [15] = bitlen [3];
int pos = 16;
byte[] part;
part = p.P;
Array.Reverse (part);
Buffer.BlockCopy (part, 0, blob, pos, keyLength);
pos += keyLength;
part = p.Q;
Array.Reverse (part);
Buffer.BlockCopy (part, 0, blob, pos, 20);
pos += 20;
part = p.G;
Array.Reverse (part);
Buffer.BlockCopy (part, 0, blob, pos, keyLength);
pos += keyLength;
part = p.Y;
Array.Reverse (part);
Buffer.BlockCopy (part, 0, blob, pos, keyLength);
pos += keyLength;
Buffer.BlockCopy (GetBytesLE (p.Counter), 0, blob, pos, 4);
pos += 4;
part = p.Seed;
Array.Reverse (part);
Buffer.BlockCopy (part, 0, blob, pos, 20);
return blob;
}
static public byte[] ToCapiKeyBlob (DSA dsa, bool includePrivateKey)
{
if (dsa == null)
throw new ArgumentNullException ("dsa");
if (includePrivateKey)
return ToCapiPrivateKeyBlob (dsa);
else
return ToCapiPublicKeyBlob (dsa);
}
//
// public constructors
//
public DSAKeyValue () {
m_key = DSA.Create();
}
public DSAKeyValue (DSA key) {
m_key = key;
}
public static AsymmetricCipherKeyPair GetDsaKeyPair(
DSA dsa)
{
return GetDsaKeyPair(dsa.ExportParameters(true));
}
public static DsaPublicKeyParameters GetDsaPublicKey(
DSA dsa)
{
return GetDsaPublicKey(dsa.ExportParameters(false));
}
/************************* PUBLIC METHODS *************************/
/// <include file='doc\DSASignatureFormatter.uex' path='docs/doc[@for="DSASignatureFormatter.SetKey"]/*' />
public override void SetKey(AsymmetricAlgorithm key)
{
_dsaKey = (DSA)key;
}
public DSACryptoServiceProvider() : base()
{
// This class wraps DSA
_impl = DSA.Create();
KeySize = 1024;
}
public virtual byte[] Sign (DSA key)
{
string oid = "1.2.840.10040.4.3";
ASN1 tbs = ToBeSigned (oid);
HashAlgorithm ha = HashAlgorithm.Create (hashName);
if (!(ha is SHA1))
throw new NotSupportedException ("Only SHA-1 is supported for DSA");
byte[] hash = ha.ComputeHash (tbs.GetBytes ());
DSASignatureFormatter dsa = new DSASignatureFormatter (key);
dsa.SetHashAlgorithm (hashName);
byte[] rs = dsa.CreateSignature (hash);
// split R and S
byte[] r = new byte [20];
Buffer.BlockCopy (rs, 0, r, 0, 20);
byte[] s = new byte [20];
Buffer.BlockCopy (rs, 20, s, 0, 20);
ASN1 signature = new ASN1 (0x30);
signature.Add (new ASN1 (0x02, r));
signature.Add (new ASN1 (0x02, s));
// dsaWithSha1 (1 2 840 10040 4 3)
return Build (tbs, oid, signature.GetBytes ());
}
public DSASignatureDeformatterTest ()
{
// key generation is VERY long so one time is enough
dsa = DSA.Create ();
rsa = RSA.Create ();
}
internal bool VerifySignature (DSA dsa)
{
if (signatureOID != "1.2.840.10040.4.3")
throw new CryptographicException ("Unsupported hash algorithm: " + signatureOID);
DSASignatureDeformatter v = new DSASignatureDeformatter (dsa);
// only SHA-1 is supported
v.SetHashAlgorithm ("SHA1");
ASN1 sign = new ASN1 (signature);
if ((sign == null) || (sign.Count != 2))
return false;
// parts may be less than 20 bytes (i.e. first bytes were 0x00)
byte[] part1 = sign [0].Value;
byte[] part2 = sign [1].Value;
byte[] sig = new byte [40];
// parts may be less than 20 bytes (i.e. first bytes were 0x00)
// parts may be more than 20 bytes (i.e. first byte > 0x80, negative)
int s1 = System.Math.Max (0, part1.Length - 20);
int e1 = System.Math.Max (0, 20 - part1.Length);
Buffer.BlockCopy (part1, s1, sig, e1, part1.Length - s1);
int s2 = System.Math.Max (0, part2.Length - 20);
int e2 = System.Math.Max (20, 40 - part2.Length);
Buffer.BlockCopy (part2, s2, sig, e2, part2.Length - s2);
return v.VerifySignature (Hash, sig);
}
public DSAKeyValue (DSA key)
{
dsa = key;
}