RsaSecurityKey.cs source code in C# .NET

                        Code:
                         / WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / IdentityModel / System / IdentityModel / Tokens / RsaSecurityKey.cs / 1 / RsaSecurityKey.cs
                        
                        
                            //------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------

namespace System.IdentityModel.Tokens 
{
    using System.IdentityModel.Selectors; 
    using System.Security.Cryptography; 
    using System.Security.Cryptography.Xml;
 
    sealed public class RsaSecurityKey : AsymmetricSecurityKey
    {
        PrivateKeyStatus privateKeyStatus = PrivateKeyStatus.AvailabilityNotDetermined;
        readonly RSA rsa; 

        public RsaSecurityKey(RSA rsa) 
        { 
            if (rsa == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("rsa"); 

            this.rsa = rsa;
        }
 
        public override int KeySize
        { 
            get { return this.rsa.KeySize; } 
        }
 
        public override byte[] DecryptKey(string algorithm, byte[] keyData)
        {
            switch (algorithm)
            { 
                case SecurityAlgorithms.RsaV15KeyWrap:
                    return EncryptedXml.DecryptKey(keyData, rsa, false); 
                case SecurityAlgorithms.RsaOaepKeyWrap: 
                    return EncryptedXml.DecryptKey(keyData, rsa, true);
                default: 
                    throw  DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CryptographicException(SR.GetString(SR.UnsupportedAlgorithmForCryptoOperation,
                        algorithm, "DecryptKey")));
            }
        } 

        public override byte[] EncryptKey(string algorithm, byte[] keyData) 
        { 
            switch (algorithm)
            { 
                case SecurityAlgorithms.RsaV15KeyWrap:
                    return EncryptedXml.EncryptKey(keyData, rsa, false);
                case SecurityAlgorithms.RsaOaepKeyWrap:
                    return EncryptedXml.EncryptKey(keyData, rsa, true); 
                default:
                    throw  DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CryptographicException(SR.GetString(SR.UnsupportedAlgorithmForCryptoOperation, 
                        algorithm, "EncryptKey"))); 
            }
        } 

        public override AsymmetricAlgorithm GetAsymmetricAlgorithm(string algorithm, bool requiresPrivateKey)
        {
            if (requiresPrivateKey && !HasPrivateKey()) 
            {
                throw  DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CryptographicException(SR.GetString(SR.NoPrivateKeyAvailable))); 
            } 
            return this.rsa;
        } 

        public override HashAlgorithm GetHashAlgorithmForSignature(string algorithm)
        {
            switch (algorithm) 
            {
                case SecurityAlgorithms.RsaSha1Signature: 
                    return CryptoHelper.NewSha1HashAlgorithm(); 
                default:
                    throw  DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CryptographicException(SR.GetString(SR.UnsupportedAlgorithmForCryptoOperation, 
                        algorithm, "GetHashAlgorithmForSignature")));
            }
        }
 
        public override AsymmetricSignatureDeformatter GetSignatureDeformatter(string algorithm)
        { 
            switch (algorithm) 
            {
                case SecurityAlgorithms.RsaSha1Signature: 
                    return new RSAPKCS1SignatureDeformatter(rsa);
                default:
                    throw  DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CryptographicException(SR.GetString(SR.UnsupportedAlgorithmForCryptoOperation,
                        algorithm, "GetSignatureDeformatter"))); 
            }
        } 
 
        public override AsymmetricSignatureFormatter GetSignatureFormatter(string algorithm)
        { 
            switch (algorithm)
            {
                case SecurityAlgorithms.RsaSha1Signature:
                    return new RSAPKCS1SignatureFormatter(rsa); 
                default:
                    throw  DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CryptographicException(SR.GetString(SR.UnsupportedAlgorithmForCryptoOperation, 
                        algorithm, "GetSignatureFormatter"))); 
            }
        } 

        public override bool HasPrivateKey()
        {
            if (this.privateKeyStatus == PrivateKeyStatus.AvailabilityNotDetermined) 
            {
                RSACryptoServiceProvider rsaCryptoServiceProvider = this.rsa as RSACryptoServiceProvider; 
                if (rsaCryptoServiceProvider != null) 
                {
                    this.privateKeyStatus = rsaCryptoServiceProvider.PublicOnly ? PrivateKeyStatus.DoesNotHavePrivateKey : PrivateKeyStatus.HasPrivateKey; 
                }
                else
                {
                    try 
                    {
                        byte[] hash = new byte[20]; 
                        this.rsa.DecryptValue(hash); // imitate signing 
                        this.privateKeyStatus = PrivateKeyStatus.HasPrivateKey;
                    } 
                    catch (CryptographicException)
                    {
                        this.privateKeyStatus = PrivateKeyStatus.DoesNotHavePrivateKey;
                    } 
                }
            } 
            return this.privateKeyStatus == PrivateKeyStatus.HasPrivateKey; 
        }
 
        public override bool IsAsymmetricAlgorithm(string algorithm)
        {
            return CryptoHelper.IsAsymmetricAlgorithm(algorithm);
        } 

        public override bool IsSupportedAlgorithm(string algorithm) 
        { 
            switch (algorithm)
            { 
                case SecurityAlgorithms.RsaV15KeyWrap:
                case SecurityAlgorithms.RsaOaepKeyWrap:
                case SecurityAlgorithms.RsaSha1Signature:
                    return true; 
                default:
                    return false; 
            } 
        }
 
        public override bool IsSymmetricAlgorithm(string algorithm)
        {
            return CryptoHelper.IsSymmetricAlgorithm(algorithm);
        } 

 
        enum PrivateKeyStatus 
        {
            AvailabilityNotDetermined, 
            HasPrivateKey,
            DoesNotHavePrivateKey
        }
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
RsaSecurityKey.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
