/********EXTERNAL OBJECT PUBLIC METHODS  - END ********/

        private String Sign(PrivateKey key, string hashAlgorithm, Stream input)
        {
            PrivateKeyManager keyMan = (PrivateKeyManager)key;

            if (keyMan.HasError())
            {
                this.error = keyMan.GetError();
                return("");
            }
            AsymmetricSigningAlgorithm asymmetricSigningAlgorithm = AsymmetricSigningAlgorithmUtils
                                                                    .GetAsymmetricSigningAlgorithm(keyMan.getPrivateKeyAlgorithm(), this.error);

            if (this.HasError())
            {
                return("");
            }
            ISigner signer = AsymmetricSigningAlgorithmUtils.GetSigner(asymmetricSigningAlgorithm, GetHash(hashAlgorithm),
                                                                       this.error);

            if (this.HasError())
            {
                return("");
            }
            SetUpSigner(signer, input, keyMan.getPrivateKeyParameterForSigning(), true);
            if (this.HasError())
            {
                return("");
            }
            byte[] outputBytes = null;
            try
            {
                outputBytes = signer.GenerateSignature();
            }
            catch (Exception e)
            {
                error.setError("AE01", e.Message);
                return("");
            }
            String result = "";

            try
            {
                result = Base64.ToBase64String(outputBytes);
            }
            catch (Exception e)
            {
                error.setError("AE018", e.Message);
                return("");
            }
            return(result);
        }
        private bool Verify(Certificate certificate, Stream input, string signature)
        {
            CertificateX509 cert = (CertificateX509)certificate;

            if (cert.HasError())
            {
                this.error = cert.GetError();
                return(false);
            }
            string hashAlgorithm = "";

            if (SecurityUtils.compareStrings(cert.getPublicKeyHash(), "ECDSA"))
            {
                hashAlgorithm = "SHA1";
            }
            else
            {
                hashAlgorithm = cert.getPublicKeyHash();
            }
            AsymmetricSigningAlgorithm asymmetricSigningAlgorithm = AsymmetricSigningAlgorithmUtils
                                                                    .GetAsymmetricSigningAlgorithm(cert.getPublicKeyAlgorithm(), this.error);

            if (this.HasError())
            {
                return(false);
            }
            ISigner signer = AsymmetricSigningAlgorithmUtils.GetSigner(asymmetricSigningAlgorithm, GetHash(hashAlgorithm),
                                                                       this.error);

            if (this.HasError())
            {
                return(false);
            }
            SetUpSigner(signer, input, cert.getPublicKeyParameterForSigning(), false);
            if (this.HasError())
            {
                return(false);
            }
            byte[] signatureBytes = null;
            try
            {
                signatureBytes = Base64.Decode(signature);
            }
            catch (Exception e)
            {
                error.setError("AE019", e.Message);
                return(false);
            }

            if (signatureBytes == null || signatureBytes.Length == 0)
            {
                this.error.setError("AE020", "Error reading signature");
                return(false);
            }
            bool result = false;

            try
            {
                result = signer.VerifySignature(signatureBytes);
            }
            catch (Exception e)
            {
                error.setError("AE021", e.Message);
                return(false);
            }
            return(result);
        }