X509Certificate2 클래스

정의

X.509 인증서를 나타냅니다.

public ref class X509Certificate2 : System::Security::Cryptography::X509Certificates::X509Certificate
public class X509Certificate2 : System.Security.Cryptography.X509Certificates.X509Certificate
[System.Serializable]
public class X509Certificate2 : System.Security.Cryptography.X509Certificates.X509Certificate
type X509Certificate2 = class
    inherit X509Certificate
[<System.Serializable>]
type X509Certificate2 = class
    inherit X509Certificate
Public Class X509Certificate2
Inherits X509Certificate
상속
X509Certificate2
특성

예제

다음 예제에서는 개체를 X509Certificate2 사용하여 파일을 암호화하고 암호를 해독하는 방법을 보여 줍니다.

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

다음 예제에서는 인증서 파일을 인수로 사용하고 다양한 인증서 속성을 콘솔에 출력하는 명령줄 실행 파일을 만듭니다.

#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
        {
            X509Certificate2 x509 = new X509Certificate2();
            //Create X509Certificate2 object from .cer file.
            byte[] rawData = 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.
            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

설명

X.509 구조는 ISO(국제 표준화 기구) 작업 그룹에서 시작되었습니다. 이 구조는 ID, 자격 및 소유자 특성(권한, 연령, 성별, 위치, 소속 등)을 비롯한 다양한 유형의 정보를 나타내는 데 사용할 수 있습니다. ISO 사양은 구조 자체에 대해 가장 유익하지만 클래스는 IETF(Internet Engineering Task Force) 공개 키 인프라, X509Certificate2 X.509(PKIX) 작업 그룹에서 발급한 사양에 정의된 사용 시나리오를 모델링하도록 설계되었습니다. 이러한 사양의 가장 많은 정보는 RFC 3280, "CRL(인증서 및 인증서 해지 목록) 프로필"입니다.

중요

.NET Framework 4.6부터 이 형식은 인터페이스를 IDisposable 구현합니다. 형식을 사용 하 여 마쳤으면 직접 또는 간접적으로의 삭제 해야 있습니다. 직접 형식의 dispose 호출 해당 Dispose 의 메서드를 try/catch 블록입니다. 삭제 하지 직접, 언어 구문 같은 사용 using (C#에서) 또는 Using (Visual Basic에서는). 자세한 내용은 "를 사용 하는 개체는 구현 IDisposable" 섹션을 참조 하세요.를 IDisposable 인터페이스 항목입니다.

.NET Framework 4.5.2 및 이전 버전을 대상으로 하는 앱의 X509Certificate2 경우 클래스는 인터페이스를 IDisposable 구현하지 않으므로 메서드가 Dispose 없습니다.

생성자

X509Certificate2()
사용되지 않음.

X509Certificate2 클래스의 새 인스턴스를 초기화합니다.

X509Certificate2(Byte[])

바이트 배열의 정보를 사용하여 X509Certificate2 클래스의 새 인스턴스를 초기화합니다.

X509Certificate2(Byte[], SecureString)

바이트 배열 및 암호를 사용하여 X509Certificate2 클래스의 새 인스턴스를 초기화합니다.

X509Certificate2(Byte[], SecureString, X509KeyStorageFlags)

바이트 배열, 암호 및 키 스토리지 플래그를 사용하여 X509Certificate2 클래스의 새 인스턴스를 초기화합니다.

X509Certificate2(Byte[], String)

바이트 배열 및 암호를 사용하여 X509Certificate2 클래스의 새 인스턴스를 초기화합니다.

X509Certificate2(Byte[], String, X509KeyStorageFlags)

바이트 배열, 암호 및 키 스토리지 플래그를 사용하여 X509Certificate2 클래스의 새 인스턴스를 초기화합니다.

X509Certificate2(IntPtr)

관리되지 않는 핸들을 사용하여 X509Certificate2 클래스의 새 인스턴스를 초기화합니다.

X509Certificate2(ReadOnlySpan<Byte>)

인증서 데이터에서 X509Certificate2 클래스의 새 인스턴스를 초기화합니다.

X509Certificate2(ReadOnlySpan<Byte>, ReadOnlySpan<Char>, X509KeyStorageFlags)

인증서 데이터, 암호 및 키 스토리지 플래그에서 X509Certificate2 클래스의 새 인스턴스를 초기화합니다.

X509Certificate2(SerializationInfo, StreamingContext)
사용되지 않음.

지정된 serialization과 스트림 컨텍스트 정보를 사용하여 X509Certificate2 클래스의 새 인스턴스를 초기화합니다.

X509Certificate2(String)

인증서 파일 이름을 사용하여 X509Certificate2 클래스의 새 인스턴스를 초기화합니다.

X509Certificate2(String, ReadOnlySpan<Char>, X509KeyStorageFlags)

인증서 파일 이름, 암호 및 키 스토리지 플래그를 사용하여 X509Certificate2 클래스의 새 인스턴스를 초기화합니다.

X509Certificate2(String, SecureString)

인증서 파일 이름 및 암호를 사용하여 X509Certificate2 클래스의 새 인스턴스를 초기화합니다.

X509Certificate2(String, SecureString, X509KeyStorageFlags)

인증서 파일 이름, 암호 및 키 스토리지 플래그를 사용하여 X509Certificate2 클래스의 새 인스턴스를 초기화합니다.

X509Certificate2(String, String)

인증서 파일 이름과 인증서 액세스에 사용되는 암호를 사용하여 X509Certificate2 클래스의 새 인스턴스를 초기화합니다.

X509Certificate2(String, String, X509KeyStorageFlags)

인증서 파일 이름, 인증서 액세스에 사용되는 암호 및 키 스토리지 플래그를 사용하여 X509Certificate2 클래스의 새 인스턴스를 초기화합니다.

X509Certificate2(X509Certificate)

X509Certificate2 개체를 사용하여 X509Certificate 클래스의 새 인스턴스를 초기화합니다.

속성

Archived

X.509 인증서가 보관됨을 나타내는 값을 가져오거나 설정합니다.

Extensions

X509Extension 개체의 컬렉션입니다.

FriendlyName

인증서의 관련 별칭을 가져오거나 설정합니다.

Handle

비관리 PCCERT_CONTEXT 구조체로 설명되는 Microsoft 암호화 API 인증서 컨텍스트에 대한 핸들을 가져옵니다.

(다음에서 상속됨 X509Certificate)
HasPrivateKey

X509Certificate2 개체에 프라이빗 키가 들어 있는지 여부를 나타내는 값을 가져옵니다.

Issuer

X.509v3 인증서를 발급한 인증 기관의 이름을 가져옵니다.

(다음에서 상속됨 X509Certificate)
IssuerName

인증서 발급자의 고유 이름을 가져옵니다.

NotAfter

인증서가 더 이상 유효하지 않은 현지 시간 날짜를 가져옵니다.

NotBefore

인증서를 사용할 수 있게 되는 현지 시간 날짜를 가져옵니다.

PrivateKey
사용되지 않음.

인증서와 관련된 프라이빗 키를 나타내는 AsymmetricAlgorithm 개체를 가져오거나 설정합니다.

PublicKey

인증서와 관련된 PublicKey 개체를 가져옵니다.

RawData

인증서의 원시 데이터를 가져옵니다.

RawDataMemory

인증서의 원시 데이터를 가져옵니다.

SerialNumber

인증서의 일련 번호를 Big Endian 16진 문자열로 가져옵니다.

SerialNumberBytes

인증서 일련 번호의 big-endian 표현을 가져옵니다.

(다음에서 상속됨 X509Certificate)
SignatureAlgorithm

인증서의 서명을 만드는 데 사용하는 알고리즘을 가져옵니다.

Subject

인증서에서 구별된 주체 이름을 가져옵니다.

(다음에서 상속됨 X509Certificate)
SubjectName

인증서에서 주체 고유 이름을 가져옵니다.

Thumbprint

인증서의 지문을 가져옵니다.

Version

X.509 형식의 인증서 버전을 가져옵니다.

메서드

CopyWithPrivateKey(ECDiffieHellman)

프라이빗 키를 인증서의 ECDiffieHellman 공개 키와 결합하여 새 ECDiffieHellman 인증서를 생성합니다.

CreateFromEncryptedPem(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

RFC 7468 PEM으로 인코딩된 인증서 및 암호로 보호된 프라이빗 키의 내용에서 새 X509 인증서를 만듭니다.

CreateFromEncryptedPemFile(String, ReadOnlySpan<Char>, String)

RFC 7468 PEM으로 인코딩된 인증서 및 암호로 보호된 프라이빗 키의 파일 내용에서 새 X509 인증서를 만듭니다.

CreateFromPem(ReadOnlySpan<Char>)

RFC 7468 PEM으로 인코딩된 인증서의 내용에서 새 X509 인증서를 만듭니다.

CreateFromPem(ReadOnlySpan<Char>, ReadOnlySpan<Char>)

RFC 7468 PEM으로 인코딩된 인증서 및 프라이빗 키의 내용에서 새 X509 인증서를 만듭니다.

CreateFromPemFile(String, String)

RFC 7468 PEM으로 인코딩된 인증서 및 프라이빗 키의 파일 내용에서 새 X509 인증서를 만듭니다.

Dispose()

현재 X509Certificate 개체에서 사용하는 모든 리소스를 해제합니다.

(다음에서 상속됨 X509Certificate)
Dispose(Boolean)

X509Certificate에서 사용하는 관리되지 않는 모든 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다.

(다음에서 상속됨 X509Certificate)
Equals(Object)

X509Certificate 개체가 같은지 비교합니다.

(다음에서 상속됨 X509Certificate)
Equals(X509Certificate)

X509Certificate 개체가 같은지 비교합니다.

(다음에서 상속됨 X509Certificate)
Export(X509ContentType)

현재 X509Certificate 개체를 X509ContentType 값 중 하나로 설명되는 형식으로 바이트 배열로 내보냅니다.

(다음에서 상속됨 X509Certificate)
Export(X509ContentType, SecureString)

지정된 형식 및 암호를 사용하여 현재 X509Certificate 개체를 바이트 배열로 내보냅니다.

(다음에서 상속됨 X509Certificate)
Export(X509ContentType, String)

현재 X509Certificate 개체를 지정된 암호를 사용하여 X509ContentType 값 중 하나로 설명되는 형식으로 바이트 배열로 내보냅니다.

(다음에서 상속됨 X509Certificate)
ExportCertificatePem()

PEM으로 인코딩된 공용 X.509 인증서를 내보냅니다.

GetCertContentType(Byte[])

바이트 배열에 포함된 인증서 형식을 나타냅니다.

GetCertContentType(ReadOnlySpan<Byte>)

제공된 데이터에 포함된 인증서의 유형을 나타냅니다.

GetCertContentType(String)

파일에 포함된 인증서 형식을 나타냅니다.

GetCertHash()

X.509v3 인증서에 대한 해시 값을 바이트 배열로 반환합니다.

(다음에서 상속됨 X509Certificate)
GetCertHash(HashAlgorithmName)

지정된 암호화 해시 알고리즘을 사용하여 계산된 X.509v3 인증서에 대한 해시 값을 반환합니다.

(다음에서 상속됨 X509Certificate)
GetCertHashString()

X.509v3 인증서의 SHA1 해시 값을 16진수 문자열로 반환합니다.

(다음에서 상속됨 X509Certificate)
GetCertHashString(HashAlgorithmName)

지정된 암호화 해시 알고리즘을 사용하여 계산된 X.509v3 인증서에 대한 해시 값을 포함하는 16진수 문자열을 반환합니다.

(다음에서 상속됨 X509Certificate)
GetECDiffieHellmanPrivateKey()

이 인증서에서 ECDiffieHellman 프라이빗 키를 가져옵니다.

GetECDiffieHellmanPublicKey()

이 인증서에서 ECDiffieHellman 공개 키를 가져옵니다.

GetEffectiveDateString()

이 X.509v3 인증서의 개시 날짜를 반환합니다.

(다음에서 상속됨 X509Certificate)
GetExpirationDateString()

이 X.509v3 인증서의 만료 날짜를 반환합니다.

(다음에서 상속됨 X509Certificate)
GetFormat()

이 X.509v3 인증서의 형식 이름을 반환합니다.

(다음에서 상속됨 X509Certificate)
GetHashCode()

X.509v3 인증서에 대한 해시 코드를 정수로 반환합니다.

(다음에서 상속됨 X509Certificate)
GetIssuerName()
사용되지 않음.
사용되지 않음.
사용되지 않음.

X.509v3 인증서를 발급한 인증 기관의 이름을 반환합니다.

(다음에서 상속됨 X509Certificate)
GetKeyAlgorithm()

이 X.509v3 인증서의 키 알고리즘 정보를 문자열로 반환합니다.

(다음에서 상속됨 X509Certificate)
GetKeyAlgorithmParameters()

X.509v3 인증서에 대한 키 알고리즘 매개 변수(바이트 배열)를 반환합니다.

(다음에서 상속됨 X509Certificate)
GetKeyAlgorithmParametersString()

X.509v3 인증서의 키 알고리즘 매개 변수를 16진수 문자열로 반환합니다.

(다음에서 상속됨 X509Certificate)
GetName()
사용되지 않음.
사용되지 않음.
사용되지 않음.

인증서가 발행된 대상 보안 주체의 이름을 반환합니다.

(다음에서 상속됨 X509Certificate)
GetNameInfo(X509NameType, Boolean)

인증서에서 주체와 발급자 이름을 가져옵니다.

GetPublicKey()

X.509v3 인증서에 대한 공개 키(바이트 배열)를 반환합니다.

(다음에서 상속됨 X509Certificate)
GetPublicKeyString()

X.509v3 인증서에 대한 공개 키(16진 문자열)를 반환합니다.

(다음에서 상속됨 X509Certificate)
GetRawCertData()

전체 X.509v3 인증서에 대한 원시 데이터(바이트 배열)를 반환합니다.

(다음에서 상속됨 X509Certificate)
GetRawCertDataString()

전체 X.509v3 인증서에 대한 원시 데이터(16진 문자열)를 반환합니다.

(다음에서 상속됨 X509Certificate)
GetSerialNumber()

X.509v3 인증서의 일련 번호를 Little Endian 순서의 바이트 배열로 반환합니다.

(다음에서 상속됨 X509Certificate)
GetSerialNumberString()

X.509v3 인증서의 일련 번호를 Little Endian 16진 문자열로 반환합니다.

(다음에서 상속됨 X509Certificate)
GetType()

현재 인스턴스의 Type을 가져옵니다.

(다음에서 상속됨 Object)
Import(Byte[])
사용되지 않음.

X509Certificate2 개체를 바이트 배열의 데이터로 채웁니다.

Import(Byte[])
사용되지 않음.

바이트 배열의 데이터로 X509Certificate 개체를 채웁니다.

(다음에서 상속됨 X509Certificate)
Import(Byte[], SecureString, X509KeyStorageFlags)
사용되지 않음.

바이트 배열 데이터, 암호 및 키 스토리지 플래그를 사용하여 X509Certificate2 개체를 채웁니다.

Import(Byte[], SecureString, X509KeyStorageFlags)
사용되지 않음.

바이트 배열 데이터, 암호 및 키 스토리지 플래그를 사용하여 X509Certificate 개체를 채웁니다.

(다음에서 상속됨 X509Certificate)
Import(Byte[], String, X509KeyStorageFlags)
사용되지 않음.

바이트 배열의 데이터, 암호 및 프라이빗 키를 가져오는 방법을 결정하기 위한 플래그를 사용하여 X509Certificate2 개체를 채웁니다.

Import(Byte[], String, X509KeyStorageFlags)
사용되지 않음.

바이트 배열의 데이터, 암호 및 프라이빗 키 가져오기 방법을 결정하기 위한 플래그를 사용하여 X509Certificate 개체를 채웁니다.

(다음에서 상속됨 X509Certificate)
Import(String)
사용되지 않음.

X509Certificate2 개체를 인증서 파일의 정보로 채웁니다.

Import(String)
사용되지 않음.

인증서 파일의 정보로 X509Certificate 개체를 채웁니다.

(다음에서 상속됨 X509Certificate)
Import(String, SecureString, X509KeyStorageFlags)
사용되지 않음.

인증서 파일의 정보, 암호 및 키 스토리지 플래그로 X509Certificate2 개체를 채웁니다.

Import(String, SecureString, X509KeyStorageFlags)
사용되지 않음.

인증서 파일의 정보, 암호 및 키 스토리지 플래그로 X509Certificate 개체를 채웁니다.

(다음에서 상속됨 X509Certificate)
Import(String, String, X509KeyStorageFlags)
사용되지 않음.

X509Certificate2 개체를 인증서 파일의 정보, 암호 및 X509KeyStorageFlags 값으로 채웁니다.

Import(String, String, X509KeyStorageFlags)
사용되지 않음.

인증서 파일의 정보, 암호 및 X509Certificate 값으로 X509KeyStorageFlags 개체를 채웁니다.

(다음에서 상속됨 X509Certificate)
MatchesHostname(String, Boolean, Boolean)

인증서가 제공된 호스트 이름과 일치하는지 확인합니다.

MemberwiseClone()

현재 Object의 단순 복사본을 만듭니다.

(다음에서 상속됨 Object)
Reset()

X509Certificate2 개체의 상태를 다시 설정합니다.

Reset()

X509Certificate2 개체의 상태를 다시 설정합니다.

(다음에서 상속됨 X509Certificate)
ToString()

X.509 인증서를 텍스트 형식으로 표시합니다.

ToString(Boolean)

X.509 인증서를 텍스트 형식으로 표시합니다.

TryExportCertificatePem(Span<Char>, Int32)

PEM으로 인코딩된 공용 X.509 인증서를 내보내려고 시도합니다.

TryGetCertHash(HashAlgorithmName, Span<Byte>, Int32)

지정된 해시 알고리즘을 통해 인코딩된 인증서 표현을 해시하여 인증서의 “지문”을 생성하려고 합니다.

(다음에서 상속됨 X509Certificate)
Verify()

기본 유효성 검사 정책을 사용하여 X.509 체인의 유효성 검사를 수행합니다.

명시적 인터페이스 구현

IDeserializationCallback.OnDeserialization(Object)

ISerializable 인터페이스를 구현하고 역직렬화가 완료되면 역직렬화 이벤트에 의해 콜백됩니다.

(다음에서 상속됨 X509Certificate)
ISerializable.GetObjectData(SerializationInfo, StreamingContext)

현재 X509Certificate 개체의 인스턴스를 다시 만드는 데 필요한 모든 데이터가 포함된 serialization 정보를 가져옵니다.

(다음에서 상속됨 X509Certificate)

확장 메서드

CopyWithPrivateKey(X509Certificate2, DSA)

DSA 인증서의 퍼블릭 키와 프라이빗 키를 결합하여 새 DSA 인증서를 생성합니다.

GetDSAPrivateKey(X509Certificate2)

X509Certificate2에서 DSA 프라이빗 키를 가져옵니다.

GetDSAPublicKey(X509Certificate2)

X509Certificate2에서 DSA 공개 키를 가져옵니다.

CopyWithPrivateKey(X509Certificate2, ECDsa)

ECDsa 인증서의 퍼블릭 키와 프라이빗 키를 결합하여 새 ECDSA 인증서를 생성합니다.

GetECDsaPrivateKey(X509Certificate2)

X509Certificate2 인증서에서 ECDsa 프라이빗 키를 가져옵니다.

GetECDsaPublicKey(X509Certificate2)

X509Certificate2 인증서에서 ECDsa 공개 키를 가져옵니다.

CopyWithPrivateKey(X509Certificate2, RSA)

RSA 인증서의 퍼블릭 키와 프라이빗 키를 결합하여 새 RSA 인증서를 생성합니다.

GetRSAPrivateKey(X509Certificate2)

X509Certificate2에서 RSA 프라이빗 키를 가져옵니다.

GetRSAPublicKey(X509Certificate2)

X509Certificate2에서 RSA 공개 키를 가져옵니다.

적용 대상