Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / whidbey / netfxsp / ndp / clr / src / BCL / System / Security / Cryptography / DSACryptoServiceProvider.cs / 1 / DSACryptoServiceProvider.cs
// ==++==
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// ==--==
//
// DSACryptoServiceProvider.cs
//
// CSP-based implementation of DSA
//
namespace System.Security.Cryptography {
using System;
using System.IO;
using System.Security.Cryptography.X509Certificates;
using System.Security.Permissions;
using System.Globalization;
// Object layout of the DSAParameters structure
internal class DSACspObject {
internal byte[] P;
internal byte[] Q;
internal byte[] G;
internal byte[] Y;
internal byte[] J;
internal byte[] X;
internal byte[] Seed;
internal int Counter;
}
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class DSACryptoServiceProvider : DSA, ICspAsymmetricAlgorithm {
private int _dwKeySize;
private CspParameters _parameters;
private bool _randomKeyContainer;
private SafeProvHandle _safeProvHandle;
private SafeKeyHandle _safeKeyHandle;
private SHA1CryptoServiceProvider _sha1;
private static CspProviderFlags s_UseMachineKeyStore = 0;
//
// public constructors
//
public DSACryptoServiceProvider()
: this(0, new CspParameters(Constants.PROV_DSS_DH, null, null, s_UseMachineKeyStore)) {
}
public DSACryptoServiceProvider(int dwKeySize)
: this(dwKeySize, new CspParameters(Constants.PROV_DSS_DH, null, null, s_UseMachineKeyStore)) {
}
public DSACryptoServiceProvider(CspParameters parameters)
: this(0, parameters) {
}
public DSACryptoServiceProvider(int dwKeySize, CspParameters parameters) {
if (dwKeySize < 0)
throw new ArgumentOutOfRangeException("dwKeySize", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
_parameters = Utils.SaveCspParameters(CspAlgorithmType.Dss, parameters, s_UseMachineKeyStore, ref _randomKeyContainer);
LegalKeySizesValue = new KeySizes[] { new KeySizes(512, 1024, 64) }; // per the DSS spec
_dwKeySize = dwKeySize;
_sha1 = new SHA1CryptoServiceProvider();
// If this is not a random container we generate, create it eagerly
// in the constructor so we can report any errors now.
if (!_randomKeyContainer || Environment.GetCompatibilityFlag(CompatibilityFlag.EagerlyGenerateRandomAsymmKeys))
GetKeyPair();
}
//
// private methods
//
private void GetKeyPair () {
if (_safeKeyHandle == null) {
lock (this) {
if (_safeKeyHandle == null)
Utils.GetKeyPairHelper(CspAlgorithmType.Dss, _parameters, _randomKeyContainer, _dwKeySize, ref _safeProvHandle, ref _safeKeyHandle);
}
}
}
protected override void Dispose(bool disposing) {
if (_safeKeyHandle != null && !_safeKeyHandle.IsClosed)
_safeKeyHandle.Dispose();
if (_safeProvHandle != null && !_safeProvHandle.IsClosed)
_safeProvHandle.Dispose();
}
//
// public properties
//
[System.Runtime.InteropServices.ComVisible(false)]
public bool PublicOnly {
get {
GetKeyPair();
byte[] publicKey = (byte[]) Utils._GetKeyParameter(_safeKeyHandle, Constants.CLR_PUBLICKEYONLY);
return (publicKey[0] == 1);
}
}
[System.Runtime.InteropServices.ComVisible(false)]
public CspKeyContainerInfo CspKeyContainerInfo {
get {
GetKeyPair();
return new CspKeyContainerInfo(_parameters, _randomKeyContainer);
}
}
public override int KeySize {
get {
GetKeyPair();
byte[] keySize = (byte[]) Utils._GetKeyParameter(_safeKeyHandle, Constants.CLR_KEYLEN);
_dwKeySize = (keySize[0] | (keySize[1] << 8) | (keySize[2] << 16) | (keySize[3] << 24));
return _dwKeySize;
}
}
public override string KeyExchangeAlgorithm {
get { return null; }
}
public override string SignatureAlgorithm {
get { return "http://www.w3.org/2000/09/xmldsig#dsa-sha1"; }
}
public static bool UseMachineKeyStore {
get { return (s_UseMachineKeyStore == CspProviderFlags.UseMachineKeyStore); }
set { s_UseMachineKeyStore = (value ? CspProviderFlags.UseMachineKeyStore : 0); }
}
public bool PersistKeyInCsp {
get {
if (_safeProvHandle == null) {
lock (this) {
if (_safeProvHandle == null)
_safeProvHandle = Utils.CreateProvHandle(_parameters, _randomKeyContainer);
}
}
return Utils._GetPersistKeyInCsp(_safeProvHandle);
}
set {
bool oldPersistKeyInCsp = this.PersistKeyInCsp;
if (value == oldPersistKeyInCsp)
return;
KeyContainerPermission kp = new KeyContainerPermission(KeyContainerPermissionFlags.NoFlags);
if (!value) {
KeyContainerPermissionAccessEntry entry = new KeyContainerPermissionAccessEntry(_parameters, KeyContainerPermissionFlags.Delete);
kp.AccessEntries.Add(entry);
} else {
KeyContainerPermissionAccessEntry entry = new KeyContainerPermissionAccessEntry(_parameters, KeyContainerPermissionFlags.Create);
kp.AccessEntries.Add(entry);
}
kp.Demand();
Utils._SetPersistKeyInCsp(_safeProvHandle, value);
}
}
//
// public methods
//
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);
}
[System.Runtime.InteropServices.ComVisible(false)]
public byte[] ExportCspBlob (bool includePrivateParameters) {
GetKeyPair();
return Utils.ExportCspBlobHelper(includePrivateParameters, _parameters, _safeKeyHandle);
}
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);
}
}
[System.Runtime.InteropServices.ComVisible(false)]
public void ImportCspBlob (byte[] keyBlob) {
Utils.ImportCspBlobHelper(CspAlgorithmType.Dss, keyBlob, IsPublic(keyBlob), ref _parameters, _randomKeyContainer, ref _safeProvHandle, ref _safeKeyHandle);
}
public byte[] SignData(Stream inputStream) {
byte[] hashVal = _sha1.ComputeHash(inputStream);
return SignHash(hashVal, null);
}
public byte[] SignData(byte[] buffer) {
byte[] hashVal = _sha1.ComputeHash(buffer);
return SignHash(hashVal, null);
}
public byte[] SignData(byte[] buffer, int offset, int count) {
byte[] hashVal = _sha1.ComputeHash(buffer, offset, count);
return SignHash(hashVal, null);
}
public bool VerifyData(byte[] rgbData, byte[] rgbSignature) {
byte[] hashVal = _sha1.ComputeHash(rgbData);
return VerifyHash(hashVal, null, rgbSignature);
}
override public byte[] CreateSignature(byte[] rgbHash) {
return SignHash(rgbHash, null);
}
override public bool VerifySignature(byte[] rgbHash, byte[] rgbSignature) {
return VerifyHash(rgbHash, null, rgbSignature);
}
public byte[] SignHash(byte[] rgbHash, string str) {
if (rgbHash == null)
throw new ArgumentNullException("rgbHash");
if (PublicOnly)
throw new CryptographicException(Environment.GetResourceString("Cryptography_CSP_NoPrivateKey"));
int calgHash = X509Utils.OidToAlgId(str);
if (rgbHash.Length != _sha1.HashSize / 8)
throw new CryptographicException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Cryptography_InvalidHashSize"), "SHA1", _sha1.HashSize / 8));
GetKeyPair();
if (!CspKeyContainerInfo.RandomlyGenerated) {
KeyContainerPermission kp = new KeyContainerPermission(KeyContainerPermissionFlags.NoFlags);
KeyContainerPermissionAccessEntry entry = new KeyContainerPermissionAccessEntry(_parameters, KeyContainerPermissionFlags.Sign);
kp.AccessEntries.Add(entry);
kp.Demand();
}
return Utils._SignValue(_safeKeyHandle, _parameters.KeyNumber, Constants.CALG_DSS_SIGN, calgHash, rgbHash, 0);
}
public bool VerifyHash(byte[] rgbHash, string str, byte[] rgbSignature) {
if (rgbHash == null)
throw new ArgumentNullException("rgbHash");
if (rgbSignature == null)
throw new ArgumentNullException("rgbSignature");
int calgHash = X509Utils.OidToAlgId(str);
if (rgbHash.Length != _sha1.HashSize / 8)
throw new CryptographicException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Cryptography_InvalidHashSize"), "SHA1", _sha1.HashSize / 8));
GetKeyPair();
return Utils._VerifySign(_safeKeyHandle, Constants.CALG_DSS_SIGN, calgHash, rgbHash, rgbSignature, 0);
}
//
// private static methods
//
private static DSAParameters DSAObjectToStruct (DSACspObject dsaCspObject) {
DSAParameters dsaParams = new DSAParameters();
dsaParams.P = dsaCspObject.P;
dsaParams.Q = dsaCspObject.Q;
dsaParams.G = dsaCspObject.G;
dsaParams.Y = dsaCspObject.Y;
dsaParams.J = dsaCspObject.J;
dsaParams.X = dsaCspObject.X;
dsaParams.Seed = dsaCspObject.Seed;
dsaParams.Counter = dsaCspObject.Counter;
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;
}
private static bool IsPublic (DSAParameters dsaParams) {
return (dsaParams.X == null);
}
// find whether a DSS key blob is public.
private static bool IsPublic (byte[] keyBlob) {
if (keyBlob == null)
throw new ArgumentNullException("keyBlob");
// The CAPI DSS public key representation consists of the following sequence:
// - BLOBHEADER
// - DSSPUBKEY
// - rgbP[cbKey]
// - rgbQ[20]
// - rgbG[cbKey]
// - rgbY[cbKey]
// - DSSSEED
// The first should be PUBLICKEYBLOB and magic should be DSS_MAGIC "DSS1" or DSS_PUB_MAGIC_VER3 "DSS3"
if (keyBlob[0] != Constants.PUBLICKEYBLOB)
return false;
if ((keyBlob[11] != 0x31 && keyBlob[11] != 0x33) || keyBlob[10] != 0x53 || keyBlob[9] != 0x53 || keyBlob[8] != 0x44)
return false;
return true;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// ==++==
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// ==--==
//
// DSACryptoServiceProvider.cs
//
// CSP-based implementation of DSA
//
namespace System.Security.Cryptography {
using System;
using System.IO;
using System.Security.Cryptography.X509Certificates;
using System.Security.Permissions;
using System.Globalization;
// Object layout of the DSAParameters structure
internal class DSACspObject {
internal byte[] P;
internal byte[] Q;
internal byte[] G;
internal byte[] Y;
internal byte[] J;
internal byte[] X;
internal byte[] Seed;
internal int Counter;
}
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class DSACryptoServiceProvider : DSA, ICspAsymmetricAlgorithm {
private int _dwKeySize;
private CspParameters _parameters;
private bool _randomKeyContainer;
private SafeProvHandle _safeProvHandle;
private SafeKeyHandle _safeKeyHandle;
private SHA1CryptoServiceProvider _sha1;
private static CspProviderFlags s_UseMachineKeyStore = 0;
//
// public constructors
//
public DSACryptoServiceProvider()
: this(0, new CspParameters(Constants.PROV_DSS_DH, null, null, s_UseMachineKeyStore)) {
}
public DSACryptoServiceProvider(int dwKeySize)
: this(dwKeySize, new CspParameters(Constants.PROV_DSS_DH, null, null, s_UseMachineKeyStore)) {
}
public DSACryptoServiceProvider(CspParameters parameters)
: this(0, parameters) {
}
public DSACryptoServiceProvider(int dwKeySize, CspParameters parameters) {
if (dwKeySize < 0)
throw new ArgumentOutOfRangeException("dwKeySize", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
_parameters = Utils.SaveCspParameters(CspAlgorithmType.Dss, parameters, s_UseMachineKeyStore, ref _randomKeyContainer);
LegalKeySizesValue = new KeySizes[] { new KeySizes(512, 1024, 64) }; // per the DSS spec
_dwKeySize = dwKeySize;
_sha1 = new SHA1CryptoServiceProvider();
// If this is not a random container we generate, create it eagerly
// in the constructor so we can report any errors now.
if (!_randomKeyContainer || Environment.GetCompatibilityFlag(CompatibilityFlag.EagerlyGenerateRandomAsymmKeys))
GetKeyPair();
}
//
// private methods
//
private void GetKeyPair () {
if (_safeKeyHandle == null) {
lock (this) {
if (_safeKeyHandle == null)
Utils.GetKeyPairHelper(CspAlgorithmType.Dss, _parameters, _randomKeyContainer, _dwKeySize, ref _safeProvHandle, ref _safeKeyHandle);
}
}
}
protected override void Dispose(bool disposing) {
if (_safeKeyHandle != null && !_safeKeyHandle.IsClosed)
_safeKeyHandle.Dispose();
if (_safeProvHandle != null && !_safeProvHandle.IsClosed)
_safeProvHandle.Dispose();
}
//
// public properties
//
[System.Runtime.InteropServices.ComVisible(false)]
public bool PublicOnly {
get {
GetKeyPair();
byte[] publicKey = (byte[]) Utils._GetKeyParameter(_safeKeyHandle, Constants.CLR_PUBLICKEYONLY);
return (publicKey[0] == 1);
}
}
[System.Runtime.InteropServices.ComVisible(false)]
public CspKeyContainerInfo CspKeyContainerInfo {
get {
GetKeyPair();
return new CspKeyContainerInfo(_parameters, _randomKeyContainer);
}
}
public override int KeySize {
get {
GetKeyPair();
byte[] keySize = (byte[]) Utils._GetKeyParameter(_safeKeyHandle, Constants.CLR_KEYLEN);
_dwKeySize = (keySize[0] | (keySize[1] << 8) | (keySize[2] << 16) | (keySize[3] << 24));
return _dwKeySize;
}
}
public override string KeyExchangeAlgorithm {
get { return null; }
}
public override string SignatureAlgorithm {
get { return "http://www.w3.org/2000/09/xmldsig#dsa-sha1"; }
}
public static bool UseMachineKeyStore {
get { return (s_UseMachineKeyStore == CspProviderFlags.UseMachineKeyStore); }
set { s_UseMachineKeyStore = (value ? CspProviderFlags.UseMachineKeyStore : 0); }
}
public bool PersistKeyInCsp {
get {
if (_safeProvHandle == null) {
lock (this) {
if (_safeProvHandle == null)
_safeProvHandle = Utils.CreateProvHandle(_parameters, _randomKeyContainer);
}
}
return Utils._GetPersistKeyInCsp(_safeProvHandle);
}
set {
bool oldPersistKeyInCsp = this.PersistKeyInCsp;
if (value == oldPersistKeyInCsp)
return;
KeyContainerPermission kp = new KeyContainerPermission(KeyContainerPermissionFlags.NoFlags);
if (!value) {
KeyContainerPermissionAccessEntry entry = new KeyContainerPermissionAccessEntry(_parameters, KeyContainerPermissionFlags.Delete);
kp.AccessEntries.Add(entry);
} else {
KeyContainerPermissionAccessEntry entry = new KeyContainerPermissionAccessEntry(_parameters, KeyContainerPermissionFlags.Create);
kp.AccessEntries.Add(entry);
}
kp.Demand();
Utils._SetPersistKeyInCsp(_safeProvHandle, value);
}
}
//
// public methods
//
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);
}
[System.Runtime.InteropServices.ComVisible(false)]
public byte[] ExportCspBlob (bool includePrivateParameters) {
GetKeyPair();
return Utils.ExportCspBlobHelper(includePrivateParameters, _parameters, _safeKeyHandle);
}
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);
}
}
[System.Runtime.InteropServices.ComVisible(false)]
public void ImportCspBlob (byte[] keyBlob) {
Utils.ImportCspBlobHelper(CspAlgorithmType.Dss, keyBlob, IsPublic(keyBlob), ref _parameters, _randomKeyContainer, ref _safeProvHandle, ref _safeKeyHandle);
}
public byte[] SignData(Stream inputStream) {
byte[] hashVal = _sha1.ComputeHash(inputStream);
return SignHash(hashVal, null);
}
public byte[] SignData(byte[] buffer) {
byte[] hashVal = _sha1.ComputeHash(buffer);
return SignHash(hashVal, null);
}
public byte[] SignData(byte[] buffer, int offset, int count) {
byte[] hashVal = _sha1.ComputeHash(buffer, offset, count);
return SignHash(hashVal, null);
}
public bool VerifyData(byte[] rgbData, byte[] rgbSignature) {
byte[] hashVal = _sha1.ComputeHash(rgbData);
return VerifyHash(hashVal, null, rgbSignature);
}
override public byte[] CreateSignature(byte[] rgbHash) {
return SignHash(rgbHash, null);
}
override public bool VerifySignature(byte[] rgbHash, byte[] rgbSignature) {
return VerifyHash(rgbHash, null, rgbSignature);
}
public byte[] SignHash(byte[] rgbHash, string str) {
if (rgbHash == null)
throw new ArgumentNullException("rgbHash");
if (PublicOnly)
throw new CryptographicException(Environment.GetResourceString("Cryptography_CSP_NoPrivateKey"));
int calgHash = X509Utils.OidToAlgId(str);
if (rgbHash.Length != _sha1.HashSize / 8)
throw new CryptographicException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Cryptography_InvalidHashSize"), "SHA1", _sha1.HashSize / 8));
GetKeyPair();
if (!CspKeyContainerInfo.RandomlyGenerated) {
KeyContainerPermission kp = new KeyContainerPermission(KeyContainerPermissionFlags.NoFlags);
KeyContainerPermissionAccessEntry entry = new KeyContainerPermissionAccessEntry(_parameters, KeyContainerPermissionFlags.Sign);
kp.AccessEntries.Add(entry);
kp.Demand();
}
return Utils._SignValue(_safeKeyHandle, _parameters.KeyNumber, Constants.CALG_DSS_SIGN, calgHash, rgbHash, 0);
}
public bool VerifyHash(byte[] rgbHash, string str, byte[] rgbSignature) {
if (rgbHash == null)
throw new ArgumentNullException("rgbHash");
if (rgbSignature == null)
throw new ArgumentNullException("rgbSignature");
int calgHash = X509Utils.OidToAlgId(str);
if (rgbHash.Length != _sha1.HashSize / 8)
throw new CryptographicException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Cryptography_InvalidHashSize"), "SHA1", _sha1.HashSize / 8));
GetKeyPair();
return Utils._VerifySign(_safeKeyHandle, Constants.CALG_DSS_SIGN, calgHash, rgbHash, rgbSignature, 0);
}
//
// private static methods
//
private static DSAParameters DSAObjectToStruct (DSACspObject dsaCspObject) {
DSAParameters dsaParams = new DSAParameters();
dsaParams.P = dsaCspObject.P;
dsaParams.Q = dsaCspObject.Q;
dsaParams.G = dsaCspObject.G;
dsaParams.Y = dsaCspObject.Y;
dsaParams.J = dsaCspObject.J;
dsaParams.X = dsaCspObject.X;
dsaParams.Seed = dsaCspObject.Seed;
dsaParams.Counter = dsaCspObject.Counter;
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;
}
private static bool IsPublic (DSAParameters dsaParams) {
return (dsaParams.X == null);
}
// find whether a DSS key blob is public.
private static bool IsPublic (byte[] keyBlob) {
if (keyBlob == null)
throw new ArgumentNullException("keyBlob");
// The CAPI DSS public key representation consists of the following sequence:
// - BLOBHEADER
// - DSSPUBKEY
// - rgbP[cbKey]
// - rgbQ[20]
// - rgbG[cbKey]
// - rgbY[cbKey]
// - DSSSEED
// The first should be PUBLICKEYBLOB and magic should be DSS_MAGIC "DSS1" or DSS_PUB_MAGIC_VER3 "DSS3"
if (keyBlob[0] != Constants.PUBLICKEYBLOB)
return false;
if ((keyBlob[11] != 0x31 && keyBlob[11] != 0x33) || keyBlob[10] != 0x53 || keyBlob[9] != 0x53 || keyBlob[8] != 0x44)
return false;
return true;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- AutomationProperties.cs
- TextOutput.cs
- DocComment.cs
- ALinqExpressionVisitor.cs
- RegexCaptureCollection.cs
- CodeArrayCreateExpression.cs
- ModelUIElement3D.cs
- XmlException.cs
- Compilation.cs
- TextTreeObjectNode.cs
- LayoutInformation.cs
- HwndStylusInputProvider.cs
- EntityParameter.cs
- BaseTemplateCodeDomTreeGenerator.cs
- ComplexType.cs
- ConfigurationValidatorAttribute.cs
- PlanCompiler.cs
- Base64Stream.cs
- PointConverter.cs
- UrlAuthFailedErrorFormatter.cs
- DocumentCollection.cs
- ResumeStoryboard.cs
- ThicknessKeyFrameCollection.cs
- SubstitutionList.cs
- MaskInputRejectedEventArgs.cs
- TrueReadOnlyCollection.cs
- DependencyObjectPropertyDescriptor.cs
- WhileDesigner.xaml.cs
- XPathDocumentBuilder.cs
- WebPartAddingEventArgs.cs
- ProgressChangedEventArgs.cs
- IPAddress.cs
- FixedPageAutomationPeer.cs
- TemplateInstanceAttribute.cs
- StatusCommandUI.cs
- PrintPageEvent.cs
- GridEntryCollection.cs
- ShaderEffect.cs
- FormCollection.cs
- PersistenceContextEnlistment.cs
- WebPartCloseVerb.cs
- ToolStripItemCollection.cs
- TextDocumentView.cs
- XmlSchemaValidationException.cs
- XamlGridLengthSerializer.cs
- RepeaterItemCollection.cs
- SortExpressionBuilder.cs
- XmlSchemaAny.cs
- SqlProfileProvider.cs
- BooleanStorage.cs
- PathGeometry.cs
- DocobjHost.cs
- EntityDataSourceWrapperCollection.cs
- ContextMenu.cs
- XmlCompatibilityReader.cs
- CellParaClient.cs
- XmlBindingWorker.cs
- RouteValueExpressionBuilder.cs
- MultiSelectRootGridEntry.cs
- EllipseGeometry.cs
- ObfuscateAssemblyAttribute.cs
- Thread.cs
- Transform.cs
- ToolStripItemCollection.cs
- designeractionbehavior.cs
- DataGridViewRowHeightInfoNeededEventArgs.cs
- EntityDataSourceUtil.cs
- SafeCryptContextHandle.cs
- OutOfMemoryException.cs
- ConfigurationValue.cs
- ByteConverter.cs
- LogRestartAreaEnumerator.cs
- XmlnsDefinitionAttribute.cs
- ModelVisual3D.cs
- DeviceFiltersSection.cs
- sqlmetadatafactory.cs
- metrodevice.cs
- CompilerParameters.cs
- XmlValueConverter.cs
- XmlTextAttribute.cs
- TreeNodeBinding.cs
- DataGridViewRowContextMenuStripNeededEventArgs.cs
- SafeTimerHandle.cs
- PieceDirectory.cs
- ExitEventArgs.cs
- ValueUtilsSmi.cs
- InteropBitmapSource.cs
- LayoutTableCell.cs
- DocumentViewerAutomationPeer.cs
- FactoryGenerator.cs
- ColorMap.cs
- Freezable.cs
- MouseEventArgs.cs
- _FtpControlStream.cs
- KeyPressEvent.cs
- AppLevelCompilationSectionCache.cs
- DisplayInformation.cs
- FlowSwitch.cs
- KeyValuePair.cs
- AmbientValueAttribute.cs