X509Certificate2 Sınıf

Tanım

Ad Alanı:

System.Security.Cryptography.X509Certificates

Bütünleştirilmiş Kod:

System.Security.Cryptography.dll

Kaynak:

X509Certificate2.cs

X.509 sertifikayı temsil eder.

public ref class X509Certificate2 : System::Security::Cryptography::X509Certificates::X509Certificate

public class X509Certificate2 : System.Security.Cryptography.X509Certificates.X509Certificate

type X509Certificate2 = class
    inherit X509Certificate

Public Class X509Certificate2
Inherits X509Certificate

Devralma

Object

X509Certificate

X509Certificate2

Örnekler

Aşağıdaki örnekte, bir dosyanın şifrelenmesi ve şifresinin çözülmesi için bir X509Certificate2 nesnenin nasıl kullanılacağı gösterilmektedir.

using System;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.IO;
using System.Text;

// To run this sample use the Certificate Creation Tool (Makecert.exe) to generate a test X.509 certificate and
// place it in the local user store.
// To generate an exchange key and make the key exportable run the following command from a Visual Studio command prompt:

//makecert -r -pe -n "CN=CERT_SIGN_TEST_CERT" -b 01/01/2010 -e 01/01/2012 -sky exchange -ss my
namespace X509CertEncrypt
{
    class Program
    {

        // Path variables for source, encryption, and
        // decryption folders. Must end with a backslash.
        private static string encrFolder = @"C:\Encrypt\";
        private static string decrFolder = @"C:\Decrypt\";
        private static string originalFile = "TestData.txt";
        private static string encryptedFile = "TestData.enc";

        static void Main(string[] args)
        {

            // Create an input file with test data.
            StreamWriter sw = File.CreateText(originalFile);
            sw.WriteLine("Test data to be encrypted");
            sw.Close();

            // Get the certificate to use to encrypt the key.
            X509Certificate2 cert = GetCertificateFromStore("CN=CERT_SIGN_TEST_CERT");
            if (cert == null)
            {
                Console.WriteLine("Certificate 'CN=CERT_SIGN_TEST_CERT' not found.");
                Console.ReadLine();
            }

            // Encrypt the file using the public key from the certificate.
            EncryptFile(originalFile, (RSA)cert.PublicKey.Key);

            // Decrypt the file using the private key from the certificate.
            DecryptFile(encryptedFile, cert.GetRSAPrivateKey());

            //Display the original data and the decrypted data.
            Console.WriteLine("Original:   {0}", File.ReadAllText(originalFile));
            Console.WriteLine("Round Trip: {0}", File.ReadAllText(decrFolder + originalFile));
            Console.WriteLine("Press the Enter key to exit.");
            Console.ReadLine();
        }
        private static X509Certificate2 GetCertificateFromStore(string certName)
        {

            // Get the certificate store for the current user.
            X509Store store = new X509Store(StoreLocation.CurrentUser);
            try
            {
                store.Open(OpenFlags.ReadOnly);

                // Place all certificates in an X509Certificate2Collection object.
                X509Certificate2Collection certCollection = store.Certificates;
                // If using a certificate with a trusted root you do not need to FindByTimeValid, instead:
                // currentCerts.Find(X509FindType.FindBySubjectDistinguishedName, certName, true);
                X509Certificate2Collection currentCerts = certCollection.Find(X509FindType.FindByTimeValid, DateTime.Now, false);
                X509Certificate2Collection signingCert = currentCerts.Find(X509FindType.FindBySubjectDistinguishedName, certName, false);
                if (signingCert.Count == 0)
                    return null;
                // Return the first certificate in the collection, has the right name and is current.
                return signingCert[0];
            }
            finally
            {
                store.Close();
            }
        }

        // Encrypt a file using a public key.
        private static void EncryptFile(string inFile, RSA rsaPublicKey)
        {
            using (Aes aes = Aes.Create())
            {
                // Create instance of Aes for
                // symmetric encryption of the data.
                aes.KeySize = 256;
                aes.Mode = CipherMode.CBC;
                using (ICryptoTransform transform = aes.CreateEncryptor())
                {
                    RSAPKCS1KeyExchangeFormatter keyFormatter = new RSAPKCS1KeyExchangeFormatter(rsaPublicKey);
                    byte[] keyEncrypted = keyFormatter.CreateKeyExchange(aes.Key, aes.GetType());

                    // Create byte arrays to contain
                    // the length values of the key and IV.
                    byte[] LenK = new byte[4];
                    byte[] LenIV = new byte[4];

                    int lKey = keyEncrypted.Length;
                    LenK = BitConverter.GetBytes(lKey);
                    int lIV = aes.IV.Length;
                    LenIV = BitConverter.GetBytes(lIV);

                    // Write the following to the FileStream
                    // for the encrypted file (outFs):
                    // - length of the key
                    // - length of the IV
                    // - encrypted key
                    // - the IV
                    // - the encrypted cipher content

                    int startFileName = inFile.LastIndexOf("\\") + 1;
                    // Change the file's extension to ".enc"
                    string outFile = encrFolder + inFile.Substring(startFileName, inFile.LastIndexOf(".") - startFileName) + ".enc";
                    Directory.CreateDirectory(encrFolder);

                    using (FileStream outFs = new FileStream(outFile, FileMode.Create))
                    {

                        outFs.Write(LenK, 0, 4);
                        outFs.Write(LenIV, 0, 4);
                        outFs.Write(keyEncrypted, 0, lKey);
                        outFs.Write(aes.IV, 0, lIV);

                        // Now write the cipher text using
                        // a CryptoStream for encrypting.
                        using (CryptoStream outStreamEncrypted = new CryptoStream(outFs, transform, CryptoStreamMode.Write))
                        {

                            // By encrypting a chunk at
                            // a time, you can save memory
                            // and accommodate large files.
                            int count = 0;

                            // blockSizeBytes can be any arbitrary size.
                            int blockSizeBytes = aes.BlockSize / 8;
                            byte[] data = new byte[blockSizeBytes];
                            int bytesRead = 0;

                            using (FileStream inFs = new FileStream(inFile, FileMode.Open))
                            {
                                do
                                {
                                    count = inFs.Read(data, 0, blockSizeBytes);
                                    outStreamEncrypted.Write(data, 0, count);
                                    bytesRead += count;
                                }
                                while (count > 0);
                                inFs.Close();
                            }
                            outStreamEncrypted.FlushFinalBlock();
                            outStreamEncrypted.Close();
                        }
                        outFs.Close();
                    }
                }
            }
        }


        // Decrypt a file using a private key.
        private static void DecryptFile(string inFile, RSA rsaPrivateKey)
        {

            // Create instance of Aes for
            // symmetric decryption of the data.
            using (Aes aes = Aes.Create())
            {
                aes.KeySize = 256;
                aes.Mode = CipherMode.CBC;

                // Create byte arrays to get the length of
                // the encrypted key and IV.
                // These values were stored as 4 bytes each
                // at the beginning of the encrypted package.
                byte[] LenK = new byte[4];
                byte[] LenIV = new byte[4];

                // Construct the file name for the decrypted file.
                string outFile = decrFolder + inFile.Substring(0, inFile.LastIndexOf(".")) + ".txt";

                // Use FileStream objects to read the encrypted
                // file (inFs) and save the decrypted file (outFs).
                using (FileStream inFs = new FileStream(encrFolder + inFile, FileMode.Open))
                {

                    inFs.Seek(0, SeekOrigin.Begin);
                    inFs.Seek(0, SeekOrigin.Begin);
                    inFs.Read(LenK, 0, 3);
                    inFs.Seek(4, SeekOrigin.Begin);
                    inFs.Read(LenIV, 0, 3);

                    // Convert the lengths to integer values.
                    int lenK = BitConverter.ToInt32(LenK, 0);
                    int lenIV = BitConverter.ToInt32(LenIV, 0);

                    // Determine the start position of
                    // the cipher text (startC)
                    // and its length(lenC).
                    int startC = lenK + lenIV + 8;
                    int lenC = (int)inFs.Length - startC;

                    // Create the byte arrays for
                    // the encrypted Aes key,
                    // the IV, and the cipher text.
                    byte[] KeyEncrypted = new byte[lenK];
                    byte[] IV = new byte[lenIV];

                    // Extract the key and IV
                    // starting from index 8
                    // after the length values.
                    inFs.Seek(8, SeekOrigin.Begin);
                    inFs.Read(KeyEncrypted, 0, lenK);
                    inFs.Seek(8 + lenK, SeekOrigin.Begin);
                    inFs.Read(IV, 0, lenIV);
                    Directory.CreateDirectory(decrFolder);
                    // Use RSA
                    // to decrypt the Aes key.
                    byte[] KeyDecrypted = rsaPrivateKey.Decrypt(KeyEncrypted, RSAEncryptionPadding.Pkcs1);

                    // Decrypt the key.
                    using (ICryptoTransform transform = aes.CreateDecryptor(KeyDecrypted, IV))
                    {

                        // Decrypt the cipher text from
                        // from the FileSteam of the encrypted
                        // file (inFs) into the FileStream
                        // for the decrypted file (outFs).
                        using (FileStream outFs = new FileStream(outFile, FileMode.Create))
                        {

                            int count = 0;

                            int blockSizeBytes = aes.BlockSize / 8;
                            byte[] data = new byte[blockSizeBytes];

                            // By decrypting a chunk a time,
                            // you can save memory and
                            // accommodate large files.

                            // Start at the beginning
                            // of the cipher text.
                            inFs.Seek(startC, SeekOrigin.Begin);
                            using (CryptoStream outStreamDecrypted = new CryptoStream(outFs, transform, CryptoStreamMode.Write))
                            {
                                do
                                {
                                    count = inFs.Read(data, 0, blockSizeBytes);
                                    outStreamDecrypted.Write(data, 0, count);
                                }
                                while (count > 0);

                                outStreamDecrypted.FlushFinalBlock();
                                outStreamDecrypted.Close();
                            }
                            outFs.Close();
                        }
                        inFs.Close();
                    }
                }
            }
        }
    }
}

Imports System.Security.Cryptography
Imports System.Security.Cryptography.X509Certificates
Imports System.IO
Imports System.Text


' To run this sample use the Certificate Creation Tool (Makecert.exe) to generate a test X.509 certificate and
' place it in the local user store.
' To generate an exchange key and make the key exportable run the following command from a Visual Studio command prompt:
'makecert -r -pe -n "CN=CERT_SIGN_TEST_CERT" -b 01/01/2010 -e 01/01/2012 -sky exchange -ss my

Class Program

    ' Path variables for source, encryption, and
    ' decryption folders. Must end with a backslash.
    Private Shared encrFolder As String = "C:\Encrypt\"
    Private Shared decrFolder As String = "C:\Decrypt\"
    Private Shared originalFile As String = "TestData.txt"
    Private Shared encryptedFile As String = "TestData.enc"


    Shared Sub Main(ByVal args() As String)

        ' Create an input file with test data.
        Dim sw As StreamWriter = File.CreateText(originalFile)
        sw.WriteLine("Test data to be encrypted")
        sw.Close()

        ' Get the certificate to use to encrypt the key.
        Dim cert As X509Certificate2 = GetCertificateFromStore("CN=CERT_SIGN_TEST_CERT")
        If cert Is Nothing Then
            Console.WriteLine("Certificate 'CN=CERT_SIGN_TEST_CERT' not found.")
            Console.ReadLine()
        End If


        ' Encrypt the file using the public key from the certificate.
        EncryptFile(originalFile, CType(cert.PublicKey.Key, RSA))

        ' Decrypt the file using the private key from the certificate.
        DecryptFile(encryptedFile, cert.GetRSAPrivateKey())

        'Display the original data and the decrypted data.
        Console.WriteLine("Original:   {0}", File.ReadAllText(originalFile))
        Console.WriteLine("Round Trip: {0}", File.ReadAllText(decrFolder + originalFile))
        Console.WriteLine("Press the Enter key to exit.")
        Console.ReadLine()

    End Sub

    Private Shared Function GetCertificateFromStore(ByVal certName As String) As X509Certificate2
        ' Get the certificate store for the current user.
        Dim store As New X509Store(StoreLocation.CurrentUser)
        Try
            store.Open(OpenFlags.ReadOnly)

            ' Place all certificates in an X509Certificate2Collection object.
            Dim certCollection As X509Certificate2Collection = store.Certificates
            ' If using a certificate with a trusted root you do not need to FindByTimeValid, instead use:
            ' currentCerts.Find(X509FindType.FindBySubjectDistinguishedName, certName, true);
            Dim currentCerts As X509Certificate2Collection = certCollection.Find(X509FindType.FindByTimeValid, DateTime.Now, False)
            Dim signingCert As X509Certificate2Collection = currentCerts.Find(X509FindType.FindBySubjectDistinguishedName, certName, False)
            If signingCert.Count = 0 Then
                Return Nothing
            End If ' Return the first certificate in the collection, has the right name and is current.
            Return signingCert(0)
        Finally
            store.Close()
        End Try


    End Function 'GetCertificateFromStore

    ' Encrypt a file using a public key.
    Private Shared Sub EncryptFile(ByVal inFile As String, ByVal rsaPublicKey As RSA)
        Dim aes As Aes = Aes.Create()
        Try
            ' Create instance of Aes for
            ' symmetric encryption of the data.
            aes.KeySize = 256
            aes.Mode = CipherMode.CBC
            Dim transform As ICryptoTransform = aes.CreateEncryptor()
            Try
                Dim keyFormatter As New RSAPKCS1KeyExchangeFormatter(rsaPublicKey)
                Dim keyEncrypted As Byte() = keyFormatter.CreateKeyExchange(aes.Key, aes.GetType())

                ' Create byte arrays to contain
                ' the length values of the key and IV.
                Dim LenK(3) As Byte
                Dim LenIV(3) As Byte

                Dim lKey As Integer = keyEncrypted.Length
                LenK = BitConverter.GetBytes(lKey)
                Dim lIV As Integer = aes.IV.Length
                LenIV = BitConverter.GetBytes(lIV)

                ' Write the following to the FileStream
                ' for the encrypted file (outFs):
                ' - length of the key
                ' - length of the IV
                ' - encrypted key
                ' - the IV
                ' - the encrypted cipher content
                Dim startFileName As Integer = inFile.LastIndexOf("\") + 1
                ' Change the file's extension to ".enc"
                Dim outFile As String = encrFolder + inFile.Substring(startFileName, inFile.LastIndexOf(".") - startFileName) + ".enc"
                Directory.CreateDirectory(encrFolder)

                Dim outFs As New FileStream(outFile, FileMode.Create)
                Try

                    outFs.Write(LenK, 0, 4)
                    outFs.Write(LenIV, 0, 4)
                    outFs.Write(keyEncrypted, 0, lKey)
                    outFs.Write(aes.IV, 0, lIV)

                    ' Now write the cipher text using
                    ' a CryptoStream for encrypting.
                    Dim outStreamEncrypted As New CryptoStream(outFs, transform, CryptoStreamMode.Write)
                    Try

                        ' By encrypting a chunk at
                        ' a time, you can save memory
                        ' and accommodate large files.
                        Dim count As Integer = 0

                        ' blockSizeBytes can be any arbitrary size.
                        Dim blockSizeBytes As Integer = aes.BlockSize / 8
                        Dim data(blockSizeBytes) As Byte
                        Dim bytesRead As Integer = 0

                        Dim inFs As New FileStream(inFile, FileMode.Open)
                        Try
                            Do
                                count = inFs.Read(data, 0, blockSizeBytes)
                                outStreamEncrypted.Write(data, 0, count)
                                bytesRead += count
                            Loop While count > 0
                            inFs.Close()
                        Finally
                            inFs.Dispose()
                        End Try
                        outStreamEncrypted.FlushFinalBlock()
                        outStreamEncrypted.Close()
                    Finally
                        outStreamEncrypted.Dispose()
                    End Try
                    outFs.Close()
                Finally
                    outFs.Dispose()
                End Try
            Finally
                transform.Dispose()
            End Try
        Finally
            aes.Dispose()
        End Try

    End Sub


    ' Decrypt a file using a private key.
    Private Shared Sub DecryptFile(ByVal inFile As String, ByVal rsaPrivateKey As RSA)

        ' Create instance of Aes for
        ' symmetric decryption of the data.
        Dim aes As Aes = Aes.Create()
        Try
            aes.KeySize = 256
            aes.Mode = CipherMode.CBC

            ' Create byte arrays to get the length of
            ' the encrypted key and IV.
            ' These values were stored as 4 bytes each
            ' at the beginning of the encrypted package.
            Dim LenK() As Byte = New Byte(4 - 1) {}
            Dim LenIV() As Byte = New Byte(4 - 1) {}

            ' Consruct the file name for the decrypted file.
            Dim outFile As String = decrFolder + inFile.Substring(0, inFile.LastIndexOf(".")) + ".txt"

            ' Use FileStream objects to read the encrypted
            ' file (inFs) and save the decrypted file (outFs).
            Dim inFs As New FileStream(encrFolder + inFile, FileMode.Open)
            Try

                inFs.Seek(0, SeekOrigin.Begin)
                inFs.Seek(0, SeekOrigin.Begin)
                inFs.Read(LenK, 0, 3)
                inFs.Seek(4, SeekOrigin.Begin)
                inFs.Read(LenIV, 0, 3)

                ' Convert the lengths to integer values.
                Dim lengthK As Integer = BitConverter.ToInt32(LenK, 0)
                Dim lengthIV As Integer = BitConverter.ToInt32(LenIV, 0)

                ' Determine the start postition of
                ' the cipher text (startC)
                ' and its length(lenC).
                Dim startC As Integer = lengthK + lengthIV + 8
                Dim lenC As Integer = (CType(inFs.Length, Integer) - startC)

                ' Create the byte arrays for
                ' the encrypted AES key,
                ' the IV, and the cipher text.
                Dim KeyEncrypted() As Byte = New Byte(lengthK - 1) {}
                Dim IV() As Byte = New Byte(lengthIV - 1) {}

                ' Extract the key and IV
                ' starting from index 8
                ' after the length values.
                inFs.Seek(8, SeekOrigin.Begin)
                inFs.Read(KeyEncrypted, 0, lengthK)
                inFs.Seek(8 + lengthK, SeekOrigin.Begin)
                inFs.Read(IV, 0, lengthIV)
                Directory.CreateDirectory(decrFolder)
                ' Use RSA
                ' to decrypt the AES key.
                Dim KeyDecrypted As Byte() = rsaPrivateKey.Decrypt(KeyEncrypted, RSAEncryptionPadding.Pkcs1)

                ' Decrypt the key.
                Dim transform As ICryptoTransform = aes.CreateDecryptor(KeyDecrypted, IV)
                ' Decrypt the cipher text from
                ' from the FileSteam of the encrypted
                ' file (inFs) into the FileStream
                ' for the decrypted file (outFs).
                Dim outFs As New FileStream(outFile, FileMode.Create)
                Try
                    ' Decrypt the cipher text from
                    ' from the FileSteam of the encrypted
                    ' file (inFs) into the FileStream
                    ' for the decrypted file (outFs).

                    Dim count As Integer = 0

                    Dim blockSizeBytes As Integer = aes.BlockSize / 8
                    Dim data(blockSizeBytes) As Byte

                    ' By decrypting a chunk a time,
                    ' you can save memory and
                    ' accommodate large files.
                    ' Start at the beginning
                    ' of the cipher text.
                    inFs.Seek(startC, SeekOrigin.Begin)
                    Dim outStreamDecrypted As New CryptoStream(outFs, transform, CryptoStreamMode.Write)
                    Try
                        Do
                            count = inFs.Read(data, 0, blockSizeBytes)
                            outStreamDecrypted.Write(data, 0, count)
                        Loop While count > 0

                        outStreamDecrypted.FlushFinalBlock()
                        outStreamDecrypted.Close()
                    Finally
                        outStreamDecrypted.Dispose()
                    End Try
                    outFs.Close()
                Finally
                    outFs.Dispose()
                End Try
                inFs.Close()

            Finally
                inFs.Dispose()

            End Try

        Finally
            aes.Dispose()
        End Try


    End Sub
End Class

Aşağıdaki örnek, bir sertifika dosyasını bağımsız değişken olarak alan ve çeşitli sertifika özelliklerini konsola yazdıran bir komut satırı yürütülebilir dosyası oluşturur.

#using <System.dll>

using namespace System;
using namespace System::Security::Cryptography;
using namespace System::Security::Permissions;
using namespace System::IO;
using namespace System::Security::Cryptography::X509Certificates;

//Reads a file.
array<Byte>^ ReadFile( String^ fileName )
{
   FileStream^ f = gcnew FileStream( fileName,FileMode::Open,FileAccess::Read );
   int size = (int)f->Length;
   array<Byte>^data = gcnew array<Byte>(size);
   size = f->Read( data, 0, size );
   f->Close();
   return data;
}

[SecurityPermissionAttribute(SecurityAction::LinkDemand, Unrestricted = true)]
int main()
{
   array<String^>^args = Environment::GetCommandLineArgs();

   //Test for correct number of arguments.
   if ( args->Length < 2 )
   {
      Console::WriteLine( "Usage: CertInfo <filename>" );
      return  -1;
   }

   try
   {
      System::Security::Cryptography::X509Certificates::X509Certificate2 ^ x509 =
            gcnew System::Security::Cryptography::X509Certificates::X509Certificate2;

      //Create X509Certificate2 object from .cer file.
      array<Byte>^rawData = ReadFile( args[ 1 ] );

      x509->Import(rawData);

      //Print to console information contained in the certificate.
      Console::WriteLine( "{0}Subject: {1}{0}", Environment::NewLine, x509->Subject );
      Console::WriteLine( "{0}Issuer: {1}{0}", Environment::NewLine, x509->Issuer );
      Console::WriteLine( "{0}Version: {1}{0}", Environment::NewLine, x509->Version );
      Console::WriteLine( "{0}Valid Date: {1}{0}", Environment::NewLine, x509->NotBefore );
      Console::WriteLine( "{0}Expiry Date: {1}{0}", Environment::NewLine, x509->NotAfter );
      Console::WriteLine( "{0}Thumbprint: {1}{0}", Environment::NewLine, x509->Thumbprint );
      Console::WriteLine( "{0}Serial Number: {1}{0}", Environment::NewLine, x509->SerialNumber );
      Console::WriteLine( "{0}Friendly Name: {1}{0}", Environment::NewLine, x509->PublicKey->Oid->FriendlyName );
      Console::WriteLine( "{0}Public Key Format: {1}{0}", Environment::NewLine, x509->PublicKey->EncodedKeyValue->Format(true) );
      Console::WriteLine( "{0}Raw Data Length: {1}{0}", Environment::NewLine, x509->RawData->Length );
      Console::WriteLine( "{0}Certificate to string: {1}{0}", Environment::NewLine, x509->ToString( true ) );
      Console::WriteLine( "{0}Certificate to XML String: {1}{0}", Environment::NewLine, x509->PublicKey->Key->ToXmlString( false ) );

      //Add the certificate to a X509Store.
      X509Store ^ store = gcnew X509Store;
      store->Open( OpenFlags::MaxAllowed );
      store->Add( x509 );
      store->Close();
   }
   catch ( DirectoryNotFoundException^ )
   {
      Console::WriteLine( "Error: The directory specified could not be found." );
   }
   catch ( IOException^ )
   {
      Console::WriteLine( "Error: A file in the directory could not be accessed." );
   }
   catch ( NullReferenceException^ )
   {
      Console::WriteLine( "File must be a .cer file. Program does not have access to that type of file." );
   }

}

using System;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.IO;
using System.Security.Cryptography.X509Certificates;

class CertInfo
{
    //Reads a file.
    internal static byte[] ReadFile (string fileName)
    {
        FileStream f = new FileStream(fileName, FileMode.Open, FileAccess.Read);
        int size = (int)f.Length;
        byte[] data = new byte[size];
        size = f.Read(data, 0, size);
        f.Close();
        return data;
    }
    //Main method begins here.
    static void Main(string[] args)
    {
        //Test for correct number of arguments.
        if (args.Length < 1)
        {
            Console.WriteLine("Usage: CertInfo <filename>");
            return;
        }
        try
        {
            byte[] rawData = ReadFile(args[0]);
            //Create X509Certificate2 object from .cer file.
            X509Certificate2 x509 = new X509Certificate2(rawData);

            //Print to console information contained in the certificate.
            Console.WriteLine("{0}Subject: {1}{0}", Environment.NewLine, x509.Subject);
            Console.WriteLine("{0}Issuer: {1}{0}", Environment.NewLine, x509.Issuer);
            Console.WriteLine("{0}Version: {1}{0}", Environment.NewLine, x509.Version);
            Console.WriteLine("{0}Valid Date: {1}{0}", Environment.NewLine, x509.NotBefore);
            Console.WriteLine("{0}Expiry Date: {1}{0}", Environment.NewLine, x509.NotAfter);
            Console.WriteLine("{0}Thumbprint: {1}{0}", Environment.NewLine, x509.Thumbprint);
            Console.WriteLine("{0}Serial Number: {1}{0}", Environment.NewLine, x509.SerialNumber);
            Console.WriteLine("{0}Friendly Name: {1}{0}", Environment.NewLine, x509.PublicKey.Oid.FriendlyName);
            Console.WriteLine("{0}Public Key Format: {1}{0}", Environment.NewLine, x509.PublicKey.EncodedKeyValue.Format(true));
            Console.WriteLine("{0}Raw Data Length: {1}{0}", Environment.NewLine, x509.RawData.Length);
            Console.WriteLine("{0}Certificate to string: {1}{0}", Environment.NewLine, x509.ToString(true));
            Console.WriteLine("{0}Certificate to XML String: {1}{0}", Environment.NewLine, x509.PublicKey.Key.ToXmlString(false));

            //Add the certificate to a X509Store.
            X509Store store = new X509Store();
            store.Open(OpenFlags.MaxAllowed);
            store.Add(x509);
            store.Close();
        }
        catch (DirectoryNotFoundException)
        {
               Console.WriteLine("Error: The directory specified could not be found.");
        }
        catch (IOException)
        {
            Console.WriteLine("Error: A file in the directory could not be accessed.");
        }
        catch (NullReferenceException)
        {
            Console.WriteLine("File must be a .cer file. Program does not have access to that type of file.");
        }
    }
}

Imports System.Security.Cryptography
Imports System.Security.Permissions
Imports System.IO
Imports System.Security.Cryptography.X509Certificates

Class CertInfo

    'Reads a file.
    Friend Shared Function ReadFile(ByVal fileName As String) As Byte()
        Dim f As New FileStream(fileName, FileMode.Open, FileAccess.Read)
        Dim size As Integer = Fix(f.Length)
        Dim data(size - 1) As Byte
        size = f.Read(data, 0, size)
        f.Close()
        Return data

    End Function 

    <SecurityPermission(SecurityAction.LinkDemand, Unrestricted:=True)> _
    Shared Sub Main(ByVal args() As String)
        'Test for correct number of arguments.
        If args.Length < 1 Then
            Console.WriteLine("Usage: CertInfo <filename>")
            Return
        End If
        Try
            Dim x509 As New X509Certificate2()
            'Create X509Certificate2 object from .cer file.
            Dim rawData As Byte() = ReadFile(args(0))
            
            x509.Import(rawData)

            'Print to console information contained in the certificate.
            Console.WriteLine("{0}Subject: {1}{0}", Environment.NewLine, x509.Subject)
            Console.WriteLine("{0}Issuer: {1}{0}", Environment.NewLine, x509.Issuer)
            Console.WriteLine("{0}Version: {1}{0}", Environment.NewLine, x509.Version)
            Console.WriteLine("{0}Valid Date: {1}{0}", Environment.NewLine, x509.NotBefore)
            Console.WriteLine("{0}Expiry Date: {1}{0}", Environment.NewLine, x509.NotAfter)
            Console.WriteLine("{0}Thumbprint: {1}{0}", Environment.NewLine, x509.Thumbprint)
            Console.WriteLine("{0}Serial Number: {1}{0}", Environment.NewLine, x509.SerialNumber)
            Console.WriteLine("{0}Friendly Name: {1}{0}", Environment.NewLine, x509.PublicKey.Oid.FriendlyName)
            Console.WriteLine("{0}Public Key Format: {1}{0}", Environment.NewLine, x509.PublicKey.EncodedKeyValue.Format(True))
            Console.WriteLine("{0}Raw Data Length: {1}{0}", Environment.NewLine, x509.RawData.Length)
            Console.WriteLine("{0}Certificate to string: {1}{0}", Environment.NewLine, x509.ToString(True))

            Console.WriteLine("{0}Certificate to XML String: {1}{0}", Environment.NewLine, x509.PublicKey.Key.ToXmlString(False))

            'Add the certificate to a X509Store.
            Dim store As New X509Store()
            store.Open(OpenFlags.MaxAllowed)
            store.Add(x509)
            store.Close()

        Catch dnfExcept As DirectoryNotFoundException
            Console.WriteLine("Error: The directory specified could not be found.")
        Catch ioExpcept As IOException
            Console.WriteLine("Error: A file in the directory could not be accessed.")
        Catch nrExcept As NullReferenceException
            Console.WriteLine("File must be a .cer file. Program does not have access to that type of file.")
        End Try

    End Sub
End Class

Açıklamalar

X.509 yapısı Uluslararası Standardizasyon Örgütü (ISO) çalışma gruplarında kaynaklanır. Bu yapı kimlik, yetkilendirme ve sahip öznitelikleri (izinler, yaş, cinsiyet, konum, ilişki vb.) gibi çeşitli bilgi türlerini temsil etmek için kullanılabilir. ISO belirtimleri yapı üzerinde en bilgilendirici olsa da, X509Certificate2 sınıf internet mühendisliği görev gücü (IETF) Ortak Anahtar Altyapısı, X.509 (PKIX) çalışma grubu tarafından verilen belirtimlerde tanımlanan kullanım senaryolarını modellemek için tasarlanmıştır. Bu belirtimler hakkında en bilgilendirici olan RFC 3280, "Sertifika ve Sertifika İptal Listesi (CRL) Profili"dir.

Önemli

.NET Framework 4.6'dan başlayarak, bu tür arabirimi uygularIDisposable. Türünü kullanmayı bitirdiğinizde, doğrudan veya dolaylı olarak atmalısınız. Türü doğrudan atmak için yöntemini bir try/catch blokta çağırın.Dispose Bunu dolaylı olarak atmak için (C#'ta) veya Using (Visual Basic'te) gibi using bir dil yapısı kullanın. Daha fazla bilgi için arabirim konusunun "IDisposable Uygulayan Bir Nesne Kullanma" bölümüne IDisposable bakın.

.NET Framework 4.5.2 ve önceki sürümleri hedefleyen uygulamalar için sınıfı X509Certificate2 arabirimini uygulamaz IDisposable ve bu nedenle bir Dispose yöntemi yoktur.

Oluşturucular

X509Certificate2()	Geçersiz. X509Certificate2 sınıfının yeni bir örneğini başlatır.
X509Certificate2(Byte[])	Bayt dizisinden X509Certificate2 alınan bilgileri kullanarak sınıfının yeni bir örneğini başlatır.
X509Certificate2(Byte[], SecureString)	Bayt dizisi ve parola kullanarak sınıfının yeni bir örneğini X509Certificate2 başlatır.
X509Certificate2(Byte[], SecureString, X509KeyStorageFlags)	Bayt dizisi, parola ve anahtar depolama bayrağı kullanarak sınıfının yeni bir örneğini X509Certificate2 başlatır.
X509Certificate2(Byte[], String)	Bayt dizisi ve parola kullanarak sınıfının yeni bir örneğini X509Certificate2 başlatır.
X509Certificate2(Byte[], String, X509KeyStorageFlags)	Bayt dizisi, parola ve anahtar depolama bayrağı kullanarak sınıfının yeni bir örneğini X509Certificate2 başlatır.
X509Certificate2(IntPtr)	Yönetilmeyen bir tanıtıcı kullanarak sınıfının yeni bir örneğini X509Certificate2 başlatır.
X509Certificate2(ReadOnlySpan<Byte>)	Sertifika verilerinden sınıfının yeni bir örneğini X509Certificate2 başlatır.
X509Certificate2(ReadOnlySpan<Byte>, ReadOnlySpan<Char>, X509KeyStorageFlags)	Sertifika verilerinden X509Certificate2 , paroladan ve anahtar depolama bayraklarından sınıfının yeni bir örneğini başlatır.
X509Certificate2(SerializationInfo, StreamingContext)	Geçersiz. Belirtilen serileştirme ve akış bağlam bilgilerini kullanarak sınıfının yeni bir örneğini X509Certificate2 başlatır.
X509Certificate2(String)	Sertifika dosya adını kullanarak sınıfının yeni bir örneğini X509Certificate2 başlatır.
X509Certificate2(String, ReadOnlySpan<Char>, X509KeyStorageFlags)	Sertifika dosya adı, parola ve anahtar depolama bayrağı kullanarak sınıfının yeni bir örneğini X509Certificate2 başlatır.
X509Certificate2(String, SecureString)	Sertifika dosya adı ve parola kullanarak sınıfının yeni bir örneğini X509Certificate2 başlatır.
X509Certificate2(String, SecureString, X509KeyStorageFlags)	Sertifika dosya adı, parola ve anahtar depolama bayrağı kullanarak sınıfının yeni bir örneğini X509Certificate2 başlatır.
X509Certificate2(String, String)	Sertifika dosya adını ve sertifikaya X509Certificate2 erişmek için kullanılan parolayı kullanarak sınıfının yeni bir örneğini başlatır.
X509Certificate2(String, String, X509KeyStorageFlags)	Sertifika dosya adını, sertifikaya erişmek için kullanılan parolayı X509Certificate2 ve anahtar depolama bayrağını kullanarak sınıfın yeni bir örneğini başlatır.
X509Certificate2(X509Certificate)	Nesnesini kullanarak sınıfının yeni bir X509Certificate örneğini X509Certificate2 başlatır.

Özellikler

Archived	X.509 sertifikasının arşivlendiğini belirten bir değer alır veya ayarlar.
Extensions	Nesne koleksiyonunu X509Extension alır.
FriendlyName	Bir sertifika için ilişkili diğer adı alır veya ayarlar.
Handle	Yönetilmeyen PCCERT_CONTEXT bir yapı tarafından açıklanan Microsoft Şifreleme API'si sertifika bağlamının tanıtıcısını alır. (Devralındığı yer: X509Certificate)
HasPrivateKey	Bir nesnenin özel anahtar içerip içermediğini X509Certificate2 belirten bir değer alır.
Issuer	X.509v3 sertifikasını veren sertifika yetkilisinin adını alır. (Devralındığı yer: X509Certificate)
IssuerName	Sertifikayı verenin ayırt edici adını alır.
NotAfter	Sertifikanın artık geçerli olmadığı tarihi yerel saatle alır.
NotBefore	Sertifikanın geçerli olduğu yerel saat içindeki tarihi alır.
PrivateKey	Geçersiz. Sertifikayla ilişkili özel anahtarı temsil eden nesneyi alır veya ayarlar AsymmetricAlgorithm .
PublicKey	Sertifikayla ilişkilendirilmiş bir PublicKey nesneyi alır.
RawData	Sertifikanın ham X.509 genel verilerini alır.
RawDataMemory	Sertifikanın ham X.509 genel verilerini alır.
SerialNumber	Bir sertifikanın seri numarasını büyük endian onaltılık dize olarak alır.
SerialNumberBytes	Sertifikanın seri numarasının büyük endian gösterimini alır. (Devralındığı yer: X509Certificate)
SignatureAlgorithm	Sertifikanın imzasını oluşturmak için kullanılan algoritmayı alır.
Subject	Sertifikadan konu ayırt edici adını alır. (Devralındığı yer: X509Certificate)
SubjectName	Sertifikadan konu ayırt edici adını alır.
Thumbprint	Sertifikanın parmak izini alır.
Version	Sertifikanın X.509 biçimli sürümünü alır.

Yöntemler

CopyWithPrivateKey(ECDiffieHellman)	Özel anahtarı sertifikanın ortak anahtarıyla birleştirerek ECDiffieHellman yeni bir ECDiffieHellman sertifikası oluşturur.
CreateFromEncryptedPem(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	RFC 7468 PEM ile kodlanmış sertifika ve parola korumalı özel anahtarın içeriğinden yeni bir X509 sertifikası oluşturur.
CreateFromEncryptedPemFile(String, ReadOnlySpan<Char>, String)	RFC 7468 PEM ile kodlanmış sertifikanın ve parola korumalı özel anahtarın dosya içeriğinden yeni bir X509 sertifikası oluşturur.
CreateFromPem(ReadOnlySpan<Char>)	RFC 7468 PEM ile kodlanmış bir sertifikanın içeriğinden yeni bir X509 sertifikası oluşturur.
CreateFromPem(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	RFC 7468 PEM kodlu sertifikanın ve özel anahtarın içeriğinden yeni bir X509 sertifikası oluşturur.
CreateFromPemFile(String, String)	RFC 7468 PEM ile kodlanmış sertifikanın ve özel anahtarın dosya içeriğinden yeni bir X509 sertifikası oluşturur.
Dispose()	Geçerli X509Certificate nesne tarafından kullanılan tüm kaynakları serbest bırakır. (Devralındığı yer: X509Certificate)
Dispose(Boolean)	Bunun X509Certificate tarafından kullanılan tüm yönetilmeyen kaynakları serbest bırakır ve isteğe bağlı olarak yönetilen kaynakları serbest bırakır. (Devralındığı yer: X509Certificate)
Equals(Object)	Eşitlik için iki X509Certificate nesneyi karşılaştırır. (Devralındığı yer: X509Certificate)
Equals(X509Certificate)	Eşitlik için iki X509Certificate nesneyi karşılaştırır. (Devralındığı yer: X509Certificate)
Export(X509ContentType)	Geçerli X509Certificate nesneyi değerlerden biri tarafından açıklanan biçimde bir bayt dizisine X509ContentType aktarır. (Devralındığı yer: X509Certificate)
Export(X509ContentType, SecureString)	Belirtilen biçimi ve parolayı kullanarak geçerli X509Certificate nesneyi bir bayt dizisine aktarır. (Devralındığı yer: X509Certificate)
Export(X509ContentType, String)	Geçerli X509Certificate nesneyi değerlerden biri X509ContentType tarafından tanımlanan biçimde ve belirtilen parolayı kullanarak bayt dizisine aktarır. (Devralındığı yer: X509Certificate)
ExportCertificatePem()	GENEL X.509 sertifikasını PEM olarak kodlanmış olarak dışarı aktarır.
GetCertContentType(Byte[])	Bayt dizisinde bulunan sertifika türünü gösterir.
GetCertContentType(ReadOnlySpan<Byte>)	Sağlanan verilerde yer alan sertifika türünü gösterir.
GetCertContentType(String)	Bir dosyada bulunan sertifika türünü gösterir.
GetCertHash()	X.509v3 sertifikasının karma değerini bayt dizisi olarak döndürür. (Devralındığı yer: X509Certificate)
GetCertHash(HashAlgorithmName)	Belirtilen şifreleme karma algoritması kullanılarak hesaplanan X.509v3 sertifikasının karma değerini döndürür. (Devralındığı yer: X509Certificate)
GetCertHashString()	X.509v3 sertifikasının SHA1 karma değerini onaltılık dize olarak döndürür. (Devralındığı yer: X509Certificate)
GetCertHashString(HashAlgorithmName)	Belirtilen şifreleme karma algoritması kullanılarak hesaplanan X.509v3 sertifikasının karma değerini içeren onaltılık bir dize döndürür. (Devralındığı yer: X509Certificate)
GetECDiffieHellmanPrivateKey()	Bu sertifikadan ECDiffieHellman özel anahtarı alır.
GetECDiffieHellmanPublicKey()	Bu sertifikadan ECDiffieHellman ortak anahtarı alır.
GetEffectiveDateString()	Bu X.509v3 sertifikasının geçerlilik tarihini döndürür. (Devralındığı yer: X509Certificate)
GetExpirationDateString()	Bu X.509v3 sertifikasının sona erme tarihini döndürür. (Devralındığı yer: X509Certificate)
GetFormat()	Bu X.509v3 sertifikasının biçiminin adını döndürür. (Devralındığı yer: X509Certificate)
GetHashCode()	X.509v3 sertifikasının karma kodunu tamsayı olarak döndürür. (Devralındığı yer: X509Certificate)
GetIssuerName()	Geçersiz. X.509v3 sertifikasını veren sertifika yetkilisinin adını döndürür. (Devralındığı yer: X509Certificate)
GetKeyAlgorithm()	Bu X.509v3 sertifikasının anahtar algoritması bilgilerini dize olarak döndürür. (Devralındığı yer: X509Certificate)
GetKeyAlgorithmParameters()	X.509v3 sertifikasının anahtar algoritması parametrelerini bayt dizisi olarak döndürür. (Devralındığı yer: X509Certificate)
GetKeyAlgorithmParametersString()	X.509v3 sertifikasının anahtar algoritması parametrelerini onaltılık dize olarak döndürür. (Devralındığı yer: X509Certificate)
GetName()	Geçersiz. Sertifikanın verildiği sorumlunun adını döndürür. (Devralındığı yer: X509Certificate)
GetNameInfo(X509NameType, Boolean)	Sertifikadan konu ve veren adlarını alır.
GetPublicKey()	X.509v3 sertifikasının ortak anahtarını bayt dizisi olarak döndürür. (Devralındığı yer: X509Certificate)
GetPublicKeyString()	X.509v3 sertifikasının ortak anahtarını onaltılık dize olarak döndürür. (Devralındığı yer: X509Certificate)
GetRawCertData()	X.509v3 sertifikasının tamamı için ham verileri bayt dizisi olarak döndürür. (Devralındığı yer: X509Certificate)
GetRawCertDataString()	X.509v3 sertifikasının tamamının ham verilerini onaltılık dize olarak döndürür. (Devralındığı yer: X509Certificate)
GetSerialNumber()	X.509v3 sertifikasının seri numarasını küçük endian sırada bayt dizisi olarak döndürür. (Devralındığı yer: X509Certificate)
GetSerialNumberString()	X.509v3 sertifikasının seri numarasını küçük endian onaltılık dize olarak döndürür. (Devralındığı yer: X509Certificate)
GetType()	Type Geçerli örneğini alır. (Devralındığı yer: Object)
Import(Byte[])	Geçersiz. Bir X509Certificate2 nesneyi bayt dizisinden alınan verilerle doldurur.
Import(Byte[], SecureString, X509KeyStorageFlags)	Geçersiz. Bir X509Certificate2 bayt dizisinden, paroladan ve anahtar depolama bayrağından verileri kullanarak bir nesneyi doldurur.
Import(Byte[], String, X509KeyStorageFlags)	Geçersiz. Bir X509Certificate2 bayt dizisinden verileri, parolayı ve özel anahtarın nasıl içeri aktarılacağını belirlemek için bayrakları kullanarak bir nesneyi doldurur.
Import(String)	Geçersiz. Bir X509Certificate2 nesneyi sertifika dosyasındaki bilgilerle doldurur.
Import(String, SecureString, X509KeyStorageFlags)	Geçersiz. Bir X509Certificate2 nesneyi sertifika dosyasından, paroladan ve anahtar depolama bayrağından alınan bilgilerle doldurur.
Import(String, String, X509KeyStorageFlags)	Geçersiz. Bir X509Certificate2 nesneyi bir sertifika dosyasından, paroladan ve X509KeyStorageFlags değerden alınan bilgilerle doldurur.
MatchesHostname(String, Boolean, Boolean)	Sertifikanın sağlanan ana bilgisayar adıyla eşleşip eşleşmediğini denetler.
MemberwiseClone()	Geçerli Objectöğesinin sığ bir kopyasını oluşturur. (Devralındığı yer: Object)
Reset()	Bir X509Certificate2 nesnenin durumunu sıfırlar.
ToString()	Metin biçiminde bir X.509 sertifikası görüntüler.
ToString(Boolean)	Metin biçiminde bir X.509 sertifikası görüntüler.
TryExportCertificatePem(Span<Char>, Int32)	PEM olarak kodlanmış genel X.509 sertifikasını dışarı aktarmaya çalışır.
TryGetCertHash(HashAlgorithmName, Span<Byte>, Int32)	Sertifikanın kodlanmış gösterimini belirtilen karma algoritmayla karma oluşturarak sertifika için bir "parmak izi" üretmeye çalışır. (Devralındığı yer: X509Certificate)
Verify()	Temel doğrulama ilkesini kullanarak X.509 zincir doğrulaması gerçekleştirir.

Belirtik Arabirim Kullanımları

IDeserializationCallback.OnDeserialization(Object)	arabirimini ISerializable uygular ve seri durumdan çıkarma işlemi tamamlandığında seri durumdan çıkarma olayı tarafından geri çağrılır. (Devralındığı yer: X509Certificate)
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	Geçerli X509Certificate nesnenin bir örneğini yeniden oluşturmak için gereken tüm verilerle serileştirme bilgilerini alır. (Devralındığı yer: X509Certificate)

Uzantı Metotları

CopyWithPrivateKey(X509Certificate2, DSA)	Yeni bir DSA sertifikası oluşturmak için özel anahtarı sertifikanın DSA ortak anahtarıyla birleştirir.
GetDSAPrivateKey(X509Certificate2)	DSA özel anahtarı'ndan X509Certificate2alır.
GetDSAPublicKey(X509Certificate2)	DSA ortak anahtarını içinden X509Certificate2alır.
CopyWithPrivateKey(X509Certificate2, ECDsa)	Yeni bir ECDSA sertifikası oluşturmak için özel anahtarı sertifikanın ECDsa ortak anahtarıyla birleştirir.
GetECDsaPrivateKey(X509Certificate2)	Sertifikadan ECDsaX509Certificate2 özel anahtarı alır.
GetECDsaPublicKey(X509Certificate2)	Sertifikadan ECDsaX509Certificate2 ortak anahtarı alır.
CopyWithPrivateKey(X509Certificate2, RSA)	Yeni bir RSA sertifikası oluşturmak için özel anahtarı bir RSA sertifikanın ortak anahtarıyla birleştirir.
GetRSAPrivateKey(X509Certificate2)	RSA özel anahtarı'ndan X509Certificate2alır.
GetRSAPublicKey(X509Certificate2)	RSA ortak anahtarını içinden X509Certificate2alır.