Silverlight 5

WinRT

public abstract class Aes	public abstract class Aes
: SymmetricAlgorithm, IDisposable	: SymmetricAlgorithm, IDisposable
	static public Aes Create();

	public sealed class AesCryptoServiceProvider
	: Aes, IDisposable
	public virtual Byte Key { get; set; }
	public virtual Int32 KeySize { get; set; }
	public virtual ICryptoTransform CreateDecryptor();
	public virtual ICryptoTransform CreateDecryptor(Byte key, Byte[] iv);
	public virtual ICryptoTransform CreateEncryptor();
	public virtual ICryptoTransform CreateEncryptor(Byte key, Byte[] iv);
	protected virtual void Dispose(Boolean disposing);
	public virtual void GenerateIV();
	public virtual void GenerateKey();

public sealed class AesManaged	public sealed class AesManaged
: Aes, IDisposable	: Aes, IDisposable
	public virtual Int32 FeedbackSize { get; set; }
public virtual Byte IV { get; set; }	public virtual Byte IV { get; set; }
public virtual Byte Key { get; set; }	public virtual Byte Key { get; set; }
public virtual Int32 KeySize { get; set; }	public virtual Int32 KeySize { get; set; }
	public virtual CipherMode Mode { get; set; }
	public virtual PaddingMode Padding { get; set; }
public virtual ICryptoTransform CreateDecryptor();	public virtual ICryptoTransform CreateDecryptor();
public virtual ICryptoTransform CreateDecryptor(Byte key, Byte[] iv);	public virtual ICryptoTransform CreateDecryptor(Byte key, Byte[] iv);
public virtual ICryptoTransform CreateEncryptor();	public virtual ICryptoTransform CreateEncryptor();
public virtual ICryptoTransform CreateEncryptor(Byte key, Byte[] iv);	public virtual ICryptoTransform CreateEncryptor(Byte key, Byte[] iv);
	protected virtual void Dispose(Boolean disposing);
public virtual void GenerateIV();	public virtual void GenerateIV();
public virtual void GenerateKey();	public virtual void GenerateKey();

	public class AsnEncodedData
	public Oid Oid { get; set; }
	public Byte RawData { get; set; }
	public virtual void CopyFrom(AsnEncodedData asnEncodedData);
	public virtual String Format(Boolean multiLine);

	public sealed class AsnEncodedDataCollection
	: ICollection, IEnumerable
	public virtual Int32 Count { get; }
	public virtual Boolean IsSynchronized { get; }
	public AsnEncodedData Item { get; }
	public virtual Object SyncRoot { get; }
	public Int32 Add(AsnEncodedData asnEncodedData);
	public void CopyTo(AsnEncodedData array, Int32 index);
	public AsnEncodedDataEnumerator GetEnumerator();
	public void Remove(AsnEncodedData asnEncodedData);

	public sealed class AsnEncodedDataEnumerator
	: IEnumerator
	public AsnEncodedData Current { get; }
	public virtual Boolean MoveNext();
	public virtual void Reset();

	public abstract class AsymmetricAlgorithm
	: IDisposable
	public abstract virtual String KeyExchangeAlgorithm { get; }
	public virtual Int32 KeySize { get; set; }
	public virtual KeySizes LegalKeySizes { get; }
	public abstract virtual String SignatureAlgorithm { get; }
	public void Clear();
	static public AsymmetricAlgorithm Create();
	static public AsymmetricAlgorithm Create(String algName);
	public virtual void Dispose();
	protected virtual void Dispose(Boolean disposing);
	public abstract virtual void FromXmlString(String xmlString);
	public abstract virtual String ToXmlString(Boolean includePrivateParameters);

	public abstract class AsymmetricKeyExchangeDeformatter
	public abstract virtual String Parameters { get; set; }
	public abstract virtual Byte DecryptKeyExchange(Byte[] rgb);
	public abstract virtual void SetKey(AsymmetricAlgorithm key);

	public abstract class AsymmetricKeyExchangeFormatter
	public abstract virtual String Parameters { get; }
	public abstract virtual Byte CreateKeyExchange(Byte[] data);
	public abstract virtual Byte CreateKeyExchange(Byte[] data, Type symAlgType);
	public abstract virtual void SetKey(AsymmetricAlgorithm key);

	public abstract class AsymmetricSignatureDeformatter
	public abstract virtual void SetHashAlgorithm(String strName);
	public abstract virtual void SetKey(AsymmetricAlgorithm key);
	public virtual Boolean VerifySignature(HashAlgorithm hash, Byte rgbSignature);
	public abstract virtual Boolean VerifySignature(Byte rgbHash, Byte[] rgbSignature);

	public abstract class AsymmetricSignatureFormatter
	public virtual Byte CreateSignature(HashAlgorithm hash);
	public abstract virtual Byte CreateSignature(Byte[] rgbHash);
	public abstract virtual void SetHashAlgorithm(String strName);
	public abstract virtual void SetKey(AsymmetricAlgorithm key);

	public sealed enum CipherMode
	: IComparable, IFormattable, IConvertible
	{ CBC, ECB, OFB, CFB, CTS }

	public sealed class CngAlgorithm
	: IEquatable`1<CngAlgorithm>
	public String Algorithm { get; }
	static public CngAlgorithm ECDiffieHellmanP256 { get; }
	static public CngAlgorithm ECDiffieHellmanP384 { get; }
	static public CngAlgorithm ECDiffieHellmanP521 { get; }
	static public CngAlgorithm ECDsaP256 { get; }
	static public CngAlgorithm ECDsaP384 { get; }
	static public CngAlgorithm ECDsaP521 { get; }
	static public CngAlgorithm MD5 { get; }
	static public CngAlgorithm Sha1 { get; }
	static public CngAlgorithm Sha256 { get; }
	static public CngAlgorithm Sha384 { get; }
	static public CngAlgorithm Sha512 { get; }
	public virtual Boolean Equals(Object obj);
	public virtual Boolean Equals(CngAlgorithm other);
	public virtual Int32 GetHashCode();
	static public Boolean op_Equality(CngAlgorithm left, CngAlgorithm right);
	static public Boolean op_Inequality(CngAlgorithm left, CngAlgorithm right);
	public virtual String ToString();

	public sealed class CngAlgorithmGroup
	: IEquatable`1<CngAlgorithmGroup>
	public String AlgorithmGroup { get; }
	static public CngAlgorithmGroup DiffieHellman { get; }
	static public CngAlgorithmGroup Dsa { get; }
	static public CngAlgorithmGroup ECDiffieHellman { get; }
	static public CngAlgorithmGroup ECDsa { get; }
	static public CngAlgorithmGroup Rsa { get; }
	public virtual Boolean Equals(Object obj);
	public virtual Boolean Equals(CngAlgorithmGroup other);
	public virtual Int32 GetHashCode();
	static public Boolean op_Equality(CngAlgorithmGroup left, CngAlgorithmGroup right);
	static public Boolean op_Inequality(CngAlgorithmGroup left, CngAlgorithmGroup right);
	public virtual String ToString();

	public sealed enum CngExportPolicies
	: IComparable, IFormattable, IConvertible
	{ None, AllowExport, AllowPlaintextExport, AllowArchiving, AllowPlaintextArchiving }

	public sealed class CngKey
	: IDisposable
	public CngAlgorithm Algorithm { get; }
	public CngAlgorithmGroup AlgorithmGroup { get; }
	public CngExportPolicies ExportPolicy { get; }
	public SafeNCryptKeyHandle Handle { get; }
	public Boolean IsEphemeral { get; set; }
	public Boolean IsMachineKey { get; }
	public String KeyName { get; }
	public Int32 KeySize { get; }
	public CngKeyUsages KeyUsage { get; }
	public IntPtr ParentWindowHandle { get; set; }
	public CngProvider Provider { get; }
	public SafeNCryptProviderHandle ProviderHandle { get; }
	public CngUIPolicy UIPolicy { get; }
	public String UniqueName { get; }
	static public CngKey Create(CngAlgorithm algorithm);
	static public CngKey Create(CngAlgorithm algorithm, String keyName);
	static public CngKey Create(CngAlgorithm algorithm, String keyName, CngKeyCreationParameters creationParameters);
	public void Delete();
	public virtual void Dispose();
	static public Boolean Exists(String keyName);
	static public Boolean Exists(String keyName, CngProvider provider);
	static public Boolean Exists(String keyName, CngProvider provider, CngKeyOpenOptions options);
	public Byte Export(CngKeyBlobFormat format);
	public CngProperty GetProperty(String name, CngPropertyOptions options);
	public Boolean HasProperty(String name, CngPropertyOptions options);
	static public CngKey Import(Byte keyBlob, CngKeyBlobFormat format);
	static public CngKey Import(Byte keyBlob, CngKeyBlobFormat format, CngProvider provider);
	static public CngKey Open(String keyName);
	static public CngKey Open(String keyName, CngProvider provider);
	static public CngKey Open(String keyName, CngProvider provider, CngKeyOpenOptions openOptions);
	static public CngKey Open(SafeNCryptKeyHandle keyHandle, CngKeyHandleOpenOptions keyHandleOpenOptions);
	public void SetProperty(CngProperty property);

	public sealed class CngKeyBlobFormat
	: IEquatable`1<CngKeyBlobFormat>
	static public CngKeyBlobFormat EccPrivateBlob { get; }
	static public CngKeyBlobFormat EccPublicBlob { get; }
	public String Format { get; }
	static public CngKeyBlobFormat GenericPrivateBlob { get; }
	static public CngKeyBlobFormat GenericPublicBlob { get; }
	static public CngKeyBlobFormat OpaqueTransportBlob { get; }
	static public CngKeyBlobFormat Pkcs8PrivateBlob { get; }
	public virtual Boolean Equals(Object obj);
	public virtual Boolean Equals(CngKeyBlobFormat other);
	public virtual Int32 GetHashCode();
	static public Boolean op_Equality(CngKeyBlobFormat left, CngKeyBlobFormat right);
	static public Boolean op_Inequality(CngKeyBlobFormat left, CngKeyBlobFormat right);
	public virtual String ToString();

	public sealed enum CngKeyCreationOptions
	: IComparable, IFormattable, IConvertible
	{ None, MachineKey, OverwriteExistingKey }

	public sealed class CngKeyCreationParameters
	public Nullable`1<CngExportPolicies> ExportPolicy { get; set; }
	public CngKeyCreationOptions KeyCreationOptions { get; set; }
	public Nullable`1<CngKeyUsages> KeyUsage { get; set; }
	public CngPropertyCollection Parameters { get; }
	public IntPtr ParentWindowHandle { get; set; }
	public CngProvider Provider { get; set; }
	public CngUIPolicy UIPolicy { get; set; }

	public sealed enum CngKeyHandleOpenOptions
	: IComparable, IFormattable, IConvertible
	{ None, EphemeralKey }

	public sealed enum CngKeyOpenOptions
	: IComparable, IFormattable, IConvertible
	{ None, UserKey, MachineKey, Silent }

	public sealed enum CngKeyUsages
	: IComparable, IFormattable, IConvertible
	{ None, Decryption, Signing, KeyAgreement, AllUsages }

	public sealed struct CngProperty
	: ValueType, IEquatable`1<CngProperty>
	public String Name { get; }
	public CngPropertyOptions Options { get; }
	public virtual Boolean Equals(Object obj);
	public virtual Boolean Equals(CngProperty other);
	public virtual Int32 GetHashCode();
	public Byte GetValue();
	static public Boolean op_Equality(CngProperty left, CngProperty right);
	static public Boolean op_Inequality(CngProperty left, CngProperty right);

	public sealed class CngPropertyCollection
	: Collection`1<CngProperty>, IList`1<CngProperty>, ICollection`1<CngProperty>, IEnumerable`1<CngProperty>, IEnumerable, IList, ICollection, IReadOnlyList`1<CngProperty>

	public sealed enum CngPropertyOptions
	: IComparable, IFormattable, IConvertible
	{ None, CustomProperty, Persist }

	public sealed class CngProvider
	: IEquatable`1<CngProvider>
	static public CngProvider MicrosoftSmartCardKeyStorageProvider { get; }
	static public CngProvider MicrosoftSoftwareKeyStorageProvider { get; }
	public String Provider { get; }
	public virtual Boolean Equals(Object obj);
	public virtual Boolean Equals(CngProvider other);
	public virtual Int32 GetHashCode();
	static public Boolean op_Equality(CngProvider left, CngProvider right);
	static public Boolean op_Inequality(CngProvider left, CngProvider right);
	public virtual String ToString();

	public sealed class CngUIPolicy
	public String CreationTitle { get; }
	public String Description { get; }
	public String FriendlyName { get; }
	public CngUIProtectionLevels ProtectionLevel { get; }
	public String UseContext { get; }

	public sealed enum CngUIProtectionLevels
	: IComparable, IFormattable, IConvertible
	{ None, ProtectKey, ForceHighProtection }

	public sealed class CryptoAPITransform
	: ICryptoTransform, IDisposable
	public virtual Boolean CanReuseTransform { get; }
	public virtual Boolean CanTransformMultipleBlocks { get; }
	public virtual Int32 InputBlockSize { get; }
	public IntPtr KeyHandle { get; }
	public virtual Int32 OutputBlockSize { get; }
	public void Clear();
	public virtual void Dispose();
	public void Reset();
	public virtual Int32 TransformBlock(Byte inputBuffer, Int32 inputOffset, Int32 inputCount, Byte[] outputBuffer, Int32 outputOffset);
	public virtual Byte TransformFinalBlock(Byte[] inputBuffer, Int32 inputOffset, Int32 inputCount);

	public class CryptoConfig
	static public Boolean AllowOnlyFipsAlgorithms { get; }
	static public void AddAlgorithm(Type algorithm, String names);
	static public void AddOID(String oid, String names);
	static public Object CreateFromName(String name, Object args);
	static public Object CreateFromName(String name);
	static public Byte EncodeOID(String str);
	static public String MapNameToOID(String name);

public class CryptographicException	public class CryptographicException
: SystemException, _Exception	: SystemException, ISerializable, _Exception

public class CryptographicUnexpectedOperationException	public class CryptographicUnexpectedOperationException
: CryptographicException, _Exception	: CryptographicException, ISerializable, _Exception

public class CryptoStream	public class CryptoStream
: Stream, IDisposable	: Stream, IDisposable
public virtual Boolean CanRead { get; }	public virtual Boolean CanRead { get; }
public virtual Boolean CanSeek { get; }	public virtual Boolean CanSeek { get; }
public virtual Boolean CanWrite { get; }	public virtual Boolean CanWrite { get; }
	public Boolean HasFlushedFinalBlock { get; }
public virtual Int64 Length { get; }	public virtual Int64 Length { get; }
public virtual Int64 Position { get; set; }	public virtual Int64 Position { get; set; }
public void Clear();	public void Clear();
	protected virtual void Dispose(Boolean disposing);
public virtual void Flush();	public virtual void Flush();
public void FlushFinalBlock();	public void FlushFinalBlock();
public virtual Int32 Read(out Byte buffer, Int32 offset, Int32 count);	public virtual Int32 Read(out Byte buffer, Int32 offset, Int32 count);
public virtual Int64 Seek(Int64 offset, SeekOrigin origin);	public virtual Int64 Seek(Int64 offset, SeekOrigin origin);
public virtual void SetLength(Int64 value);	public virtual void SetLength(Int64 value);
public virtual void Write(Byte buffer, Int32 offset, Int32 count);	public virtual void Write(Byte buffer, Int32 offset, Int32 count);

public sealed enum CryptoStreamMode	public sealed enum CryptoStreamMode
: IComparable, IFormattable, IConvertible	: IComparable, IFormattable, IConvertible
{ Read, Write }	{ Read, Write }

	public sealed class CspKeyContainerInfo
	public Boolean Accessible { get; }
	public CryptoKeySecurity CryptoKeySecurity { get; }
	public Boolean Exportable { get; }
	public Boolean HardwareDevice { get; }
	public String KeyContainerName { get; }
	public KeyNumber KeyNumber { get; }
	public Boolean MachineKeyStore { get; }
	public Boolean Protected { get; }
	public String ProviderName { get; }
	public Int32 ProviderType { get; }
	public Boolean RandomlyGenerated { get; }
	public Boolean Removable { get; }
	public String UniqueKeyContainerName { get; }

	public sealed class CspParameters
	public CryptoKeySecurity CryptoKeySecurity { get; set; }
	public CspProviderFlags Flags { get; set; }
	public SecureString KeyPassword { get; set; }
	public IntPtr ParentWindowHandle { get; set; }

	public sealed enum CspProviderFlags
	: IComparable, IFormattable, IConvertible
	{ NoFlags, UseMachineKeyStore, UseDefaultKeyContainer, UseNonExportableKey, UseExistingKey, UseArchivableKey, UseUserProtectedKey, NoPrompt, CreateEphemeralKey }

public abstract class DeriveBytes	public abstract class DeriveBytes
	: IDisposable
	public virtual void Dispose();
	protected virtual void Dispose(Boolean disposing);
public abstract virtual Byte GetBytes(Int32 cb);	public abstract virtual Byte GetBytes(Int32 cb);
public abstract virtual void Reset();	public abstract virtual void Reset();

	public abstract class DES
	: SymmetricAlgorithm, IDisposable
	public virtual Byte Key { get; set; }
	static public DES Create();
	static public DES Create(String algName);
	static public Boolean IsSemiWeakKey(Byte rgbKey);
	static public Boolean IsWeakKey(Byte rgbKey);

	public sealed class DESCryptoServiceProvider
	: DES, IDisposable
	public virtual ICryptoTransform CreateDecryptor(Byte rgbKey, Byte[] rgbIV);
	public virtual ICryptoTransform CreateEncryptor(Byte rgbKey, Byte[] rgbIV);
	public virtual void GenerateIV();
	public virtual void GenerateKey();

	public abstract class DSA
	: AsymmetricAlgorithm, IDisposable
	static public DSA Create();
	static public DSA Create(String algName);
	public abstract virtual Byte CreateSignature(Byte[] rgbHash);
	public abstract virtual DSAParameters ExportParameters(Boolean includePrivateParameters);
	public virtual void FromXmlString(String xmlString);
	public abstract virtual void ImportParameters(DSAParameters parameters);
	public virtual String ToXmlString(Boolean includePrivateParameters);
	public abstract virtual Boolean VerifySignature(Byte rgbHash, Byte[] rgbSignature);

	public sealed class DSACryptoServiceProvider
	: DSA, IDisposable, ICspAsymmetricAlgorithm
	public virtual CspKeyContainerInfo CspKeyContainerInfo { get; }
	public virtual String KeyExchangeAlgorithm { get; }
	public virtual Int32 KeySize { get; }
	public Boolean PersistKeyInCsp { get; set; }
	public Boolean PublicOnly { get; }
	public virtual String SignatureAlgorithm { get; }
	static public Boolean UseMachineKeyStore { get; set; }
	public virtual Byte CreateSignature(Byte[] rgbHash);
	protected virtual void Dispose(Boolean disposing);
	public virtual Byte ExportCspBlob(Boolean includePrivateParameters);
	public virtual DSAParameters ExportParameters(Boolean includePrivateParameters);
	public virtual void ImportCspBlob(Byte keyBlob);
	public virtual void ImportParameters(DSAParameters parameters);
	public Byte SignData(Stream inputStream);
	public Byte SignData(Byte[] buffer);
	public Byte SignData(Byte[] buffer, Int32 offset, Int32 count);
	public Byte SignHash(Byte[] rgbHash, String str);
	public Boolean VerifyData(Byte rgbData, Byte[] rgbSignature);
	public Boolean VerifyHash(Byte rgbHash, String str, Byte[] rgbSignature);
	public virtual Boolean VerifySignature(Byte rgbHash, Byte[] rgbSignature);

	public sealed struct DSAParameters
	: ValueType

	public class DSASignatureDeformatter
	: AsymmetricSignatureDeformatter
	public virtual void SetHashAlgorithm(String strName);
	public virtual void SetKey(AsymmetricAlgorithm key);
	public virtual Boolean VerifySignature(Byte rgbHash, Byte[] rgbSignature);

	public class DSASignatureFormatter
	: AsymmetricSignatureFormatter
	public virtual Byte CreateSignature(Byte[] rgbHash);
	public virtual void SetHashAlgorithm(String strName);
	public virtual void SetKey(AsymmetricAlgorithm key);

	public abstract class ECDiffieHellman
	: AsymmetricAlgorithm, IDisposable
	public virtual String KeyExchangeAlgorithm { get; }
	public abstract virtual ECDiffieHellmanPublicKey PublicKey { get; }
	public virtual String SignatureAlgorithm { get; }
	static public ECDiffieHellman Create();
	static public ECDiffieHellman Create(String algorithm);
	public abstract virtual Byte DeriveKeyMaterial(ECDiffieHellmanPublicKey otherPartyPublicKey);

	public sealed class ECDiffieHellmanCng
	: ECDiffieHellman, IDisposable
	public CngAlgorithm HashAlgorithm { get; set; }
	public Byte HmacKey { get; set; }
	public CngKey Key { get; set; }
	public ECDiffieHellmanKeyDerivationFunction KeyDerivationFunction { get; set; }
	public Byte Label { get; set; }
	public virtual ECDiffieHellmanPublicKey PublicKey { get; }
	public Byte SecretAppend { get; set; }
	public Byte SecretPrepend { get; set; }
	public Byte Seed { get; set; }
	public Boolean UseSecretAgreementAsHmacKey { get; }
	public virtual Byte DeriveKeyMaterial(ECDiffieHellmanPublicKey otherPartyPublicKey);
	public Byte DeriveKeyMaterial(CngKey otherPartyPublicKey);
	public SafeNCryptSecretHandle DeriveSecretAgreementHandle(ECDiffieHellmanPublicKey otherPartyPublicKey);
	public SafeNCryptSecretHandle DeriveSecretAgreementHandle(CngKey otherPartyPublicKey);
	protected virtual void Dispose(Boolean disposing);
	public virtual void FromXmlString(String xmlString);
	public void FromXmlString(String xml, ECKeyXmlFormat format);
	public virtual String ToXmlString(Boolean includePrivateParameters);
	public String ToXmlString(ECKeyXmlFormat format);

	public sealed class ECDiffieHellmanCngPublicKey
	: ECDiffieHellmanPublicKey, IDisposable
	public CngKeyBlobFormat BlobFormat { get; }
	protected virtual void Dispose(Boolean disposing);
	static public ECDiffieHellmanPublicKey FromByteArray(Byte publicKeyBlob, CngKeyBlobFormat format);
	static public ECDiffieHellmanCngPublicKey FromXmlString(String xml);
	public CngKey Import();
	public virtual String ToXmlString();

	public sealed enum ECDiffieHellmanKeyDerivationFunction
	: IComparable, IFormattable, IConvertible
	{ Hash, Hmac, Tls }

	public abstract class ECDiffieHellmanPublicKey
	: IDisposable
	public virtual void Dispose();
	protected virtual void Dispose(Boolean disposing);
	public virtual Byte ToByteArray();
	public abstract virtual String ToXmlString();

	public abstract class ECDsa
	: AsymmetricAlgorithm, IDisposable
	public virtual String KeyExchangeAlgorithm { get; }
	public virtual String SignatureAlgorithm { get; }
	static public ECDsa Create();
	static public ECDsa Create(String algorithm);
	public abstract virtual Byte SignHash(Byte[] hash);
	public abstract virtual Boolean VerifyHash(Byte hash, Byte[] signature);

	public sealed class ECDsaCng
	: ECDsa, IDisposable
	public CngAlgorithm HashAlgorithm { get; set; }
	public CngKey Key { get; set; }
	protected virtual void Dispose(Boolean disposing);
	public virtual void FromXmlString(String xmlString);
	public void FromXmlString(String xml, ECKeyXmlFormat format);
	public Byte SignData(Byte[] data);
	public Byte SignData(Byte[] data, Int32 offset, Int32 count);
	public Byte SignData(Stream data);
	public virtual Byte SignHash(Byte[] hash);
	public virtual String ToXmlString(Boolean includePrivateParameters);
	public String ToXmlString(ECKeyXmlFormat format);
	public Boolean VerifyData(Byte data, Byte[] signature);
	public Boolean VerifyData(Byte data, Int32 offset, Int32 count, Byte[] signature);
	public Boolean VerifyData(Stream data, Byte signature);
	public virtual Boolean VerifyHash(Byte hash, Byte[] signature);

	public sealed enum ECKeyXmlFormat
	: IComparable, IFormattable, IConvertible
	{ Rfc4050 }

	public class FromBase64Transform
	: ICryptoTransform, IDisposable
	public virtual Boolean CanReuseTransform { get; }
	public virtual Boolean CanTransformMultipleBlocks { get; }
	public virtual Int32 InputBlockSize { get; }
	public virtual Int32 OutputBlockSize { get; }
	public void Clear();
	public virtual void Dispose();
	protected virtual void Dispose(Boolean disposing);
	protected virtual void Finalize();
	public virtual Int32 TransformBlock(Byte inputBuffer, Int32 inputOffset, Int32 inputCount, Byte[] outputBuffer, Int32 outputOffset);
	public virtual Byte TransformFinalBlock(Byte[] inputBuffer, Int32 inputOffset, Int32 inputCount);

	public sealed enum FromBase64TransformMode
	: IComparable, IFormattable, IConvertible
	{ IgnoreWhiteSpaces, DoNotIgnoreWhiteSpaces }

public abstract class HashAlgorithm	public abstract class HashAlgorithm
: ICryptoTransform, IDisposable	: ICryptoTransform, IDisposable
public virtual Boolean CanReuseTransform { get; }	public virtual Boolean CanReuseTransform { get; }
public virtual Boolean CanTransformMultipleBlocks { get; }	public virtual Boolean CanTransformMultipleBlocks { get; }
public virtual Byte Hash { get; }	public virtual Byte Hash { get; }
public virtual Int32 HashSize { get; }	public virtual Int32 HashSize { get; }
public virtual Int32 InputBlockSize { get; }	public virtual Int32 InputBlockSize { get; }
public virtual Int32 OutputBlockSize { get; }	public virtual Int32 OutputBlockSize { get; }
public void Clear();	public void Clear();
public Byte ComputeHash(Stream inputStream);	public Byte ComputeHash(Stream inputStream);
public Byte ComputeHash(Byte[] buffer);	public Byte ComputeHash(Byte[] buffer);
public Byte ComputeHash(Byte[] buffer, Int32 offset, Int32 count);	public Byte ComputeHash(Byte[] buffer, Int32 offset, Int32 count);
	static public HashAlgorithm Create();
	static public HashAlgorithm Create(String hashName);
	public virtual void Dispose();
	protected virtual void Dispose(Boolean disposing);
	protected abstract virtual void HashCore(Byte array, Int32 ibStart, Int32 cbSize);
	protected abstract virtual Byte HashFinal();
public abstract virtual void Initialize();	public abstract virtual void Initialize();
public virtual Int32 TransformBlock(Byte inputBuffer, Int32 inputOffset, Int32 inputCount, Byte[] outputBuffer, Int32 outputOffset);	public virtual Int32 TransformBlock(Byte inputBuffer, Int32 inputOffset, Int32 inputCount, Byte[] outputBuffer, Int32 outputOffset);
public virtual Byte TransformFinalBlock(Byte[] inputBuffer, Int32 inputOffset, Int32 inputCount);	public virtual Byte TransformFinalBlock(Byte[] inputBuffer, Int32 inputOffset, Int32 inputCount);

public abstract class HMAC	public abstract class HMAC
: KeyedHashAlgorithm, ICryptoTransform, IDisposable	: KeyedHashAlgorithm, ICryptoTransform, IDisposable
	protected Int32 BlockSizeValue { get; set; }
public String HashName { get; }	public String HashName { get; set; }
public virtual Byte Key { get; set; }	public virtual Byte Key { get; set; }
	static public HMAC Create();
	static public HMAC Create(String algorithmName);
	protected virtual void Dispose(Boolean disposing);
	protected virtual void HashCore(Byte rgb, Int32 ib, Int32 cb);
	protected virtual Byte HashFinal();
public virtual void Initialize();	public virtual void Initialize();

	public class HMACMD5
	: HMAC, ICryptoTransform, IDisposable

	public class HMACRIPEMD160
	: HMAC, ICryptoTransform, IDisposable

public class HMACSHA1	public class HMACSHA1
: HMAC, ICryptoTransform, IDisposable	: HMAC, ICryptoTransform, IDisposable

public class HMACSHA256	public class HMACSHA256
: HMAC, ICryptoTransform, IDisposable	: HMAC, ICryptoTransform, IDisposable

	public class HMACSHA384
	: HMAC, ICryptoTransform, IDisposable
	public Boolean ProduceLegacyHmacValues { get; set; }

	public class HMACSHA512
	: HMAC, ICryptoTransform, IDisposable
	public Boolean ProduceLegacyHmacValues { get; set; }

public abstract interface ICryptoTransform	public abstract interface ICryptoTransform
: IDisposable	: IDisposable
public abstract virtual Boolean CanReuseTransform { get; }	public abstract virtual Boolean CanReuseTransform { get; }
public abstract virtual Boolean CanTransformMultipleBlocks { get; }	public abstract virtual Boolean CanTransformMultipleBlocks { get; }
public abstract virtual Int32 InputBlockSize { get; }	public abstract virtual Int32 InputBlockSize { get; }
public abstract virtual Int32 OutputBlockSize { get; }	public abstract virtual Int32 OutputBlockSize { get; }
public abstract virtual Int32 TransformBlock(Byte inputBuffer, Int32 inputOffset, Int32 inputCount, Byte[] outputBuffer, Int32 outputOffset);	public abstract virtual Int32 TransformBlock(Byte inputBuffer, Int32 inputOffset, Int32 inputCount, Byte[] outputBuffer, Int32 outputOffset);
public abstract virtual Byte TransformFinalBlock(Byte[] inputBuffer, Int32 inputOffset, Int32 inputCount);	public abstract virtual Byte TransformFinalBlock(Byte[] inputBuffer, Int32 inputOffset, Int32 inputCount);

	public abstract interface ICspAsymmetricAlgorithm
	public abstract virtual CspKeyContainerInfo CspKeyContainerInfo { get; }
	public abstract virtual Byte ExportCspBlob(Boolean includePrivateParameters);
	public abstract virtual void ImportCspBlob(Byte rawData);

public abstract class KeyedHashAlgorithm	public abstract class KeyedHashAlgorithm
: HashAlgorithm, ICryptoTransform, IDisposable	: HashAlgorithm, ICryptoTransform, IDisposable
public virtual Byte Key { get; set; }	public virtual Byte Key { get; set; }
	static public KeyedHashAlgorithm Create();
	static public KeyedHashAlgorithm Create(String algName);

	public sealed enum KeyNumber
	: IComparable, IFormattable, IConvertible
	{ Exchange, Signature }

public sealed class KeySizes	public sealed class KeySizes
public Int32 MaxSize { get; }	public Int32 MaxSize { get; }
public Int32 MinSize { get; }	public Int32 MinSize { get; }
public Int32 SkipSize { get; }	public Int32 SkipSize { get; }

	public class MACTripleDES
	: KeyedHashAlgorithm, ICryptoTransform, IDisposable
	public PaddingMode Padding { get; set; }
	protected virtual void Dispose(Boolean disposing);
	protected virtual void HashCore(Byte rgbData, Int32 ibStart, Int32 cbSize);
	protected virtual Byte HashFinal();
	public virtual void Initialize();

	public sealed class ManifestSignatureInformation
	public AuthenticodeSignatureInformation AuthenticodeSignature { get; }
	public ManifestKinds Manifest { get; }
	public StrongNameSignatureInformation StrongNameSignature { get; }
	static public ManifestSignatureInformationCollection VerifySignature(ActivationContext application);
	static public ManifestSignatureInformationCollection VerifySignature(ActivationContext application, ManifestKinds manifests);
	static public ManifestSignatureInformationCollection VerifySignature(ActivationContext application, ManifestKinds manifests, X509RevocationFlag revocationFlag, X509RevocationMode revocationMode);

	public sealed class ManifestSignatureInformationCollection
	: ReadOnlyCollection`1<ManifestSignatureInformation>, IList`1<ManifestSignatureInformation>, ICollection`1<ManifestSignatureInformation>, IEnumerable`1<ManifestSignatureInformation>, IEnumerable, IList, ICollection, IReadOnlyList`1<ManifestSignatureInformation>

	public abstract class MaskGenerationMethod
	public abstract virtual Byte GenerateMask(Byte[] rgbSeed, Int32 cbReturn);

	public abstract class MD5
	: HashAlgorithm, ICryptoTransform, IDisposable
	static public MD5 Create();
	static public MD5 Create(String algName);

	public sealed class MD5Cng
	: MD5, ICryptoTransform, IDisposable
	protected virtual void Dispose(Boolean disposing);
	protected virtual void HashCore(Byte array, Int32 ibStart, Int32 cbSize);
	protected virtual Byte HashFinal();
	public virtual void Initialize();

	public sealed class MD5CryptoServiceProvider
	: MD5, ICryptoTransform, IDisposable
	protected virtual void Dispose(Boolean disposing);
	protected virtual void HashCore(Byte rgb, Int32 ibStart, Int32 cbSize);
	protected virtual Byte HashFinal();
	public virtual void Initialize();

	public sealed class Oid
	public String FriendlyName { get; set; }
	public String Value { get; set; }
	static public Oid FromFriendlyName(String friendlyName, OidGroup group);
	static public Oid FromOidValue(String oidValue, OidGroup group);

	public sealed class OidCollection
	: ICollection, IEnumerable
	public virtual Int32 Count { get; }
	public virtual Boolean IsSynchronized { get; }
	public Oid Item { get; }
	public Oid Item { get; }
	public virtual Object SyncRoot { get; }
	public Int32 Add(Oid oid);
	public void CopyTo(Oid array, Int32 index);
	public OidEnumerator GetEnumerator();

	public sealed class OidEnumerator
	: IEnumerator
	public Oid Current { get; }
	public virtual Boolean MoveNext();
	public virtual void Reset();

	public sealed enum OidGroup
	: IComparable, IFormattable, IConvertible
	{ All, HashAlgorithm, EncryptionAlgorithm, PublicKeyAlgorithm, SignatureAlgorithm, Attribute, ExtensionOrAttribute, EnhancedKeyUsage, Policy, Template, KeyDerivationFunction }

	public sealed enum PaddingMode
	: IComparable, IFormattable, IConvertible
	{ None, PKCS7, Zeros, ANSIX923, ISO10126 }

	public class PasswordDeriveBytes
	: DeriveBytes, IDisposable
	public String HashName { get; set; }
	public Int32 IterationCount { get; set; }
	public Byte Salt { get; set; }
	public Byte CryptDeriveKey(String algname, String alghashname, Int32 keySize, Byte[] rgbIV);
	protected virtual void Dispose(Boolean disposing);
	public virtual Byte GetBytes(Int32 cb);
	public virtual void Reset();

	public class PKCS1MaskGenerationMethod
	: MaskGenerationMethod
	public String HashName { get; set; }
	public virtual Byte GenerateMask(Byte[] rgbSeed, Int32 cbReturn);

public abstract class RandomNumberGenerator	public abstract class RandomNumberGenerator
	: IDisposable
	static public RandomNumberGenerator Create();
	static public RandomNumberGenerator Create(String rngName);
	public virtual void Dispose();
	protected virtual void Dispose(Boolean disposing);
public abstract virtual void GetBytes(Byte data);	public abstract virtual void GetBytes(Byte data);

	public abstract class RC2
	: SymmetricAlgorithm, IDisposable
	public virtual Int32 EffectiveKeySize { get; set; }
	public virtual Int32 KeySize { get; set; }
	static public RC2 Create();
	static public RC2 Create(String AlgName);

	public sealed class RC2CryptoServiceProvider
	: RC2, IDisposable
	public virtual Int32 EffectiveKeySize { get; set; }
	public Boolean UseSalt { get; set; }
	public virtual ICryptoTransform CreateDecryptor(Byte rgbKey, Byte[] rgbIV);
	public virtual ICryptoTransform CreateEncryptor(Byte rgbKey, Byte[] rgbIV);
	public virtual void GenerateIV();
	public virtual void GenerateKey();

public class Rfc2898DeriveBytes	public class Rfc2898DeriveBytes
: DeriveBytes	: DeriveBytes, IDisposable
public Int32 IterationCount { get; set; }	public Int32 IterationCount { get; set; }
public Byte Salt { get; set; }	public Byte Salt { get; set; }
	protected virtual void Dispose(Boolean disposing);
public virtual Byte GetBytes(Int32 cb);	public virtual Byte GetBytes(Int32 cb);
public virtual void Reset();	public virtual void Reset();

	public abstract class Rijndael
	: SymmetricAlgorithm, IDisposable
	static public Rijndael Create();
	static public Rijndael Create(String algName);

	public sealed class RijndaelManaged
	: Rijndael, IDisposable
	public virtual ICryptoTransform CreateDecryptor(Byte rgbKey, Byte[] rgbIV);
	public virtual ICryptoTransform CreateEncryptor(Byte rgbKey, Byte[] rgbIV);
	public virtual void GenerateIV();
	public virtual void GenerateKey();

	public sealed class RijndaelManagedTransform
	: ICryptoTransform, IDisposable
	public Int32 BlockSizeValue { get; }
	public virtual Boolean CanReuseTransform { get; }
	public virtual Boolean CanTransformMultipleBlocks { get; }
	public virtual Int32 InputBlockSize { get; }
	public virtual Int32 OutputBlockSize { get; }
	public void Clear();
	public virtual void Dispose();
	public void Reset();
	public virtual Int32 TransformBlock(Byte inputBuffer, Int32 inputOffset, Int32 inputCount, Byte[] outputBuffer, Int32 outputOffset);
	public virtual Byte TransformFinalBlock(Byte[] inputBuffer, Int32 inputOffset, Int32 inputCount);

	public abstract class RIPEMD160
	: HashAlgorithm, ICryptoTransform, IDisposable
	static public RIPEMD160 Create();
	static public RIPEMD160 Create(String hashName);

	public class RIPEMD160Managed
	: RIPEMD160, ICryptoTransform, IDisposable
	protected virtual void HashCore(Byte rgb, Int32 ibStart, Int32 cbSize);
	protected virtual Byte HashFinal();
	public virtual void Initialize();

public sealed class RNGCryptoServiceProvider	public sealed class RNGCryptoServiceProvider
: RandomNumberGenerator	: RandomNumberGenerator, IDisposable
	protected virtual void Dispose(Boolean disposing);
public virtual void GetBytes(Byte data);	public virtual void GetBytes(Byte data);

	public abstract class RSA
	: AsymmetricAlgorithm, IDisposable
	static public RSA Create();
	static public RSA Create(String algName);
	public abstract virtual Byte DecryptValue(Byte[] rgb);
	public abstract virtual Byte EncryptValue(Byte[] rgb);
	public abstract virtual RSAParameters ExportParameters(Boolean includePrivateParameters);
	public virtual void FromXmlString(String xmlString);
	public abstract virtual void ImportParameters(RSAParameters parameters);
	public virtual String ToXmlString(Boolean includePrivateParameters);

	public sealed class RSACryptoServiceProvider
	: RSA, IDisposable, ICspAsymmetricAlgorithm
	public virtual CspKeyContainerInfo CspKeyContainerInfo { get; }
	public virtual String KeyExchangeAlgorithm { get; }
	public virtual Int32 KeySize { get; }
	public Boolean PersistKeyInCsp { get; set; }
	public Boolean PublicOnly { get; }
	public virtual String SignatureAlgorithm { get; }
	static public Boolean UseMachineKeyStore { get; set; }
	public Byte Decrypt(Byte[] rgb, Boolean fOAEP);
	public virtual Byte DecryptValue(Byte[] rgb);
	protected virtual void Dispose(Boolean disposing);
	public Byte Encrypt(Byte[] rgb, Boolean fOAEP);
	public virtual Byte EncryptValue(Byte[] rgb);
	public virtual Byte ExportCspBlob(Boolean includePrivateParameters);
	public virtual RSAParameters ExportParameters(Boolean includePrivateParameters);
	public virtual void ImportCspBlob(Byte keyBlob);
	public virtual void ImportParameters(RSAParameters parameters);
	public Byte SignData(Stream inputStream, Object halg);
	public Byte SignData(Byte[] buffer, Object halg);
	public Byte SignData(Byte[] buffer, Int32 offset, Int32 count, Object halg);
	public Byte SignHash(Byte[] rgbHash, String str);
	public Boolean VerifyData(Byte buffer, Object halg, Byte[] signature);
	public Boolean VerifyHash(Byte rgbHash, String str, Byte[] rgbSignature);

	public class RSAOAEPKeyExchangeDeformatter
	: AsymmetricKeyExchangeDeformatter
	public virtual String Parameters { get; set; }
	public virtual Byte DecryptKeyExchange(Byte[] rgbData);
	public virtual void SetKey(AsymmetricAlgorithm key);

	public class RSAOAEPKeyExchangeFormatter
	: AsymmetricKeyExchangeFormatter
	public Byte Parameter { get; set; }
	public virtual String Parameters { get; }
	public RandomNumberGenerator Rng { get; set; }
	public virtual Byte CreateKeyExchange(Byte[] rgbData);
	public virtual Byte CreateKeyExchange(Byte[] rgbData, Type symAlgType);
	public virtual void SetKey(AsymmetricAlgorithm key);

	public sealed struct RSAParameters
	: ValueType

	public class RSAPKCS1KeyExchangeDeformatter
	: AsymmetricKeyExchangeDeformatter
	public virtual String Parameters { get; set; }
	public RandomNumberGenerator RNG { get; set; }
	public virtual Byte DecryptKeyExchange(Byte[] rgbIn);
	public virtual void SetKey(AsymmetricAlgorithm key);

	public class RSAPKCS1KeyExchangeFormatter
	: AsymmetricKeyExchangeFormatter
	public virtual String Parameters { get; }
	public RandomNumberGenerator Rng { get; set; }
	public virtual Byte CreateKeyExchange(Byte[] rgbData);
	public virtual Byte CreateKeyExchange(Byte[] rgbData, Type symAlgType);
	public virtual void SetKey(AsymmetricAlgorithm key);

	public class RSAPKCS1SignatureDeformatter
	: AsymmetricSignatureDeformatter
	public virtual void SetHashAlgorithm(String strName);
	public virtual void SetKey(AsymmetricAlgorithm key);
	public virtual Boolean VerifySignature(Byte rgbHash, Byte[] rgbSignature);

	public class RSAPKCS1SignatureFormatter
	: AsymmetricSignatureFormatter
	public virtual Byte CreateSignature(Byte[] rgbHash);
	public virtual void SetHashAlgorithm(String strName);
	public virtual void SetKey(AsymmetricAlgorithm key);

public abstract class SHA1	public abstract class SHA1
: HashAlgorithm, ICryptoTransform, IDisposable	: HashAlgorithm, ICryptoTransform, IDisposable
	static public SHA1 Create();

	public sealed class SHA1Cng
	: SHA1, ICryptoTransform, IDisposable
	protected virtual void Dispose(Boolean disposing);
	protected virtual void HashCore(Byte array, Int32 ibStart, Int32 cbSize);
	protected virtual Byte HashFinal();
	public virtual void Initialize();

	public sealed class SHA1CryptoServiceProvider
	: SHA1, ICryptoTransform, IDisposable
	protected virtual void Dispose(Boolean disposing);
	protected virtual void HashCore(Byte rgb, Int32 ibStart, Int32 cbSize);
	protected virtual Byte HashFinal();
	public virtual void Initialize();

public class SHA1Managed	public class SHA1Managed
: SHA1, ICryptoTransform, IDisposable	: SHA1, ICryptoTransform, IDisposable
	protected virtual void HashCore(Byte rgb, Int32 ibStart, Int32 cbSize);
	protected virtual Byte HashFinal();
public virtual void Initialize();	public virtual void Initialize();

public abstract class SHA256	public abstract class SHA256
: HashAlgorithm, ICryptoTransform, IDisposable	: HashAlgorithm, ICryptoTransform, IDisposable
	static public SHA256 Create();

	public sealed class SHA256Cng
	: SHA256, ICryptoTransform, IDisposable
	protected virtual void Dispose(Boolean disposing);
	protected virtual void HashCore(Byte array, Int32 ibStart, Int32 cbSize);
	protected virtual Byte HashFinal();
	public virtual void Initialize();

	public sealed class SHA256CryptoServiceProvider
	: SHA256, ICryptoTransform, IDisposable
	protected virtual void Dispose(Boolean disposing);
	protected virtual void HashCore(Byte array, Int32 ibStart, Int32 cbSize);
	protected virtual Byte HashFinal();
	public virtual void Initialize();

public class SHA256Managed	public class SHA256Managed
: SHA256, ICryptoTransform, IDisposable	: SHA256, ICryptoTransform, IDisposable
	protected virtual void HashCore(Byte rgb, Int32 ibStart, Int32 cbSize);
	protected virtual Byte HashFinal();
public virtual void Initialize();	public virtual void Initialize();

	public abstract class SHA384
	: HashAlgorithm, ICryptoTransform, IDisposable
	static public SHA384 Create();
	static public SHA384 Create(String hashName);

	public sealed class SHA384Cng
	: SHA384, ICryptoTransform, IDisposable
	protected virtual void Dispose(Boolean disposing);
	protected virtual void HashCore(Byte array, Int32 ibStart, Int32 cbSize);
	protected virtual Byte HashFinal();
	public virtual void Initialize();

	public sealed class SHA384CryptoServiceProvider
	: SHA384, ICryptoTransform, IDisposable
	protected virtual void Dispose(Boolean disposing);
	protected virtual void HashCore(Byte array, Int32 ibStart, Int32 cbSize);
	protected virtual Byte HashFinal();
	public virtual void Initialize();

	public class SHA384Managed
	: SHA384, ICryptoTransform, IDisposable
	protected virtual void HashCore(Byte rgb, Int32 ibStart, Int32 cbSize);
	protected virtual Byte HashFinal();
	public virtual void Initialize();

	public abstract class SHA512
	: HashAlgorithm, ICryptoTransform, IDisposable
	static public SHA512 Create();
	static public SHA512 Create(String hashName);

	public sealed class SHA512Cng
	: SHA512, ICryptoTransform, IDisposable
	protected virtual void Dispose(Boolean disposing);
	protected virtual void HashCore(Byte array, Int32 ibStart, Int32 cbSize);
	protected virtual Byte HashFinal();
	public virtual void Initialize();

	public sealed class SHA512CryptoServiceProvider
	: SHA512, ICryptoTransform, IDisposable
	protected virtual void Dispose(Boolean disposing);
	protected virtual void HashCore(Byte array, Int32 ibStart, Int32 cbSize);
	protected virtual Byte HashFinal();
	public virtual void Initialize();

	public class SHA512Managed
	: SHA512, ICryptoTransform, IDisposable
	protected virtual void HashCore(Byte rgb, Int32 ibStart, Int32 cbSize);
	protected virtual Byte HashFinal();
	public virtual void Initialize();

	public class SignatureDescription
	public String DeformatterAlgorithm { get; set; }
	public String DigestAlgorithm { get; set; }
	public String FormatterAlgorithm { get; set; }
	public String KeyAlgorithm { get; set; }
	public virtual AsymmetricSignatureDeformatter CreateDeformatter(AsymmetricAlgorithm key);
	public virtual HashAlgorithm CreateDigest();
	public virtual AsymmetricSignatureFormatter CreateFormatter(AsymmetricAlgorithm key);

	public sealed enum SignatureVerificationResult
	: IComparable, IFormattable, IConvertible
	{ Valid, AssemblyIdentityMismatch, ContainingSignatureInvalid, PublicKeyTokenMismatch, PublisherMismatch, SystemError, InvalidSignerCertificate, InvalidCountersignature, InvalidCertificateSignature, InvalidTimestamp, BadDigest, BasicConstraintsNotObserved, UnknownTrustProvider, UnknownVerificationAction, BadSignatureFormat, CertificateNotExplicitlyTrusted, MissingSignature, CertificateExpired, InvalidTimePeriodNesting, InvalidCertificateRole, PathLengthConstraintViolated, UnknownCriticalExtension, CertificateUsageNotAllowed, IssuerChainingError, CertificateMalformed, UntrustedRootCertificate, CouldNotBuildChain, GenericTrustFailure, CertificateRevoked, UntrustedTestRootCertificate, RevocationCheckFailure, InvalidCertificateUsage, CertificateExplicitlyDistrusted, UntrustedCertificationAuthority, InvalidCertificatePolicy, InvalidCertificateName }

	public sealed class StrongNameSignatureInformation
	public String HashAlgorithm { get; }
	public Int32 HResult { get; }
	public Boolean IsValid { get; }
	public AsymmetricAlgorithm PublicKey { get; }
	public SignatureVerificationResult VerificationResult { get; }

public abstract class SymmetricAlgorithm	public abstract class SymmetricAlgorithm
: IDisposable	: IDisposable
public virtual Int32 BlockSize { get; set; }	public virtual Int32 BlockSize { get; set; }
	public virtual Int32 FeedbackSize { get; set; }
public virtual Byte IV { get; set; }	public virtual Byte IV { get; set; }
public virtual Byte Key { get; set; }	public virtual Byte Key { get; set; }
public virtual Int32 KeySize { get; set; }	public virtual Int32 KeySize { get; set; }
public virtual KeySizes LegalBlockSizes { get; }	public virtual KeySizes LegalBlockSizes { get; }
public virtual KeySizes LegalKeySizes { get; }	public virtual KeySizes LegalKeySizes { get; }
	public virtual CipherMode Mode { get; set; }
	public virtual PaddingMode Padding { get; set; }
public void Clear();	public void Clear();
	static public SymmetricAlgorithm Create();
	static public SymmetricAlgorithm Create(String algName);
public virtual ICryptoTransform CreateDecryptor();	public virtual ICryptoTransform CreateDecryptor();
public abstract virtual ICryptoTransform CreateDecryptor(Byte rgbKey, Byte[] rgbIV);	public abstract virtual ICryptoTransform CreateDecryptor(Byte rgbKey, Byte[] rgbIV);
public virtual ICryptoTransform CreateEncryptor();	public virtual ICryptoTransform CreateEncryptor();
public abstract virtual ICryptoTransform CreateEncryptor(Byte rgbKey, Byte[] rgbIV);	public abstract virtual ICryptoTransform CreateEncryptor(Byte rgbKey, Byte[] rgbIV);
	public virtual void Dispose();
	protected virtual void Dispose(Boolean disposing);
public abstract virtual void GenerateIV();	public abstract virtual void GenerateIV();
public abstract virtual void GenerateKey();	public abstract virtual void GenerateKey();
public Boolean ValidKeySize(Int32 bitLength);	public Boolean ValidKeySize(Int32 bitLength);

	public class ToBase64Transform
	: ICryptoTransform, IDisposable
	public virtual Boolean CanReuseTransform { get; }
	public virtual Boolean CanTransformMultipleBlocks { get; }
	public virtual Int32 InputBlockSize { get; }
	public virtual Int32 OutputBlockSize { get; }
	public void Clear();
	public virtual void Dispose();
	protected virtual void Dispose(Boolean disposing);
	protected virtual void Finalize();
	public virtual Int32 TransformBlock(Byte inputBuffer, Int32 inputOffset, Int32 inputCount, Byte[] outputBuffer, Int32 outputOffset);
	public virtual Byte TransformFinalBlock(Byte[] inputBuffer, Int32 inputOffset, Int32 inputCount);

	public abstract class TripleDES
	: SymmetricAlgorithm, IDisposable
	public virtual Byte Key { get; set; }
	static public TripleDES Create();
	static public TripleDES Create(String str);
	static public Boolean IsWeakKey(Byte rgbKey);

	public sealed class TripleDESCryptoServiceProvider
	: TripleDES, IDisposable
	public virtual ICryptoTransform CreateDecryptor(Byte rgbKey, Byte[] rgbIV);
	public virtual ICryptoTransform CreateEncryptor(Byte rgbKey, Byte[] rgbIV);
	public virtual void GenerateIV();
	public virtual void GenerateKey();