mcs/class/referencesource/mscorlib/system/security/cryptography/icspasymmetricalgorithm.cs

   1 // ==++==
   2 //
   3 //   Copyright (c) Microsoft Corporation.  All rights reserved.
   4 //
   5 // ==--==
   6 // <OWNER>Microsoft</OWNER>
   7 //
   8
   9 //
  10 // ICspAsymmetricAlgorithm.cs
  11 //
  12
  13 namespace System.Security.Cryptography {
  14     using System.Security.AccessControl;
  15     using System.Security.Permissions;
  16
  17     [Serializable]
  18     [System.Runtime.InteropServices.ComVisible(true)]
  19     public enum KeyNumber {
  20         Exchange  = 1,
  21         Signature = 2
  22     }
  23
  24     [System.Runtime.InteropServices.ComVisible(true)]
  25     public sealed class CspKeyContainerInfo {
  26         private CspParameters m_parameters;
  27         private bool m_randomKeyContainer;
  28
  29         private CspKeyContainerInfo () {}
  30         [System.Security.SecurityCritical]  // auto-generated
  31         internal CspKeyContainerInfo (CspParameters parameters, bool randomKeyContainer) {
  32             if (!CompatibilitySwitches.IsAppEarlierThanWindowsPhone8) {
  33                 KeyContainerPermission kp = new KeyContainerPermission(KeyContainerPermissionFlags.NoFlags);
  34                 KeyContainerPermissionAccessEntry entry = new KeyContainerPermissionAccessEntry(parameters, KeyContainerPermissionFlags.Open);
  35                 kp.AccessEntries.Add(entry);
  36                 kp.Demand();
  37             }
  38
  39             m_parameters = new CspParameters(parameters);
  40             if (m_parameters.KeyNumber == -1) {
  41                 if (m_parameters.ProviderType == Constants.PROV_RSA_FULL || m_parameters.ProviderType == Constants.PROV_RSA_AES)
  42                     m_parameters.KeyNumber = Constants.AT_KEYEXCHANGE;
  43                 else if (m_parameters.ProviderType == Constants.PROV_DSS_DH)
  44                     m_parameters.KeyNumber = Constants.AT_SIGNATURE;
  45             }
  46             m_randomKeyContainer = randomKeyContainer;
  47         }
  48
  49         [System.Security.SecuritySafeCritical]  // auto-generated
  50         public CspKeyContainerInfo (CspParameters parameters) : this (parameters, false) {}
  51
  52         public bool MachineKeyStore {
  53             get {
  54                 return (m_parameters.Flags & CspProviderFlags.UseMachineKeyStore) == CspProviderFlags.UseMachineKeyStore ? true : false;
  55             }
  56         }
  57
  58         public string ProviderName {
  59             get {
  60                 return m_parameters.ProviderName;
  61             }
  62         }
  63
  64         public int ProviderType {
  65             get {
  66                 return m_parameters.ProviderType;
  67             }
  68         }
  69
  70         public string KeyContainerName {
  71             get {
  72                 return m_parameters.KeyContainerName;
  73             }
  74         }
  75
  76         public string UniqueKeyContainerName {
  77             [System.Security.SecuritySafeCritical]  // auto-generated
  78             get {
  79                 SafeProvHandle safeProvHandle = SafeProvHandle.InvalidHandle;
  80                 int hr = Utils._OpenCSP(m_parameters, Constants.CRYPT_SILENT, ref safeProvHandle);
  81                 if (hr != Constants.S_OK)
  82                     throw new CryptographicException(Environment.GetResourceString("Cryptography_CSP_NotFound"));
  83
  84                 string uniqueContainerName = (string) Utils._GetProviderParameter(safeProvHandle, m_parameters.KeyNumber, Constants.CLR_UNIQUE_CONTAINER);
  85                 safeProvHandle.Dispose();
  86                 return uniqueContainerName;
  87             }
  88         }
  89
  90         public KeyNumber KeyNumber {
  91             get {
  92                 return (KeyNumber) m_parameters.KeyNumber;
  93             }
  94         }
  95
  96         public bool Exportable {
  97             [System.Security.SecuritySafeCritical]  // auto-generated
  98             get {
  99                 // Assume hardware keys are not exportable.
 100                 if (this.HardwareDevice)
 101                     return false;
 102
 103                 SafeProvHandle safeProvHandle = SafeProvHandle.InvalidHandle;
 104                 int hr = Utils._OpenCSP(m_parameters, Constants.CRYPT_SILENT, ref safeProvHandle);
 105                 if (hr != Constants.S_OK)
 106                     throw new CryptographicException(Environment.GetResourceString("Cryptography_CSP_NotFound"));
 107
 108                 byte[] isExportable = (byte[]) Utils._GetProviderParameter(safeProvHandle, m_parameters.KeyNumber, Constants.CLR_EXPORTABLE);
 109                 safeProvHandle.Dispose();
 110                 return (isExportable[0] == 1);
 111             }
 112         }
 113
 114         public bool HardwareDevice {
 115             [System.Security.SecuritySafeCritical]  // auto-generated
 116             get {
 117                 SafeProvHandle safeProvHandle = SafeProvHandle.InvalidHandle;
 118                 CspParameters parameters = new CspParameters(m_parameters);
 119                 parameters.KeyContainerName = null;
 120                 parameters.Flags = (parameters.Flags & CspProviderFlags.UseMachineKeyStore) != 0 ? CspProviderFlags.UseMachineKeyStore : 0;
 121                 uint flags = Constants.CRYPT_VERIFYCONTEXT;
 122                 int hr = Utils._OpenCSP(parameters, flags, ref safeProvHandle);
 123                 if (hr != Constants.S_OK)
 124                     throw new CryptographicException(Environment.GetResourceString("Cryptography_CSP_NotFound"));
 125
 126                 byte[] isHardwareDevice = (byte[]) Utils._GetProviderParameter(safeProvHandle, parameters.KeyNumber, Constants.CLR_HARDWARE);
 127                 safeProvHandle.Dispose();
 128                 return (isHardwareDevice[0] == 1);
 129             }
 130         }
 131
 132         public bool Removable {
 133             [System.Security.SecuritySafeCritical]  // auto-generated
 134             get {
 135                 SafeProvHandle safeProvHandle = SafeProvHandle.InvalidHandle;
 136                 CspParameters parameters = new CspParameters(m_parameters);
 137                 parameters.KeyContainerName = null;
 138                 parameters.Flags = (parameters.Flags & CspProviderFlags.UseMachineKeyStore) != 0 ? CspProviderFlags.UseMachineKeyStore : 0;
 139                 uint flags = Constants.CRYPT_VERIFYCONTEXT;
 140                 int hr = Utils._OpenCSP(parameters, flags, ref safeProvHandle);
 141                 if (hr != Constants.S_OK)
 142                     throw new CryptographicException(Environment.GetResourceString("Cryptography_CSP_NotFound"));
 143
 144                 byte[] isRemovable = (byte[]) Utils._GetProviderParameter(safeProvHandle, parameters.KeyNumber, Constants.CLR_REMOVABLE);
 145                 safeProvHandle.Dispose();
 146                 return (isRemovable[0] == 1);
 147             }
 148         }
 149
 150         public bool Accessible {
 151             [System.Security.SecuritySafeCritical]  // auto-generated
 152             get {
 153                 // This method will pop-up a UI for hardware keys.
 154                 SafeProvHandle safeProvHandle = SafeProvHandle.InvalidHandle;
 155                 int hr = Utils._OpenCSP(m_parameters, Constants.CRYPT_SILENT, ref safeProvHandle);
 156                 if (hr != Constants.S_OK)
 157                     return false;
 158
 159                 byte[] isAccessible = (byte[]) Utils._GetProviderParameter(safeProvHandle, m_parameters.KeyNumber, Constants.CLR_ACCESSIBLE);
 160                 safeProvHandle.Dispose();
 161                 return (isAccessible[0] == 1);
 162             }
 163         }
 164
 165         public bool Protected {
 166             [System.Security.SecuritySafeCritical]  // auto-generated
 167             get {
 168                 // Assume hardware keys are protected.
 169                 if (this.HardwareDevice == true)
 170                     return true;
 171
 172                 SafeProvHandle safeProvHandle = SafeProvHandle.InvalidHandle;
 173                 int hr = Utils._OpenCSP(m_parameters, Constants.CRYPT_SILENT, ref safeProvHandle);
 174                 if (hr != Constants.S_OK)
 175                     throw new CryptographicException(Environment.GetResourceString("Cryptography_CSP_NotFound"));
 176
 177                 byte[] isProtected = (byte[]) Utils._GetProviderParameter(safeProvHandle, m_parameters.KeyNumber, Constants.CLR_PROTECTED);
 178                 safeProvHandle.Dispose();
 179                 return (isProtected[0] == 1);
 180             }
 181         }
 182
 183 #if FEATURE_MACL
 184         public CryptoKeySecurity CryptoKeySecurity {
 185             [System.Security.SecuritySafeCritical]  // auto-generated
 186             get {
 187                 KeyContainerPermission kp = new KeyContainerPermission(KeyContainerPermissionFlags.NoFlags);
 188                 KeyContainerPermissionAccessEntry entry = new KeyContainerPermissionAccessEntry(m_parameters,
 189                                                                                                 KeyContainerPermissionFlags.ChangeAcl |
 190                                                                                                 KeyContainerPermissionFlags.ViewAcl);
 191                 kp.AccessEntries.Add(entry);
 192                 kp.Demand();
 193
 194                 SafeProvHandle safeProvHandle = SafeProvHandle.InvalidHandle;
 195                 int hr = Utils._OpenCSP(m_parameters, Constants.CRYPT_SILENT, ref safeProvHandle);
 196                 if (hr != Constants.S_OK)
 197                     throw new CryptographicException(Environment.GetResourceString("Cryptography_CSP_NotFound"));
 198
 199                 using (safeProvHandle) {
 200                     return Utils.GetKeySetSecurityInfo(safeProvHandle, AccessControlSections.All);
 201                 }
 202             }
 203         }
 204 #endif //FEATURE_MACL
 205
 206         public bool RandomlyGenerated {
 207             get {
 208                 return m_randomKeyContainer;
 209             }
 210         }
 211     }
 212
 213     [System.Runtime.InteropServices.ComVisible(true)]
 214     public interface ICspAsymmetricAlgorithm {
 215         CspKeyContainerInfo CspKeyContainerInfo { get; }
 216 #if FEATURE_LEGACYNETCFCRYPTO
 217         [SecurityCritical]
 218 #endif
 219         byte[] ExportCspBlob (bool includePrivateParameters);
 220
 221 #if FEATURE_LEGACYNETCFCRYPTO
 222         [SecurityCritical]
 223 #endif
 224         void ImportCspBlob (byte[] rawData);
 225     }
 226 }