public override void ImportParameters(DSAParameters parameters)
{
DSACspObject cspObject = DSAStructToObject(parameters);
if ((this._safeKeyHandle != null) && !this._safeKeyHandle.IsClosed)
{
this._safeKeyHandle.Dispose();
}
this._safeKeyHandle = SafeKeyHandle.InvalidHandle;
if (IsPublic(parameters))
{
Utils._ImportKey(Utils.StaticDssProvHandle, 0x2200, CspProviderFlags.NoFlags, cspObject, ref this._safeKeyHandle);
}
else
{
KeyContainerPermission permission = new KeyContainerPermission(KeyContainerPermissionFlags.NoFlags);
KeyContainerPermissionAccessEntry accessEntry = new KeyContainerPermissionAccessEntry(this._parameters, KeyContainerPermissionFlags.Import);
permission.AccessEntries.Add(accessEntry);
permission.Demand();
if (this._safeProvHandle == null)
{
this._safeProvHandle = Utils.CreateProvHandle(this._parameters, this._randomKeyContainer);
}
Utils._ImportKey(this._safeProvHandle, 0x2200, this._parameters.Flags, cspObject, ref this._safeKeyHandle);
}
}
[System.Security.SecuritySafeCritical] // auto-generated
public override void ImportParameters(DSAParameters parameters)
{
DSACspObject dsaCspObject = DSAStructToObject(parameters);
// Free the current key handle
if (_safeKeyHandle != null && !_safeKeyHandle.IsClosed)
{
_safeKeyHandle.Dispose();
}
_safeKeyHandle = SafeKeyHandle.InvalidHandle;
if (IsPublic(parameters))
{
// Use our CRYPT_VERIFYCONTEXT handle, CRYPT_EXPORTABLE is not applicable to public only keys, so pass false
Utils._ImportKey(Utils.StaticDssProvHandle, Constants.CALG_DSS_SIGN, (CspProviderFlags)0, dsaCspObject, ref _safeKeyHandle);
}
else
{
KeyContainerPermission kp = new KeyContainerPermission(KeyContainerPermissionFlags.NoFlags);
KeyContainerPermissionAccessEntry entry = new KeyContainerPermissionAccessEntry(_parameters, KeyContainerPermissionFlags.Import);
kp.AccessEntries.Add(entry);
kp.Demand();
if (_safeProvHandle == null)
{
_safeProvHandle = Utils.CreateProvHandle(_parameters, _randomKeyContainer);
}
// Now, import the key into the CSP; _ImportKey will check for failures.
Utils._ImportKey(_safeProvHandle, Constants.CALG_DSS_SIGN, _parameters.Flags, dsaCspObject, ref _safeKeyHandle);
}
}
/************************* PRIVATE METHODS ************************/
private void ReverseDSACspObject(DSACspObject obj)
{
if (obj.P != null)
{
Array.Reverse(obj.P);
}
if (obj.Q != null)
{
Array.Reverse(obj.Q);
}
if (obj.G != null)
{
Array.Reverse(obj.G);
}
if (obj.Y != null)
{
Array.Reverse(obj.Y);
}
if (obj.X != null)
{
Array.Reverse(obj.X);
}
if (obj.J != null)
{
Array.Reverse(obj.J);
}
if (obj.seed != null)
{
Array.Reverse(obj.seed);
}
}
private static DSAParameters DSAObjectToStruct(DSACspObject dsaCspObject)
{
return(new DSAParameters()
{
P = dsaCspObject.P, Q = dsaCspObject.Q, G = dsaCspObject.G, Y = dsaCspObject.Y, J = dsaCspObject.J, X = dsaCspObject.X, Seed = dsaCspObject.Seed, Counter = dsaCspObject.Counter
});
}
private static DSACspObject DSAStructToObject(DSAParameters dsaParams)
{
DSACspObject dsaCspObject = new DSACspObject();
dsaCspObject.P = dsaParams.P;
dsaCspObject.Q = dsaParams.Q;
dsaCspObject.G = dsaParams.G;
dsaCspObject.Y = dsaParams.Y;
dsaCspObject.J = dsaParams.J;
dsaCspObject.X = dsaParams.X;
dsaCspObject.Seed = dsaParams.Seed;
dsaCspObject.Counter = dsaParams.Counter;
return(dsaCspObject);
}
public override DSAParameters ExportParameters(bool includePrivateParameters)
{
this.GetKeyPair();
if (includePrivateParameters)
{
KeyContainerPermission containerPermission = new KeyContainerPermission(KeyContainerPermissionFlags.NoFlags);
KeyContainerPermissionAccessEntry accessEntry = new KeyContainerPermissionAccessEntry(this._parameters, KeyContainerPermissionFlags.Export);
containerPermission.AccessEntries.Add(accessEntry);
containerPermission.Demand();
}
DSACspObject dsaCspObject = new DSACspObject();
Utils._ExportKey(this._safeKeyHandle, includePrivateParameters ? 7 : 6, (object)dsaCspObject);
return(DSACryptoServiceProvider.DSAObjectToStruct(dsaCspObject));
}
public override DSAParameters ExportParameters(bool includePrivateParameters)
{
this.GetKeyPair();
if (includePrivateParameters)
{
KeyContainerPermission permission = new KeyContainerPermission(KeyContainerPermissionFlags.NoFlags);
KeyContainerPermissionAccessEntry accessEntry = new KeyContainerPermissionAccessEntry(this._parameters, KeyContainerPermissionFlags.Export);
permission.AccessEntries.Add(accessEntry);
permission.Demand();
}
DSACspObject cspObject = new DSACspObject();
int blobType = includePrivateParameters ? 7 : 6;
Utils._ExportKey(this._safeKeyHandle, blobType, cspObject);
return(DSAObjectToStruct(cspObject));
}
[System.Security.SecuritySafeCritical] // auto-generated
public override DSAParameters ExportParameters(bool includePrivateParameters)
{
GetKeyPair();
if (includePrivateParameters)
{
KeyContainerPermission kp = new KeyContainerPermission(KeyContainerPermissionFlags.NoFlags);
KeyContainerPermissionAccessEntry entry = new KeyContainerPermissionAccessEntry(_parameters, KeyContainerPermissionFlags.Export);
kp.AccessEntries.Add(entry);
kp.Demand();
}
DSACspObject dsaCspObject = new DSACspObject();
int blobType = includePrivateParameters ? Constants.PRIVATEKEYBLOB : Constants.PUBLICKEYBLOB;
// _ExportKey will check for failures and throw an exception
Utils._ExportKey(_safeKeyHandle, blobType, dsaCspObject);
return(DSAObjectToStruct(dsaCspObject));
}
private extern IntPtr _ImportKey(IntPtr hCSP, int algid, DSACspObject data);
private extern int _ExportKey(IntPtr hkey1, int hkey2, DSACspObject keyData);
/// <include file='doc\DSACryptoServiceProvider.uex' path='docs/doc[@for="DSACryptoServiceProvider.ImportParameters"]/*' />
public override void ImportParameters(DSAParameters parameters)
{
if (_CSPHandleProtector.IsClosed || _KeyHandleProtector.IsClosed)
{
throw new ObjectDisposedException(null, Environment.GetResourceString("ObjectDisposed_Generic_ObjectName1"));
}
DSACspObject dsaKey = new DSACspObject();
// P, Q, G are required
if (parameters.P == null)
{
throw new CryptographicException(Environment.GetResourceString("Cryptography_MissingField"));
}
dsaKey.P = (byte[])parameters.P.Clone();
if (parameters.Q == null)
{
throw new CryptographicException(Environment.GetResourceString("Cryptography_MissingField"));
}
dsaKey.Q = (byte[])parameters.Q.Clone();
if (parameters.G == null)
{
throw new CryptographicException(Environment.GetResourceString("Cryptography_MissingField"));
}
dsaKey.G = (byte[])parameters.G.Clone();
// Y is not required
dsaKey.Y = (parameters.Y == null ? null : ((byte[])parameters.Y.Clone()));
// J is not required
dsaKey.J = (parameters.J == null ? null : ((byte[])parameters.J.Clone()));
// seed is not required
dsaKey.seed = (parameters.Seed == null ? null : ((byte[])parameters.Seed.Clone()));
// counter is not required
dsaKey.counter = parameters.Counter;
// X is not required -- private component
dsaKey.X = (parameters.X == null ? null : ((byte[])parameters.X.Clone()));
// NOTE: We must reverse the dsaKey before importing!
ReverseDSACspObject(dsaKey);
// Free the current key handle
_KeyHandleProtector.Close();
// Now, import the key into the CSP
bool incremented = false;
try {
if (_CSPHandleProtector.TryAddRef(ref incremented))
{
_hKey = _ImportKey(_CSPHandleProtector.Handle, CALG_DSA_SIGN, dsaKey);
}
else
{
throw new ObjectDisposedException(null, Environment.GetResourceString("ObjectDisposed_Generic_ObjectName1"));
}
}
finally {
if (incremented)
{
_CSPHandleProtector.Release();
}
}
_KeyHandleProtector = new __KeyHandleProtector(_hKey);
_parameters.KeyNumber = AT_SIGNATURE;
if (dsaKey.X == null)
{
// If no X, then only have the public
_containerContents = KeyContainerContents.PublicOnly;
}
else
{
// Our key pairs are always exportable
_containerContents = KeyContainerContents.PublicAndExportablePrivate;
}
// zeroize private key material
if (dsaKey.X != null)
{
Array.Clear(dsaKey.X, 0, dsaKey.X.Length);
}
}
/************************* PUBLIC METHODS ************************/
/// <include file='doc\DSACryptoServiceProvider.uex' path='docs/doc[@for="DSACryptoServiceProvider.ExportParameters"]/*' />
public override DSAParameters ExportParameters(bool includePrivateParameters)
{
int hr;
if (_CSPHandleProtector.IsClosed || _KeyHandleProtector.IsClosed)
{
throw new ObjectDisposedException(null, Environment.GetResourceString("ObjectDisposed_Generic_ObjectName1"));
}
DSACspObject dsaKey = new DSACspObject();
DSAParameters dsaParams = new DSAParameters();
if (includePrivateParameters)
{
bool incremented = false;
try {
if (_KeyHandleProtector.TryAddRef(ref incremented))
{
hr = _ExportKey(_KeyHandleProtector.Handle, PRIVATEKEYBLOB, dsaKey);
}
else
{
throw new ObjectDisposedException(null, Environment.GetResourceString("ObjectDisposed_Generic_ObjectName1"));
}
}
finally {
if (incremented)
{
_KeyHandleProtector.Release();
}
}
if (hr != 0)
{
throw new CryptographicException(Environment.GetResourceString("Cryptography_CSP_ExportKey"));
}
// Must reverse after export from CAPI!
ReverseDSACspObject(dsaKey);
dsaParams.P = dsaKey.P;
dsaParams.Q = dsaKey.Q;
dsaParams.G = dsaKey.G;
dsaParams.Y = dsaKey.Y;
dsaParams.X = dsaKey.X;
if (dsaKey.J != null)
{
dsaParams.J = dsaKey.J;
}
if (dsaKey.seed != null)
{
dsaParams.Seed = dsaKey.seed;
dsaParams.Counter = dsaKey.counter;
}
}
else
{
bool incremented = false;
try {
if (_KeyHandleProtector.TryAddRef(ref incremented))
{
hr = _ExportKey(_KeyHandleProtector.Handle, PUBLICKEYBLOB, dsaKey);
}
else
{
throw new ObjectDisposedException(null, Environment.GetResourceString("ObjectDisposed_Generic_ObjectName1"));
}
}
finally {
if (incremented)
{
_KeyHandleProtector.Release();
}
}
if (hr != 0)
{
throw new CryptographicException(Environment.GetResourceString("Cryptography_CSP_ExportKey"));
}
// Must reverse (into network byte order) after export from CAPI!
ReverseDSACspObject(dsaKey);
dsaParams.P = dsaKey.P;
dsaParams.Q = dsaKey.Q;
dsaParams.G = dsaKey.G;
dsaParams.Y = dsaKey.Y;
if (dsaKey.J != null)
{
dsaParams.J = dsaKey.J;
}
if (dsaKey.seed != null)
{
dsaParams.Seed = dsaKey.seed;
dsaParams.Counter = dsaKey.counter;
}
// zeroize private key material
if (dsaKey.X != null)
{
Array.Clear(dsaKey.X, 0, dsaKey.X.Length);
}
}
return(dsaParams);
}
private static DSACspObject DSAStructToObject (DSAParameters dsaParams) {
DSACspObject dsaCspObject = new DSACspObject();
dsaCspObject.P = dsaParams.P;
dsaCspObject.Q = dsaParams.Q;
dsaCspObject.G = dsaParams.G;
dsaCspObject.Y = dsaParams.Y;
dsaCspObject.J = dsaParams.J;
dsaCspObject.X = dsaParams.X;
dsaCspObject.Seed = dsaParams.Seed;
dsaCspObject.Counter = dsaParams.Counter;
return dsaCspObject;
}
[System.Security.SecuritySafeCritical] // auto-generated
public override DSAParameters ExportParameters (bool includePrivateParameters) {
GetKeyPair();
if (includePrivateParameters) {
KeyContainerPermission kp = new KeyContainerPermission(KeyContainerPermissionFlags.NoFlags);
KeyContainerPermissionAccessEntry entry = new KeyContainerPermissionAccessEntry(_parameters, KeyContainerPermissionFlags.Export);
kp.AccessEntries.Add(entry);
kp.Demand();
}
DSACspObject dsaCspObject = new DSACspObject();
int blobType = includePrivateParameters ? Constants.PRIVATEKEYBLOB : Constants.PUBLICKEYBLOB;
// _ExportKey will check for failures and throw an exception
Utils._ExportKey(_safeKeyHandle, blobType, dsaCspObject);
return DSAObjectToStruct(dsaCspObject);
}
