X509Certificate2 Klasse

Definition

Namespace:

System.Security.Cryptography.X509Certificates

Assembly:

System.Security.Cryptography.dll

Quelle:

X509Certificate2.cs

Stellt ein X.509-Zertifikat dar.

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

Vererbung

Object

X509Certificate

X509Certificate2

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie ein X509Certificate2 -Objekt zum Verschlüsseln und Entschlüsseln einer Datei verwendet wird.

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

Im folgenden Beispiel wird eine ausführbare Befehlszeile erstellt, die eine Zertifikatdatei als Argument akzeptiert und verschiedene Zertifikateigenschaften in der Konsole ausgibt.

#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

Hinweise

Die X.509-Struktur stammt aus den Arbeitsgruppen der Internationalen Organisation für Normung (ISO). Diese Struktur kann verwendet werden, um verschiedene Arten von Informationen darzustellen, einschließlich Identitäts-, Berechtigungs- und Inhaberattributen (Berechtigungen, Alter, Geschlecht, Standort, Zugehörigkeit usw.). Obwohl die ISO-Spezifikationen für die Struktur selbst am informativsten sind, ist die X509Certificate2 Klasse dafür konzipiert, die Nutzungsszenarien zu modellieren, die in den Spezifikationen der Internet Engineering Task Force (IETF) Public Key Infrastructure, X.509 (PKIX) (Internet Engineering Task Force) definiert sind. Die informativste dieser Spezifikationen ist RFC 3280, "Certificate and Certificate Revocation List (CRL)-Profil".

Wichtig

Ab dem .NET Framework 4.6 implementiert dieser Typ die IDisposable Schnittstelle. Nach Abschluss der Verwendung sollten Sie den Typ entweder direkt oder indirekt löschen. Zum direkten Löschen des Typs rufen Sie seine Dispose-Methode in einem try/catch-Block auf. Zum indirekten Löschen verwenden Sie ein Sprachkonstrukt wie using (in C#) oder Using (in Visual Basic). Weitere Informationen finden Sie im Abschnitt „Verwenden eines Objekts, das IDisposable implementiert“ des Themas „Die IDisposable-Schnittstelle“.

Für Apps, die auf die .NET Framework 4.5.2 und frühere Versionen abzielen, implementiert die X509Certificate2 -Klasse die IDisposable Schnittstelle nicht und verfügt Dispose daher über keine -Methode.

Konstruktoren

X509Certificate2()	Veraltet. Initialisiert eine neue Instanz der X509Certificate2-Klasse.
X509Certificate2(Byte[])	Initialisiert mithilfe der Informationen aus einem Bytearray eine neue Instanz der X509Certificate2-Klasse.
X509Certificate2(Byte[], SecureString)	Initialisiert eine neue Instanz der X509Certificate2-Klasse mit einem Bytearray und einem Kennwort.
X509Certificate2(Byte[], SecureString, X509KeyStorageFlags)	Initialisiert eine neue Instanz der X509Certificate2-Klasse mit einem Bytearray, einem Kennwort und einem Schlüsselspeicherflag.
X509Certificate2(Byte[], String)	Initialisiert eine neue Instanz der X509Certificate2-Klasse mit einem Bytearray und einem Kennwort.
X509Certificate2(Byte[], String, X509KeyStorageFlags)	Initialisiert eine neue Instanz der X509Certificate2-Klasse mit einem Bytearray, einem Kennwort und einem Schlüsselspeicherflag.
X509Certificate2(IntPtr)	Initialisiert mithilfe eines nicht verwalteten Handles eine neue Instanz der X509Certificate2-Klasse.
X509Certificate2(ReadOnlySpan<Byte>)	Initialisiert eine neue Instanz der X509Certificate2-Klasse aus Zertifikatdaten.
X509Certificate2(ReadOnlySpan<Byte>, ReadOnlySpan<Char>, X509KeyStorageFlags)	Initialisiert aus Zertifikatsdaten, einem Kennwort und Schlüsselspeicherflags eine neue Instanz der X509Certificate2-Klasse.
X509Certificate2(SerializationInfo, StreamingContext)	Veraltet. Initialisiert eine neue Instanz der X509Certificate2-Klasse mit den angegebenen Serialisierungs- und Streamkontextinformationen.
X509Certificate2(String)	Initialisiert mithilfe eines Zertifikatsdateinamens eine neue Instanz der X509Certificate2-Klasse.
X509Certificate2(String, ReadOnlySpan<Char>, X509KeyStorageFlags)	Initialisiert mithilfe eines Zertifikatsdateinamens, eines Kennworts und eines Schlüsselspeicherflags eine neue Instanz der X509Certificate2-Klasse.
X509Certificate2(String, SecureString)	Initialisiert mithilfe eines Zertifikatsdateinamens und eines Kennworts eine neue Instanz der X509Certificate2-Klasse.
X509Certificate2(String, SecureString, X509KeyStorageFlags)	Initialisiert mithilfe eines Zertifikatsdateinamens, eines Kennworts und eines Schlüsselspeicherflags eine neue Instanz der X509Certificate2-Klasse.
X509Certificate2(String, String)	Initialisiert mithilfe des Zertifikatsdateinamens und eines für den Zugriff auf das Zertifikat verwendeten Kennworts eine neue Instanz der X509Certificate2-Klasse.
X509Certificate2(String, String, X509KeyStorageFlags)	Initialisiert mithilfe eines Zertifikatsdateinamens, eines für den Zugriff auf das Zertifikat verwendeten Kennworts und eines Schlüsselspeicherflags eine neue Instanz der X509Certificate2-Klasse.
X509Certificate2(X509Certificate)	Initialisiert eine neue Instanz der X509Certificate2-Klasse mit einem X509Certificate-Objekt.

Eigenschaften

Archived	Ruft einen Wert ab, der angibt, dass ein X.509-Zertifikat archiviert wird, oder legt diesen fest.
Extensions	Ruft eine Auflistung von X509Extension-Objekten ab.
FriendlyName	Ruft den einem Zertifikat zugeordneten Alias ab oder legt diesen fest.
Handle	Ruft ein Handle für einen von einer nicht verwalteten PCCERT_CONTEXT-Struktur beschriebenen Microsoft Cryptographic API-Zertifikatskontext ab. (Geerbt von X509Certificate)
HasPrivateKey	Ruft einen Wert ab, der angibt, ob ein X509Certificate2-Objekt einen privaten Schlüssel enthält.
Issuer	Ruft den Namen der Zertifizierungsstelle ab, die das X.509-Zertifikat (v.3) ausgestellt hat. (Geerbt von X509Certificate)
IssuerName	Ruft den Distinguished Name des Zertifikatausstellers ab.
NotAfter	Ruft das Datum in Ortszeit ab, ab dem ein Zertifikat nicht mehr gültig ist.
NotBefore	Ruft das Datum in Ortszeit ab, ab dem ein Zertifikat gültig wird.
PrivateKey	Veraltet. Ruft das AsymmetricAlgorithm-Objekt ab, das den einem Zertifikat zugeordneten privaten Schlüssel darstellt oder legt dieses fest.
PublicKey	Ruft ein PublicKey-Objekt ab, das einem Zertifikat zugeordnet ist.
RawData	Ruft die rohen öffentlichen X.509-Daten eines Zertifikats ab.
RawDataMemory	Ruft die rohen öffentlichen X.509-Daten eines Zertifikats ab.
SerialNumber	Ruft die Seriennummer eines Zertifikats als hexadezimale Big-Endian-Zeichenfolge ab.
SerialNumberBytes	Ruft die Big-Endian-Darstellung der Seriennummer des Zertifikats ab. (Geerbt von X509Certificate)
SignatureAlgorithm	Ruft den zum Erstellen der Signatur eines Zertifikats verwendeten Algorithmus ab.
Subject	Ruft den Distinguished Name für den Antragsteller aus dem Zertifikat ab. (Geerbt von X509Certificate)
SubjectName	Ruft den Distinguished Name des Antragstellers für das Zertifikat ab
Thumbprint	Ruft den Fingerabdruck eines Zertifikats ab.
Version	Ruft die X.509-Formatversion eines Zertifikats ab.

Methoden

CopyWithPrivateKey(ECDiffieHellman)	Kombiniert einen privaten Schlüssel mit dem öffentlichen Schlüssel eines ECDiffieHellman Zertifikats, um ein neues ECDiffieHellman-Zertifikat zu generieren.
CreateFromEncryptedPem(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Erstellt ein neues X509-Zertifikat aus dem Inhalt eines RFC 7468 PEM-codierten Zertifikats und einem kennwortgeschützten privaten Schlüssel.
CreateFromEncryptedPemFile(String, ReadOnlySpan<Char>, String)	Erstellt ein neues X509-Zertifikat aus dem Dateiinhalt eines RFC 7468 PEM-codierten Zertifikats und einem kennwortgeschützten privaten Schlüssel.
CreateFromPem(ReadOnlySpan<Char>)	Erstellt ein neues X509-Zertifikat aus dem Inhalt eines RFC 7468 PEM-codierten Zertifikats.
CreateFromPem(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Erstellt ein neues X509-Zertifikat aus dem Inhalt eines RFC 7468 PEM-codierten Zertifikats und einem privaten Schlüssel.
CreateFromPemFile(String, String)	Erstellt ein neues X509-Zertifikat aus dem Dateiinhalt eines RFC 7468 PEM-codierten Zertifikats und einem privaten Schlüssel.
Dispose()	Gibt alle vom aktuellen X509Certificate-Objekt verwendeten Ressourcen frei. (Geerbt von X509Certificate)
Dispose(Boolean)	Gibt alle von dieser X509Certificate verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. (Geerbt von X509Certificate)
Equals(Object)	Überprüft zwei X509Certificate-Objekte auf Gleichheit. (Geerbt von X509Certificate)
Equals(X509Certificate)	Überprüft zwei X509Certificate-Objekte auf Gleichheit. (Geerbt von X509Certificate)
Export(X509ContentType)	Exportiert das aktuelle X509Certificate-Objekt in einem durch einen der X509ContentType-Werte beschriebenen Format in ein Bytearray. (Geerbt von X509Certificate)
Export(X509ContentType, SecureString)	Exportiert das aktuelle X509Certificate-Objekt mit dem angegebenen Format und einem Kennwort in ein Bytearray. (Geerbt von X509Certificate)
Export(X509ContentType, String)	Exportiert das aktuelle X509Certificate-Objekt in einem durch einen der X509ContentType-Werte beschriebenen Format mithilfe des angegebenen Kennworts in ein Bytearray. (Geerbt von X509Certificate)
ExportCertificatePem()	Exportiert das öffentliche X.509-Zertifikat, codiert als PEM.
GetCertContentType(Byte[])	Gibt den Typ des in einem Bytearray enthaltenen Zertifikats an.
GetCertContentType(ReadOnlySpan<Byte>)	Gibt den Typ des in den bereitgestellten Daten enthaltenen Zertifikats an.
GetCertContentType(String)	Gibt den Typ des in einer Datei enthaltenen Zertifikats an.
GetCertHash()	Gibt den Hashwert für das X.509-Zertifikat (v.3) als Bytearray zurück. (Geerbt von X509Certificate)
GetCertHash(HashAlgorithmName)	Gibt den Hashwert für das X.509v3-Zertifikat zurück, das mit dem angegebenen kryptografischen Hashalgorithmus berechnet wird. (Geerbt von X509Certificate)
GetCertHashString()	Gibt den SHA1-Hashwert des X. 509v3-Zertifikats als hexadezimale Zeichenfolge zurück (Geerbt von X509Certificate)
GetCertHashString(HashAlgorithmName)	Gibt eine hexadezimale Zeichenfolge zurück, die den Hashwert für das X.509v3-Zertifikat enthält, das mit dem angegebenen kryptografischen Hashalgorithmus berechnet wird. (Geerbt von X509Certificate)
GetECDiffieHellmanPrivateKey()	Ruft den ECDiffieHellman privaten Schlüssel aus diesem Zertifikat ab.
GetECDiffieHellmanPublicKey()	Ruft den ECDiffieHellman öffentlichen Schlüssel aus diesem Zertifikat ab.
GetEffectiveDateString()	Gibt das Gültigkeitsdatum dieses X.509-Zertifikats (v.3) zurück. (Geerbt von X509Certificate)
GetExpirationDateString()	Gibt das Ablaufdatum dieses X.509-Zertifikats (v.3) zurück. (Geerbt von X509Certificate)
GetFormat()	Gibt den Formatnamen dieses X.509v3-Zertifikats zurück (Geerbt von X509Certificate)
GetHashCode()	Gibt den Hashcode für das X.509-Zertifikat (v.3) als ganze Zahl zurück. (Geerbt von X509Certificate)
GetIssuerName()	Veraltet. Gibt den Namen der Zertifizierungsstelle zurück, die das X.509-Zertifikat (v.3) ausgestellt hat. (Geerbt von X509Certificate)
GetKeyAlgorithm()	Gibt die Schlüsselalgorithmusinformationen zu diesem X.509v3-Zertifikat als Zeichenfolge zurück (Geerbt von X509Certificate)
GetKeyAlgorithmParameters()	Gibt die Schlüsselalgorithmusparameter für das X.509v3-Zertifikat als Bytearray zurück. (Geerbt von X509Certificate)
GetKeyAlgorithmParametersString()	Gibt die Schlüsselalgorithmusparameter für das X.509v3-Zertifikat als hexadezimale Zeichenfolge zurück (Geerbt von X509Certificate)
GetName()	Veraltet. Gibt den Namen des Prinzipals zurück, für den das Zertifikat ausgestellt wurde. (Geerbt von X509Certificate)
GetNameInfo(X509NameType, Boolean)	Ruft den die Namen des Zertifikatsantragstellers und des Zertifikatausstellers ab.
GetPublicKey()	Gibt den öffentlichen Schlüssel für das X.509v3-Zertifikat als Bytearray zurück. (Geerbt von X509Certificate)
GetPublicKeyString()	Gibt den öffentlichen Schlüssel für das X.509v3-Zertifikat als hexadezimale Zeichenfolge zurück. (Geerbt von X509Certificate)
GetRawCertData()	Gibt die Rohdaten für das gesamte X.509v3-Zertifikat als Bytearray zurück. (Geerbt von X509Certificate)
GetRawCertDataString()	Gibt die Rohdaten für das gesamte X.509v3-Zertifikat als hexadezimale Zeichenfolge zurück. (Geerbt von X509Certificate)
GetSerialNumber()	Gibt die Seriennummer des X.509v3-Zertifikats als Bytearray in Little-Endian-Reihenfolge zurück. (Geerbt von X509Certificate)
GetSerialNumberString()	Gibt die Seriennummer des X.509v3-Zertifikats als hexadezimale Little-Endian-Zeichenfolge zurück. (Geerbt von X509Certificate)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
Import(Byte[])	Veraltet. Füllt ein X509Certificate2-Objekt mit Daten aus einem Bytearray auf.
Import(Byte[], SecureString, X509KeyStorageFlags)	Veraltet. Füllt ein X509Certificate2-Objekt mithilfe der Daten aus einem Bytearray, eines Kennworts und eines Schlüsselspeicherflags auf.
Import(Byte[], String, X509KeyStorageFlags)	Veraltet. Füllt ein X509Certificate2-Objekt mithilfe der Daten aus einem Bytearray, eines Kennworts und von Flags auf, mit denen bestimmt werden kann, wie der private Schlüssel importiert wird.
Import(String)	Veraltet. Füllt ein X509Certificate2-Objekt mit Informationen aus einer Zertifikatsdatei auf.
Import(String, SecureString, X509KeyStorageFlags)	Veraltet. Füllt ein X509Certificate2-Objekt mit Informationen aus einer Zertifikatsdatei, einem Kennwort und einem Schlüsselspeicherflag auf.
Import(String, String, X509KeyStorageFlags)	Veraltet. Füllt ein X509Certificate2-Objekt mit Informationen aus einer Zertifikatsdatei, einem Kennwort und einem X509KeyStorageFlags-Wert auf.
MatchesHostname(String, Boolean, Boolean)	Überprüft, ob das Zertifikat mit dem angegebenen Hostnamen übereinstimmt.
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
Reset()	Setzt den Zustand eines X509Certificate2-Objekts zurück.
ToString()	Zeigt ein X.509-Zertifikat in Textformat an.
ToString(Boolean)	Zeigt ein X.509-Zertifikat in Textformat an.
TryExportCertificatePem(Span<Char>, Int32)	Versucht, das öffentliche X.509-Zertifikat zu exportieren, das als PEM codiert ist.
TryGetCertHash(HashAlgorithmName, Span<Byte>, Int32)	Versucht, einen „Fingerabdruck“ für das Zertifikat zu erzeugen, indem ein Hash der codierten Darstellung des Zertifikats mit dem angegebenen Hashalgorithmus generiert wird. (Geerbt von X509Certificate)
Verify()	Führt mithilfe von Basisvalidierungsrichtlinien eine Validierung von X.509-Ketten aus.

Explizite Schnittstellenimplementierungen

IDeserializationCallback.OnDeserialization(Object)	Implementiert die ISerializable-Schnittstelle und wird nach Abschluss der Deserialisierung durch das Deserialisierungsereignis aufgerufen. (Geerbt von X509Certificate)
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	Ruft Serialisierungsinformationen mit allen Daten ab, die für das erneute Erstellen einer Instanz des aktuellen X509Certificate-Objekts erforderlich sind. (Geerbt von X509Certificate)

Erweiterungsmethoden

CopyWithPrivateKey(X509Certificate2, DSA)	Kombiniert einen privaten Schlüssel mit dem öffentlichen Schlüssel eines DSA-Zertifikats zum Generieren eines neuen DSA-Zertifikats.
GetDSAPrivateKey(X509Certificate2)	Ruft den privaten DSA-Schlüssel aus dem X509Certificate2 ab.
GetDSAPublicKey(X509Certificate2)	Ruft den öffentlichen DSA-Schlüssel aus dem X509Certificate2 ab.
CopyWithPrivateKey(X509Certificate2, ECDsa)	Kombiniert einen privaten Schlüssel mit dem öffentlichen Schlüssel eines ECDsa-Zertifikats zum Generieren eines neuen ECDSA-Zertifikats.
GetECDsaPrivateKey(X509Certificate2)	Ruft den privaten Schlüssel ECDsa aus dem Zertifikat X509Certificate2 ab.
GetECDsaPublicKey(X509Certificate2)	Ruft den öffentlichen Schlüssel ECDsa aus dem Zertifikat X509Certificate2 ab.
CopyWithPrivateKey(X509Certificate2, RSA)	Kombiniert einen privaten Schlüssel mit dem öffentlichen Schlüssel eines RSA-Zertifikats zum Generieren eines neuen RSA-Zertifikats.
GetRSAPrivateKey(X509Certificate2)	Ruft den privaten RSA-Schlüssel aus dem X509Certificate2 ab.
GetRSAPublicKey(X509Certificate2)	Ruft den öffentlichen RSA-Schlüssel aus dem X509Certificate2 ab.