Verfahrensweise: Versehen einer Nachricht mit einem Umschlag für einen Empfänger
In diesem Beispiel wird eine mit einem CMS/PKCS #7-Umschlag versehene Nachricht unter Verwendung von System.Security.Cryptography.Pkcs erstellt. Die Nachricht wird für einen einzelnen Empfänger verschlüsselt. Anschließend wird die Nachricht mithilfe des privaten Schlüssels dieses Empfängers entschlüsselt. Das Beispiel verwendet das EnvelopedCms-Objekt, das es ermöglicht, Nachrichten für einen oder mehrere Empfänger zu verschlüsseln oder mit einem Umschlag zu versehen.
Beispiel
In diesem Beispiel werden die folgenden Klassen verwendet:
Für die Ausführung auf einem einzelnen Computer ist für das folgende Beispiel erforderlich, dass ein Zertifikat mit öffentlichem Schlüssel mit dem Antragstellernamen "Recipient1" in den Zertifikatspeichern "AddressBook" und "My" enthalten ist. Darüber hinaus muss der zugeordnete private Schlüssel auf diesem Computer gespeichert sein. Der Beispielcode agiert erst als Absender der Nachricht und übernimmt anschließend die Rolle des Nachrichtenempfängers, indem in beiden Rollen dieselben Anmeldeinformationen des öffentlichen Schlüssels verwendet werden. Als Absender durchsucht der Code den Zertifikatspeicher "AddressBook" nach dem Zertifikat des Empfängers und verschlüsselt damit die Nachricht. Als Empfänger durchsucht der Code den Zertifikatspeicher "My" nach dem Zertifikat und entschlüsselt mit dem zugeordneten privaten Schlüssel die Nachricht.
.gif) Hinweis: |
|---|
Dieses Beispiel dient nur der Veranschaulichung. In Produktionsumgebungen kann ein anderes Modell verwendet werden, in dem Absender und Empfänger der Nachricht in verschiedenen Prozessen mit ihren eindeutigen Anmeldeinformationen des öffentlichen Schlüssels ausgeführt werden. |
Richten Sie dieses Beispiel mithilfe des Dienstprogramms Makecert.exe ein; dies ist nur eine von vielen Möglichkeiten. Certificate Creation Tool (Makecert.exe) ist ein komfortables Dienstprogramm zum Generieren von Testzertifikaten. In einer Produktionsumgebung werden Zertifikate von einer Zertifizierungsstelle generiert.
Mithilfe des folgenden Makecert-Befehls werden die erforderlichen Zertifikate mit öffentlichem Schlüssel und die privaten Schlüssel generiert.
Makecert -n "CN=Recipient1" -ss My
Dieser Befehl legt das entsprechende Zertifikat mit öffentlichem Schlüssel im Zertifikatspeicher "My" ab und generiert den privaten Schlüssel. Zu diesem Zeitpunkt müssen Sie eine Kopie des Zertifikats mit öffentlichem Schlüssel im Zertifikatspeicher "AddressBook" ablegen. Hierzu exportieren Sie das Zertifikat mit öffentlichem Schlüssel und importieren es in den Zertifikatspeicher "AddressBook", indem Sie das in Verfahrensweise: Exportieren und Importieren eines Zertifikats mit öffentlichem Schlüssel geschilderte Verfahren verwenden.
// Copyright (c) Microsoft Corporation. All rights reserved.
#region Using directives
using System;
using System.Security.Cryptography;
using System.Security.Cryptography.Pkcs;
using System.Security.Cryptography.X509Certificates;
using System.Text;
#endregion
namespace EnvelopAMessageForOneRecipient
{
class EnvelopedCmsSingleRecipient
{
const String recipientName = "Recipient1";
static void Main(string[] args)
{
Console.WriteLine("System.Security.Cryptography.Pkcs " +
"Sample: Single-recipient encrypted and decrypted message");
// Original message.
const String msg = "Here is your personal identification number:";
Console.WriteLine("\nOriginal message (len {0}): {1} ",
msg.Length, msg);
// Convert message to an array of Unicode bytes for signing.
UnicodeEncoding unicode = new UnicodeEncoding();
byte[] msgBytes = unicode.GetBytes(msg);
Console.WriteLine("\n\n------------------------------");
Console.WriteLine(" SETUP OF CREDENTIALS ");
Console.WriteLine("------------------------------\n");
// The recipient's certificate is necessary to encrypt
// the message for that recipient.
X509Certificate2 recipientCert = GetRecipientCert();
Console.WriteLine("\n\n----------------------");
Console.WriteLine(" SENDER SIDE ");
Console.WriteLine("----------------------\n");
byte[] encodedEnvelopedCms = EncryptMsg(msgBytes,
recipientCert);
Console.Write("\nMessage after encryption (len {0}): ",
encodedEnvelopedCms.Length);
foreach (byte b in encodedEnvelopedCms)
{
Console.Write("{0:x}", b);
}
Console.WriteLine();
Console.WriteLine("\n\n------------------------");
Console.WriteLine(" RECIPIENT SIDE ");
Console.WriteLine("------------------------\n");
Byte[] decryptedMsg = DecryptMsg(encodedEnvelopedCms);
// Convert Unicode bytes to the original message string.
Console.WriteLine("\nDecrypted Message: {0}",
unicode.GetString(decryptedMsg));
}
// Open the AddressBook (also known as Other in
// Internet Explorer) certificate store and search for
// a recipient certificate with which to encrypt the
// message. The certificate must have a subject name
// of "Recipient1".
static public X509Certificate2 GetRecipientCert()
{
// Open the AddressBook local user X509 certificate store.
X509Store storeAddressBook = new X509Store(StoreName.
AddressBook, StoreLocation.CurrentUser);
storeAddressBook.Open(OpenFlags.ReadOnly);
// Display certificates to help troubleshoot
// the example's setup.
Console.WriteLine(
"Found certs with the following subject names in the " +
"{0} store:", storeAddressBook.Name);
foreach (X509Certificate2 cert in storeAddressBook.Certificates)
{
Console.WriteLine("\t{0}", cert.SubjectName.Name);
}
// Get recipient certificate.
// For purposes of this sample, do not validate the
// certificate. Note that in a production environment,
// validating the certificate will probably be necessary.
X509Certificate2Collection certColl = storeAddressBook.
Certificates.Find(X509FindType.FindBySubjectName,
recipientName, false);
Console.WriteLine(
"Found {0} certificates in the {1} store with name {2}",
certColl.Count, storeAddressBook.Name, recipientName);
// Check to see if the certificate suggested by the example
// requirements is not present.
if (certColl.Count == 0)
{
Console.WriteLine(
"A suggested certificate to use for this example " +
"is not in the certificate store. Select " +
"an alternate certificate to use for " +
"signing the message.");
}
storeAddressBook.Close();
return certColl[0];
}
// Encrypt the message with the public key of
// the recipient. This is done by enveloping the message by
// using an EnvelopedCms object.
static public byte[] EncryptMsg(
Byte[] msg,
X509Certificate2 recipientCert)
{
// Place the message in a ContentInfo object.
// This is required to build an EnvelopedCms object.
ContentInfo contentInfo = new ContentInfo(msg);
// Instantiate an EnvelopedCms object with the ContentInfo
// above.
// Has default SubjectIdentifierType IssuerAndSerialNumber.
// Has default ContentEncryptionAlgorithm property value
// RSA_DES_EDE3_CBC.
EnvelopedCms envelopedCms = new EnvelopedCms(contentInfo);
// Formulate a CmsRecipient object that
// represents information about the recipient
// to encrypt the message for.
CmsRecipient recip1 = new CmsRecipient(
SubjectIdentifierType.IssuerAndSerialNumber,
recipientCert);
Console.Write(
"Encrypting data for a single recipient of " +
"subject name {0} ... ",
recip1.Certificate.SubjectName.Name);
// Encrypt the message for the recipient.
envelopedCms.Encrypt(recip1);
Console.WriteLine("Done.");
// The encoded EnvelopedCms message contains the message
// ciphertext and the information about each recipient
// that the message was enveloped for.
return envelopedCms.Encode();
}
// Decrypt the encoded EnvelopedCms message.
static public Byte[] DecryptMsg(byte[] encodedEnvelopedCms)
{
// Prepare object in which to decode and decrypt.
EnvelopedCms envelopedCms = new EnvelopedCms();
// Decode the message.
envelopedCms.Decode(encodedEnvelopedCms);
// Display the number of recipients the message is
// enveloped for; it should be 1 for this example.
DisplayEnvelopedCms(envelopedCms, false);
// Decrypt the message for the single recipient.
Console.Write("Decrypting Data ... ");
envelopedCms.Decrypt(envelopedCms.RecipientInfos[0]);
Console.WriteLine("Done.");
// The decrypted message occupies the ContentInfo property
// after the Decrypt method is invoked.
return envelopedCms.ContentInfo.Content;
}
// Display the ContentInfo property of an EnvelopedCms object.
static private void DisplayEnvelopedCmsContent(String desc,
EnvelopedCms envelopedCms)
{
Console.WriteLine(desc + " (length {0}): ",
envelopedCms.ContentInfo.Content.Length);
foreach (byte b in envelopedCms.ContentInfo.Content)
{
Console.Write(b.ToString() + " ");
}
Console.WriteLine();
}
// Display some properties of an EnvelopedCms object.
static private void DisplayEnvelopedCms(EnvelopedCms e,
Boolean displayContent)
{
Console.WriteLine("\nEnveloped CMS/PKCS #7 Message " +
"Information:");
Console.WriteLine(
"\tThe number of recipients for the Enveloped CMS/PKCS " +
"#7 is: {0}", e.RecipientInfos.Count);
for (int i = 0; i < e.RecipientInfos.Count; i++)
{
Console.WriteLine(
"\tRecipient #{0} has type {1}.",
i + 1,
e.RecipientInfos[i].RecipientIdentifier.Type);
}
if (displayContent)
{
DisplayEnvelopedCmsContent("Enveloped CMS/PKCS " +
"#7 Content", e);
}
Console.WriteLine();
}
}
}
Siehe auch
Aufgaben
Verfahrensweise: Signieren von Nachrichten durch einen Signierer
Verfahrensweise: Signieren einer Nachricht durch mehrere Signierer
Verfahrensweise: Gegensignieren einer Nachricht
Verfahrensweise: Versehen einer Nachricht mit einem Umschlag für mehrere Empfänger
Konzepte
Verfahrensweise: Signieren und Versehen einer Nachricht mit einem Umschlag
.gif)
Copyright © 2007 by Microsoft Corporation. Alle Rechte vorbehalten.