X509Certificate2 Classe

Definizione

Spazio dei nomi:

System.Security.Cryptography.X509Certificates

Assembly:

System.Security.Cryptography.dll

Origine:

X509Certificate2.cs

Rappresenta un certificato 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

Ereditarietà

Object

X509Certificate

X509Certificate2

Esempio

Nell'esempio seguente viene illustrato come usare un X509Certificate2 oggetto per crittografare e decrittografare un file.

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

Nell'esempio seguente viene creato un eseguibile della riga di comando che accetta un file di certificato come argomento e stampa varie proprietà del certificato nella 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

Commenti

La struttura X.509 ha avuto origine nei gruppi di lavoro International Organization for Standardization (ISO). Questa struttura può essere usata per rappresentare vari tipi di informazioni, tra cui attributi di identità, diritto e titolare (autorizzazioni, età, sesso, posizione, affiliazione e così via). Anche se le specifiche ISO sono più informative sulla struttura stessa, la X509Certificate2 classe è progettata per modellare gli scenari di utilizzo definiti nelle specifiche rilasciate dal gruppo di lavoro Internet Engineering Task Force (IETF) Public Key Infrastructure, X.509 (PKIX). La più informativa di queste specifiche è RFC 3280, "Certificato e elenco di revoche di certificati (CRL) Profile".

Importante

A partire da .NET Framework 4.6, questo tipo implementa l'interfaccia IDisposable . Dopo aver utilizzato il tipo, è necessario eliminarlo direttamente o indirettamente. Per eliminare direttamente il tipo, chiamare il metodo Dispose in un blocco try/catch. Per eliminarlo indirettamente, utilizzare un costrutto di linguaggio come ad esempio using in C# o Using in Visual Basic. Per altre informazioni, vedere la sezione "Uso di un oggetto che implementa IDisposable" nell'argomento relativo all'interfaccia IDisposable.

Per le app destinate a .NET Framework 4.5.2 e versioni precedenti, la X509Certificate2 classe non implementa l'interfaccia IDisposable e pertanto non dispone di un Dispose metodo.

Costruttori

X509Certificate2()	Obsoleti. Inizializza una nuova istanza della classe X509Certificate2.
X509Certificate2(Byte[])	Inizializza una nuova istanza della classe X509Certificate2 utilizzando le informazioni ottenute da una matrice di byte.
X509Certificate2(Byte[], SecureString)	Inizializza una nuova istanza della classe X509Certificate2 usando una matrice di byte e una password.
X509Certificate2(Byte[], SecureString, X509KeyStorageFlags)	Inizializza una nuova istanza della classe X509Certificate2 usando una matrice di byte, una password e un flag di archiviazione delle chiavi.
X509Certificate2(Byte[], String)	Inizializza una nuova istanza della classe X509Certificate2 usando una matrice di byte e una password.
X509Certificate2(Byte[], String, X509KeyStorageFlags)	Inizializza una nuova istanza della classe X509Certificate2 usando una matrice di byte, una password e un flag di archiviazione delle chiavi.
X509Certificate2(IntPtr)	Inizializza una nuova istanza della classe X509Certificate2 utilizzando un handle non gestito.
X509Certificate2(ReadOnlySpan<Byte>)	Inizializza una nuova istanza della classe X509Certificate2 dai dati del certificato.
X509Certificate2(ReadOnlySpan<Byte>, ReadOnlySpan<Char>, X509KeyStorageFlags)	Inizializza una nuova istanza della classe X509Certificate2 usando i dati del certificato, una password e flag di archiviazione delle chiavi.
X509Certificate2(SerializationInfo, StreamingContext)	Obsoleti. Inizializza una nuova istanza della classe X509Certificate2 utilizzando le informazioni di serializzazione e del contesto di flusso specificate.
X509Certificate2(String)	Inizializza una nuova istanza della classe X509Certificate2 tramite un nome di file di certificato.
X509Certificate2(String, ReadOnlySpan<Char>, X509KeyStorageFlags)	Inizializza una nuova istanza della classe X509Certificate2 usando un nome di file di certificato, una password e un flag di archiviazione delle chiavi.
X509Certificate2(String, SecureString)	Inizializza una nuova istanza della classe X509Certificate2 usando un nome di file di certificato e una password.
X509Certificate2(String, SecureString, X509KeyStorageFlags)	Inizializza una nuova istanza della classe X509Certificate2 usando un nome di file di certificato, una password e un flag di archiviazione delle chiavi.
X509Certificate2(String, String)	Inizializza una nuova istanza della classe X509Certificate2 utilizzando un nome di file di certificato e una password necessaria per accedere al certificato.
X509Certificate2(String, String, X509KeyStorageFlags)	Inizializza una nuova istanza della classe X509Certificate2 utilizzando un nome di file di certificato, una password necessaria per accedere al certificato e un flag di archiviazione delle chiavi.
X509Certificate2(X509Certificate)	Inizializza una nuova istanza della classe X509Certificate2 utilizzando un oggetto X509Certificate.

Proprietà

Archived	Ottiene o imposta un valore che indica che un certificato X.509 è archiviato.
Extensions	Ottiene una raccolta di oggetti X509Extension.
FriendlyName	Ottiene o imposta l'alias associato a un certificato.
Handle	Ottiene un handle per un contesto di certificato dell'API di crittografia Microsoft descritto da una struttura PCCERT_CONTEXT non gestita. (Ereditato da X509Certificate)
HasPrivateKey	Ottiene un valore che indica se un oggetto X509Certificate2 contiene una chiave privata.
Issuer	Ottiene il nome dell'autorità di certificazione che ha emesso il certificato X.509v3. (Ereditato da X509Certificate)
IssuerName	Ottiene il nome distinto dell'autorità emittente del certificato.
NotAfter	Ottiene la data locale dopo la quale il certificato non è più valido.
NotBefore	Ottiene la data locale in cui il certificato diventa valido.
PrivateKey	Obsoleti. Ottiene o imposta l'oggetto AsymmetricAlgorithm che rappresenta la chiave privata associata a un certificato.
PublicKey	Ottiene un oggetto PublicKey associato a un certificato.
RawData	Ottiene i dati pubblici X.509 non elaborati di un certificato.
RawDataMemory	Ottiene i dati pubblici X.509 non elaborati di un certificato.
SerialNumber	Ottiene il numero di serie di un certificato sotto forma di stringa esadecimale Big Endian.
SerialNumberBytes	Ottiene la rappresentazione big-endian del numero di serie del certificato. (Ereditato da X509Certificate)
SignatureAlgorithm	Ottiene l'algoritmo utilizzato per creare la firma di un certificato.
Subject	Ottiene il nome distinto dell'oggetto dal certificato. (Ereditato da X509Certificate)
SubjectName	Ottiene il nome distinto del soggetto da un certificato.
Thumbprint	Ottiene l'identificazione personale di un certificato.
Version	Ottiene la versione del formato X.509 di un certificato.

Metodi

CopyWithPrivateKey(ECDiffieHellman)	Combina una chiave privata con la chiave pubblica di un ECDiffieHellman certificato per generare un nuovo certificato ECDiffieHellman.
CreateFromEncryptedPem(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Consente di creare un nuovo certificato X509 dal contenuto di un certificato RFC 7468 con codifica PEM e una chiave privata protetta da password.
CreateFromEncryptedPemFile(String, ReadOnlySpan<Char>, String)	Consente di creare un nuovo certificato X509 dal contenuto del file di un certificato RFC 7468 con codifica PEM e una chiave privata protetta da password.
CreateFromPem(ReadOnlySpan<Char>)	Crea un nuovo certificato X509 dal contenuto di un certificato con codifica PEM RFC 7468.
CreateFromPem(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Consente di creare un nuovo certificato X509 dal contenuto di un certificato RFC 7468 con codifica PEM e una chiave privata.
CreateFromPemFile(String, String)	Consente di creare un nuovo certificato X509 dal contenuto del file di un certificato RFC 7468 con codifica PEM e una chiave privata.
Dispose()	Rilascia tutte le risorse usate dall'oggetto X509Certificate corrente. (Ereditato da X509Certificate)
Dispose(Boolean)	Rilascia tutte le risorse non gestite usate da questo oggetto X509Certificate e, facoltativamente, le risorse gestite. (Ereditato da X509Certificate)
Equals(Object)	Confronta due oggetti X509Certificate per stabilirne l'uguaglianza. (Ereditato da X509Certificate)
Equals(X509Certificate)	Confronta due oggetti X509Certificate per stabilirne l'uguaglianza. (Ereditato da X509Certificate)
Export(X509ContentType)	Esporta l'oggetto X509Certificate corrente in una matrice di byte in un formato descritto da uno dei valori di X509ContentType. (Ereditato da X509Certificate)
Export(X509ContentType, SecureString)	Esporta l'oggetto X509Certificate corrente in una matrice di byte usando il formato specificato e una password. (Ereditato da X509Certificate)
Export(X509ContentType, String)	Esporta l'oggetto X509Certificate corrente in una matrice di byte in un formato descritto da uno dei valori di X509ContentType e usando la password specificata. (Ereditato da X509Certificate)
ExportCertificatePem()	Esporta il certificato X.509 pubblico, codificato come PEM.
GetCertContentType(Byte[])	Indica il tipo di certificato contenuto in una matrice di byte.
GetCertContentType(ReadOnlySpan<Byte>)	Indica il tipo di certificato contenuto nei dati specificati.
GetCertContentType(String)	Indica il tipo di certificato contenuto in un file.
GetCertHash()	Restituisce il valore hash del certificato X.509v3 sotto forma di matrice di byte. (Ereditato da X509Certificate)
GetCertHash(HashAlgorithmName)	Restituisce il valore hash per il certificato x.509v3 calcolato usando l'algoritmo di hash di crittografia specificato. (Ereditato da X509Certificate)
GetCertHashString()	Restituisce il valore hash SHA1 per il certificato X.509v3 come stringa esadecimale. (Ereditato da X509Certificate)
GetCertHashString(HashAlgorithmName)	Restituisce una stringa esadecimale contenente il valore hash per il certificato x.509v3 calcolato usando l'algoritmo di hash di crittografia specificato. (Ereditato da X509Certificate)
GetECDiffieHellmanPrivateKey()	Ottiene la ECDiffieHellman chiave privata da questo certificato.
GetECDiffieHellmanPublicKey()	Ottiene la ECDiffieHellman chiave pubblica da questo certificato.
GetEffectiveDateString()	Restituisce la data effettiva del certificato X.509v3. (Ereditato da X509Certificate)
GetExpirationDateString()	Restituisce la data di scadenza del certificato X.509v3. (Ereditato da X509Certificate)
GetFormat()	Restituisce il nome del formato di questo certificato X.509v3. (Ereditato da X509Certificate)
GetHashCode()	Restituisce il codice hash del certificato X.509v3 sotto forma di intero. (Ereditato da X509Certificate)
GetIssuerName()	Obsoleti. Restituisce il nome dell'autorità di certificazione che ha emesso il certificato X.509v3. (Ereditato da X509Certificate)
GetKeyAlgorithm()	Restituisce le informazioni dell'algoritmo a chiave per il certificato X.509v3 sotto forma di stringa. (Ereditato da X509Certificate)
GetKeyAlgorithmParameters()	Restituisce i parametri dell'algoritmo delle chiavi per il certificato X.509v3 sotto forma di matrice di byte. (Ereditato da X509Certificate)
GetKeyAlgorithmParametersString()	Restituisce i parametri dell'algoritmo a chiave per il certificato X.509v3 sotto forma di stringa esadecimale. (Ereditato da X509Certificate)
GetName()	Obsoleti. Restituisce il nome dell'oggetto Principal a cui è stato rilasciato il certificato. (Ereditato da X509Certificate)
GetNameInfo(X509NameType, Boolean)	Ottiene il soggetto e il nome dell'autorità emittente di un certificato.
GetPublicKey()	Restituisce la chiave pubblica del certificato X.509v3 sotto forma di matrice di byte. (Ereditato da X509Certificate)
GetPublicKeyString()	Restituisce la chiave pubblica del certificato X.509v3 sotto forma di stringa esadecimale. (Ereditato da X509Certificate)
GetRawCertData()	Restituisce i dati non elaborati dell'intero certificato X.509v3 sotto forma di matrice di byte. (Ereditato da X509Certificate)
GetRawCertDataString()	Restituisce i dati non elaborati dell'intero certificato X.509v3 sotto forma di stringa esadecimale. (Ereditato da X509Certificate)
GetSerialNumber()	Restituisce il numero di serie del certificato X.509v3 sotto forma di matrice di byte in ordine Little Endian. (Ereditato da X509Certificate)
GetSerialNumberString()	Restituisce il numero di serie del certificato X.509v3 sotto forma di stringa esadecimale Little Endian. (Ereditato da X509Certificate)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
Import(Byte[])	Obsoleti. Compila un oggetto X509Certificate2 con i dati di una matrice di byte.
Import(Byte[], SecureString, X509KeyStorageFlags)	Obsoleti. Popola un oggetto X509Certificate2 usando i dati di una matrice di byte, una password e un flag di archiviazione delle chiavi.
Import(Byte[], String, X509KeyStorageFlags)	Obsoleti. Compila un oggetto X509Certificate2 utilizzando i dati di una matrice di byte, una password e flag per determinare la modalità di importazione della chiave privata.
Import(String)	Obsoleti. Compila un oggetto X509Certificate2 con le informazioni di un file di certificato.
Import(String, SecureString, X509KeyStorageFlags)	Obsoleti. Popola un oggetto X509Certificate2 con le informazioni di un file di certificato, una password e un flag di archiviazione delle chiavi.
Import(String, String, X509KeyStorageFlags)	Obsoleti. Compila un oggetto X509Certificate2 con le informazioni di un file di certificato, una password e un valore X509KeyStorageFlags.
MatchesHostname(String, Boolean, Boolean)	Verifica se il certificato corrisponde al nome host specificato.
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
Reset()	Reimposta lo stato di un oggetto X509Certificate2.
ToString()	Visualizza un certificato X.509 in formato testo.
ToString(Boolean)	Visualizza un certificato X.509 in formato testo.
TryExportCertificatePem(Span<Char>, Int32)	Tenta di esportare il certificato X.509 pubblico, codificato come PEM.
TryGetCertHash(HashAlgorithmName, Span<Byte>, Int32)	Tenta di produrre un'identificazione personale per il certificato eseguendo l'hash della rappresentazione codificata del certificato con l'algoritmo hash specificato. (Ereditato da X509Certificate)
Verify()	Esegue la convalida di una catena X.509 mediante i criteri di convalida di base.

Implementazioni dell'interfaccia esplicita

IDeserializationCallback.OnDeserialization(Object)	Implementa l'interfaccia ISerializable e viene richiamato dall'evento di deserializzazione al termine della deserializzazione. (Ereditato da X509Certificate)
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	Ottiene le informazioni di serializzazione con tutti i dati necessari per ricreare un'istanza dell'oggetto X509Certificate corrente. (Ereditato da X509Certificate)

Metodi di estensione

CopyWithPrivateKey(X509Certificate2, DSA)	Combina una chiave privata con la chiave pubblica di un certificato DSA per generare un nuovo certificato DSA.
GetDSAPrivateKey(X509Certificate2)	Ottiene la chiave privata DSA da X509Certificate2.
GetDSAPublicKey(X509Certificate2)	Ottiene la chiave pubblica DSA dal certificato X509Certificate2.
CopyWithPrivateKey(X509Certificate2, ECDsa)	Combina una chiave privata con la chiave pubblica di un certificato ECDsa per generare un nuovo certificato ECDSA.
GetECDsaPrivateKey(X509Certificate2)	Ottiene la chiave privata ECDsa dal certificato X509Certificate2.
GetECDsaPublicKey(X509Certificate2)	Ottiene la chiave pubblica ECDsa dal certificato X509Certificate2.
CopyWithPrivateKey(X509Certificate2, RSA)	Combina una chiave privata con la chiave pubblica di un certificato RSA per generare un nuovo certificato RSA.
GetRSAPrivateKey(X509Certificate2)	Ottiene la chiave privata RSA da X509Certificate2.
GetRSAPublicKey(X509Certificate2)	Ottiene la chiave pubblica RSA dal certificato X509Certificate2.