X509Certificate2 Classe

Definição

Namespace:

System.Security.Cryptography.X509Certificates

Assembly:

System.Security.Cryptography.dll

Origem:

X509Certificate2.cs

Representa um certificado X.509.

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

Herança

Object

X509Certificate

X509Certificate2

Exemplos

O exemplo a seguir demonstra como usar um X509Certificate2 objeto para criptografar e descriptografar um arquivo.

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

O exemplo a seguir cria um executável de linha de comando que usa um arquivo de certificado como argumento e imprime várias propriedades de certificado no console.

#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

Comentários

A estrutura X.509 originou-se nos grupos de trabalho da Organização Internacional para a Padronização (ISO). Essa estrutura pode ser usada para representar vários tipos de informações, incluindo atributos de identidade, direito e titular (permissões, idade, sexo, localização, afiliação e assim por diante). Embora as especificações ISO sejam mais informativas sobre a própria estrutura, a X509Certificate2 classe foi projetada para modelar os cenários de uso definidos nas especificações emitidas pelo grupo de trabalho IETF (Internet Engineering Task Force), X.509 (PKIX). A mais informativa dessas especificações é RFC 3280, "Certificado e Perfil de CRL (Lista de Certificados Revogados)".

Importante

A partir do .NET Framework 4.6, esse tipo implementa a IDisposable interface . Quando você terminar de usar o tipo, deverá descartá-lo direta ou indiretamente. Para descartar o tipo diretamente, chame o método Dispose dele em um bloco try/catch. Para descartá-lo indiretamente, use um constructo de linguagem como using ( em C#) ou Using (em Visual Basic). Saiba mais na seção "Como usar um objeto que implementa IDisposable" no tópico da interface IDisposable.

Para aplicativos direcionados ao .NET Framework 4.5.2 e versões anteriores, a X509Certificate2 classe não implementa a IDisposable interface e, portanto, não tem um Dispose método .

Construtores

X509Certificate2()	Obsoleto. Inicializa uma nova instância da classe X509Certificate2.
X509Certificate2(Byte[])	Inicializa uma nova instância da classe X509Certificate2 usando informações de uma matriz de bytes.
X509Certificate2(Byte[], SecureString)	Inicializa uma nova instância da classe X509Certificate2 usando uma matriz de bytes e uma senha.
X509Certificate2(Byte[], SecureString, X509KeyStorageFlags)	Inicializa uma nova instância da classe X509Certificate2 usando uma matriz de bytes, uma senha e um sinalizador de armazenamento de chaves.
X509Certificate2(Byte[], String)	Inicializa uma nova instância da classe X509Certificate2 usando uma matriz de bytes e uma senha.
X509Certificate2(Byte[], String, X509KeyStorageFlags)	Inicializa uma nova instância da classe X509Certificate2 usando uma matriz de bytes, uma senha e um sinalizador de armazenamento de chaves.
X509Certificate2(IntPtr)	Inicializa uma nova instância da classe X509Certificate2 usando um identificador não gerenciado.
X509Certificate2(ReadOnlySpan<Byte>)	Inicializa uma nova instância da classe X509Certificate2 a partir dos dados do certificado.
X509Certificate2(ReadOnlySpan<Byte>, ReadOnlySpan<Char>, X509KeyStorageFlags)	Inicializa uma nova instância da classe X509Certificate2 a partir dos dados do certificado, de uma senha e de sinalizadores de armazenamento de chave.
X509Certificate2(SerializationInfo, StreamingContext)	Obsoleto. Inicializa uma nova instância da classe X509Certificate2 usando as informações de contexto de fluxo e serialização fornecidas.
X509Certificate2(String)	Inicializa uma nova instância da classe X509Certificate2 usando um nome de arquivo de certificado.
X509Certificate2(String, ReadOnlySpan<Char>, X509KeyStorageFlags)	Inicializa uma nova instância da classe X509Certificate2 usando um nome de arquivo de certificado, uma senha e um sinalizador de armazenamento de chaves.
X509Certificate2(String, SecureString)	Inicializa uma nova instância da classe X509Certificate2 usando um nome de arquivo de certificado e uma senha.
X509Certificate2(String, SecureString, X509KeyStorageFlags)	Inicializa uma nova instância da classe X509Certificate2 usando um nome de arquivo de certificado, uma senha e um sinalizador de armazenamento de chaves.
X509Certificate2(String, String)	Inicializa uma nova instância de classe X509Certificate2 usando um nome de arquivo de certificado e uma senha usada para acessar o certificado.
X509Certificate2(String, String, X509KeyStorageFlags)	Inicializa uma nova instância da classe X509Certificate2 usando um nome de arquivo de certificado, uma senha usada para acessar o certificado e um sinalizador de armazenamento de chaves.
X509Certificate2(X509Certificate)	Inicializa uma nova instância da classe X509Certificate2 usando um objeto X509Certificate.

Propriedades

Archived	Obtém ou define um valor que indica que um certificado X.509 será arquivado.
Extensions	Obtém uma coleção de objetos X509Extension .
FriendlyName	Obtém ou define o alias associado para um certificado.
Handle	Obtém um identificador para um contexto de certificado da API Criptográfica da Microsoft descrito por uma estrutura PCCERT_CONTEXT não gerenciada. (Herdado de X509Certificate)
HasPrivateKey	Obtém um valor que indica se o objeto X509Certificate2 contém uma chave privada.
Issuer	Obtém o nome da autoridade de certificado que emitiu o certificado X.509v3. (Herdado de X509Certificate)
IssuerName	Obtém o nome diferenciado de um emissor do certificado.
NotAfter	Obtém a data no horário local depois da qual um certificado não é mais válido.
NotBefore	Obtém a data no horário local em que um certificado se torna válido.
PrivateKey	Obsoleto. Obtém ou define o objeto AsymmetricAlgorithm que representa a chave privada associada a um certificado.
PublicKey	Obtém um objeto PublicKey associado a um certificado.
RawData	Obtém os dados públicos brutos X.509 de um certificado.
RawDataMemory	Obtém os dados públicos brutos X.509 de um certificado.
SerialNumber	Obtém o número de série de um certificado como uma cadeia de caracteres hexadecimal big endian.
SerialNumberBytes	Obtém a representação big-endian do número de série do certificado. (Herdado de X509Certificate)
SignatureAlgorithm	Obtém o algoritmo usado para criar a assinatura de um certificado.
Subject	Obtém o nome diferenciado da entidade do certificado. (Herdado de X509Certificate)
SubjectName	Obtém o nome diferenciado da entidade de um certificado.
Thumbprint	Obtém a impressão digital de um certificado.
Version	Obtém a versão de formato X.509 de um certificado.

Métodos

CopyWithPrivateKey(ECDiffieHellman)	Combina uma chave privada com a chave pública de um ECDiffieHellman certificado para gerar um novo certificado ECDiffieHellman.
CreateFromEncryptedPem(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Cria um certificado X509 a partir do conteúdo de um certificado codificado por PEM do RFC 7468 e da chave privada protegida por senha.
CreateFromEncryptedPemFile(String, ReadOnlySpan<Char>, String)	Cria um certificado X509 a partir do conteúdo do arquivo de um certificado codificado por PEM do RFC 7468 e da chave privada protegida por senha.
CreateFromPem(ReadOnlySpan<Char>)	Cria um novo certificado X509 com base no conteúdo de um certificado codificado em PEM RFC 7468.
CreateFromPem(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Cria um certificado X509 a partir do conteúdo de um certificado codificado por PEM do RFC 7468 e da chave privada.
CreateFromPemFile(String, String)	Cria um certificado X509 a partir do conteúdo do arquivo de um certificado codificado por PEM do RFC 7468 e da chave privada.
Dispose()	Libera todos os recursos usados pelo objeto X509Certificate atual. (Herdado de X509Certificate)
Dispose(Boolean)	Libera todos os recursos não gerenciados usados por este X509Certificate e, opcionalmente, libera os recursos gerenciados. (Herdado de X509Certificate)
Equals(Object)	Compara dois objetos X509Certificate quanto à igualdade. (Herdado de X509Certificate)
Equals(X509Certificate)	Compara dois objetos X509Certificate quanto à igualdade. (Herdado de X509Certificate)
Export(X509ContentType)	Exporta o objeto X509Certificate atual para uma matriz de bytes em um formato descrito por um dos valores de X509ContentType. (Herdado de X509Certificate)
Export(X509ContentType, SecureString)	Exporta o objeto X509Certificate atual para uma matriz de bytes usando o formato especificado e uma senha. (Herdado de X509Certificate)
Export(X509ContentType, String)	Exporta o objeto X509Certificate atual para uma matriz de bytes em um formato descrito por um dos valores X509ContentType e com a senha especificada. (Herdado de X509Certificate)
ExportCertificatePem()	Exporta o certificado X.509 público, codificado como PEM.
GetCertContentType(Byte[])	Indica o tipo de certificado contido em uma matriz de bytes.
GetCertContentType(ReadOnlySpan<Byte>)	Indica o tipo de certificado contido nos dados fornecidos.
GetCertContentType(String)	Indica o tipo de certificado contido em um arquivo.
GetCertHash()	Retorna o valor do hash para o certificado x.509v3 como uma matriz de bytes. (Herdado de X509Certificate)
GetCertHash(HashAlgorithmName)	Retorna o valor de hash do certificado X.509v3 que é calculado usando o algoritmo de hash criptográfico especificado. (Herdado de X509Certificate)
GetCertHashString()	Retorna o valor de hash SHA1 do certificado X.509v3 como uma cadeia de caracteres hexadecimal. (Herdado de X509Certificate)
GetCertHashString(HashAlgorithmName)	Retorna uma cadeia de caracteres hexadecimal que contém o valor de hash do certificado X.509v3 calculado usando algoritmo de hash criptográfico especificado. (Herdado de X509Certificate)
GetECDiffieHellmanPrivateKey()	Obtém a ECDiffieHellman chave privada deste certificado.
GetECDiffieHellmanPublicKey()	Obtém a ECDiffieHellman chave pública deste certificado.
GetEffectiveDateString()	Retorna a data de efetivação deste certificado X.509v3. (Herdado de X509Certificate)
GetExpirationDateString()	Retorna a data de validade deste certificado X.509v3. (Herdado de X509Certificate)
GetFormat()	Retorna o nome do formato desse certificado X.509v3. (Herdado de X509Certificate)
GetHashCode()	Retorna o código hash do certificado X.509v3 como um inteiro. (Herdado de X509Certificate)
GetIssuerName()	Obsoleto. Retorna o nome da autoridade de certificação que emitiu o certificado X.509v3. (Herdado de X509Certificate)
GetKeyAlgorithm()	Retorna as informações de algoritmo de chave do certificado X.509v3 como uma cadeia de caracteres. (Herdado de X509Certificate)
GetKeyAlgorithmParameters()	Retorna os parâmetros de algoritmo de chave do certificado X.509v3 como uma matriz de bytes. (Herdado de X509Certificate)
GetKeyAlgorithmParametersString()	Retorna os parâmetros de algoritmo de chave do certificado X.509v3 como uma cadeia de caracteres hexadecimal. (Herdado de X509Certificate)
GetName()	Obsoleto. Retorna o nome da entidade de segurança para a qual o certificado foi emitido. (Herdado de X509Certificate)
GetNameInfo(X509NameType, Boolean)	Obtém os nomes da entidade e do emissor de um certificado.
GetPublicKey()	Retorna a chave pública para o certificado x.509v3 como uma matriz de bytes. (Herdado de X509Certificate)
GetPublicKeyString()	Retorna a chave pública do certificado X.509v3 como uma cadeia de caracteres hexadecimal. (Herdado de X509Certificate)
GetRawCertData()	Retorna os dados brutos de todo o certificado X.509v3 como uma matriz de bytes. (Herdado de X509Certificate)
GetRawCertDataString()	Retorna os dados brutos do certificado X.509v3 como uma cadeia de caracteres hexadecimal. (Herdado de X509Certificate)
GetSerialNumber()	Retorna o número de série do certificado X.509v3 como uma matriz de bytes em ordem little endian. (Herdado de X509Certificate)
GetSerialNumberString()	Retorna o número de série do certificado X.509v3 como uma cadeia de caracteres hexadecimal little endian. (Herdado de X509Certificate)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
Import(Byte[])	Obsoleto. Preenche um objeto X509Certificate2 com os dados de uma matriz de bytes.
Import(Byte[], SecureString, X509KeyStorageFlags)	Obsoleto. Popula um objeto X509Certificate2 usando dados de uma matriz de bytes, uma senha e um sinalizador de armazenamento de chaves.
Import(Byte[], String, X509KeyStorageFlags)	Obsoleto. Preenche um objeto X509Certificate2 usando dados de uma matriz de bytes, uma senha e sinalizadores para determinar como importar a chave privada.
Import(String)	Obsoleto. Preenche um objeto X509Certificate2 com informações de um arquivo de certificado.
Import(String, SecureString, X509KeyStorageFlags)	Obsoleto. Popula um objeto X509Certificate2 com informações de um arquivo de certificado, uma senha e um sinalizador de armazenamento de chaves.
Import(String, String, X509KeyStorageFlags)	Obsoleto. Preenche um objeto X509Certificate2 com informações de um arquivo de certificado, uma senha e um valor X509KeyStorageFlags.
MatchesHostname(String, Boolean, Boolean)	Verifica se o certificado corresponde ao nome do host fornecido.
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
Reset()	Redefine o estado de um objeto X509Certificate2.
ToString()	Exibe um certificado X.509 no formato de texto.
ToString(Boolean)	Exibe um certificado X.509 no formato de texto.
TryExportCertificatePem(Span<Char>, Int32)	Tenta exportar o certificado X.509 público, codificado como PEM.
TryGetCertHash(HashAlgorithmName, Span<Byte>, Int32)	Tenta produzir uma "impressão digital" para o certificado por meio do hash da representação codificada do certificado com o algoritmo de hash especificado. (Herdado de X509Certificate)
Verify()	Executa uma validação de cadeia X.509 usando a política de validação básica.

Implantações explícitas de interface

IDeserializationCallback.OnDeserialization(Object)	Implementa a interface ISerializable e é chamado novamente pelo evento de desserialização quando a desserialização é concluída. (Herdado de X509Certificate)
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	Obtém informações de serialização com todos os dados necessários para recriar uma instância do objeto X509Certificate atual. (Herdado de X509Certificate)

Métodos de Extensão

CopyWithPrivateKey(X509Certificate2, DSA)	Combina uma chave privada com a chave pública de um certificado DSA para gerar um novo certificado DSA.
GetDSAPrivateKey(X509Certificate2)	Obtém a chave privada DSA do X509Certificate2.
GetDSAPublicKey(X509Certificate2)	Obtém a chave pública DSA do X509Certificate2.
CopyWithPrivateKey(X509Certificate2, ECDsa)	Combina uma chave privada com a chave pública de um certificado ECDsa para gerar um novo certificado ECDSA.
GetECDsaPrivateKey(X509Certificate2)	Obtém a chave privada ECDsa do certificado X509Certificate2.
GetECDsaPublicKey(X509Certificate2)	Obtém a chave pública ECDsa do certificado X509Certificate2.
CopyWithPrivateKey(X509Certificate2, RSA)	Combina uma chave privada com a chave pública de um certificado RSA para gerar um novo certificado RSA.
GetRSAPrivateKey(X509Certificate2)	Obtém a chave privada RSA do X509Certificate2.
GetRSAPublicKey(X509Certificate2)	Obtém a chave pública RSA do X509Certificate2.