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;
		}

	public DSASignatureDeformatterTest () 
	{
		// key generation is VERY long so one time is enough
		dsa = DSA.Create ();
		rsa = RSA.Create ();
	}

        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;
        }

 public override void SetKey(AsymmetricAlgorithm key)
 {
     if (key == null)
     {
         throw new ArgumentNullException("key");
     }
     this._dsaKey = (DSA) key;
 }

 public DSASignatureDeformatter(AsymmetricAlgorithm key) : this()
 {
     if (key == null)
     {
         throw new ArgumentNullException("key");
     }
     this._dsaKey = (DSA) key;
 }

	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 ();
	}

		public void SetUp () 
		{
			if (rsa == null) {
				rsa = RSA.Create ();
				rsa.ImportParameters (AllTests.GetRsaKey (true));
			}
			if (dsa == null)
				dsa = DSA.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;
			}

		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
		}

			static public byte[] Encode (DSA dsa) 
			{
				DSAParameters param = dsa.ExportParameters (true);
				return ASN1Convert.FromUnsignedBigInteger (param.X).GetBytes ();
			}

        //
        // public methods
        //

        public override void SetKey(AsymmetricAlgorithm key) {
            if (key == null) 
                throw new ArgumentNullException("key");
            Contract.EndContractBlock();
            _dsaKey = (DSA) key;
        }

 public DSASignatureDeformatter(AsymmetricAlgorithm key) : this() {
     if (key == null) 
         throw new ArgumentNullException("key");
     Contract.EndContractBlock();
     _dsaKey = (DSA) key;
 }

		static public byte[] ToCapiKeyBlob (DSA dsa, bool includePrivateKey)
		{
			if (dsa == null)
				throw new ArgumentNullException ("dsa");

			if (includePrivateKey)
				return ToCapiPrivateKeyBlob (dsa);
			else
				return ToCapiPublicKeyBlob (dsa);
		}

		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;
		}

 public DSAKeyValue (DSA key) {
     m_key = key;
 }