RC2.Create Methode

Quelle:

RC2.cs

Quelle:

RC2.cs

Quelle:

RC2.cs

public:
 static System::Security::Cryptography::RC2 ^ Create();

public static System.Security.Cryptography.RC2 Create ();

[System.Runtime.Versioning.UnsupportedOSPlatform("android")]
public static System.Security.Cryptography.RC2 Create ();

[System.Runtime.Versioning.UnsupportedOSPlatform("android")]
[System.Runtime.Versioning.UnsupportedOSPlatform("browser")]
public static System.Security.Cryptography.RC2 Create ();

static member Create : unit -> System.Security.Cryptography.RC2

[<System.Runtime.Versioning.UnsupportedOSPlatform("android")>]
static member Create : unit -> System.Security.Cryptography.RC2

[<System.Runtime.Versioning.UnsupportedOSPlatform("android")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("browser")>]
static member Create : unit -> System.Security.Cryptography.RC2

Public Shared Function Create () As RC2

Gibt zurück

Eine Instanz eines Kryptografieobjekts.

Attribute

UnsupportedOSPlatformAttribute

Ausnahmen

Beispiele

Das folgende Beispiel zeigt, wie Sie ein RC2-Objekt erstellen und verwenden, um Daten in einer Datei zu verschlüsseln und zu entschlüsseln.

using namespace System;
using namespace System::IO;
using namespace System::Security::Cryptography;
using namespace System::Text;

void EncryptTextToFile(String^ text, String^ path, array<Byte>^ key, array<Byte>^ iv);
String^ DecryptTextFromFile(String^ path, array<Byte>^ key, array<Byte>^ iv);

int main()
{
    try
    {
        array<Byte>^ key;
        array<Byte>^ iv;

        // Create a new RC2 object to generate a random key
        // and initialization vector (IV).
        {
            RC2^ rc2;

            try
            {
                rc2 = RC2::Create();
                key = rc2->Key;
                iv = rc2->IV;
            }
            finally
            {
                delete rc2;
            }
        }

        // Create a string to encrypt.
        String^ original = "Here is some data to encrypt.";
        // The name/path of the file to write.
        String^ filename = "CText.enc";

        // Encrypt the string to a file.
        EncryptTextToFile(original, filename, key, iv);

        // Decrypt the file back to a string.
        String^ decrypted = DecryptTextFromFile(filename, key, iv);

        // Display the decrypted string to the console.
        Console::WriteLine(decrypted);
    }
    catch (Exception^ e)
    {
        Console::WriteLine(e->Message);
    }
}

void EncryptTextToFile(String^ text, String^ path, array<Byte>^ key, array<Byte>^ iv)
{
    FileStream^ fStream = nullptr;
    RC2^ rc2 = nullptr;
    ICryptoTransform^ encryptor = nullptr;
    CryptoStream^ cStream = nullptr;

    try
    {
        // Create or open the specified file.
        fStream = File::Open(path, FileMode::Create);
        // Create a new RC2 object.
        rc2 = RC2::Create();
        // Create an RC2 encryptor from the key and IV
        encryptor = rc2->CreateEncryptor(key, iv);
        // Create a CryptoStream using the FileStream and encryptor
        cStream = gcnew CryptoStream(fStream, encryptor, CryptoStreamMode::Write);

        // Convert the provided string to a byte array.
        array<Byte>^ toEncrypt = Encoding::UTF8->GetBytes(text);

        // Write the byte array to the crypto stream.
        cStream->Write(toEncrypt, 0, toEncrypt->Length);
    }
    catch (CryptographicException^ e)
    {
        Console::WriteLine("A Cryptographic error occurred: {0}", e->Message);
        throw;
    }
    finally
    {
        if (cStream != nullptr)
            delete cStream;

        if (encryptor != nullptr)
            delete encryptor;

        if (rc2 != nullptr)
            delete rc2;

        if (fStream != nullptr)
            delete fStream;
    }
}

String^ DecryptTextFromFile(String^ path, array<Byte>^ key, array<Byte>^ iv)
{
    FileStream^ fStream = nullptr;
    RC2^ rc2 = nullptr;
    ICryptoTransform^ decryptor = nullptr;
    CryptoStream^ cStream = nullptr;
    StreamReader^ reader = nullptr;

    try
    {
        // Open the specified file
        fStream = File::OpenRead(path);
        // Create a new RC2 object.
        rc2 = RC2::Create();
        // Create an RC2 decryptor from the key and IV
        decryptor = rc2->CreateDecryptor(key, iv);
        // Create a CryptoStream using the FileStream and decryptor
        cStream = gcnew CryptoStream(fStream, decryptor, CryptoStreamMode::Read);
        // Create a StreamReader to turn the bytes back into text
        reader = gcnew StreamReader(cStream, Encoding::UTF8);

        // Read back all of the text from the StreamReader, which receives
        // the decrypted bytes from the CryptoStream, which receives the
        // encrypted bytes from the FileStream.
        return reader->ReadToEnd();
    }
    catch (CryptographicException^ e)
    {
        Console::WriteLine("A Cryptographic error occurred: {0}", e->Message);
        throw;
    }
    finally
    {
        if (cStream != nullptr)
            delete cStream;

        if (decryptor != nullptr)
            delete decryptor;

        if (rc2 != nullptr)
            delete rc2;

        if (fStream != nullptr)
            delete fStream;
    }
}

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;

class RC2Sample
{
    static void Main()
    {
        try
        {
            byte[] key;
            byte[] iv;

            // Create a new RC2 object to generate a random key
            // and initialization vector (IV).
            using (RC2 rc2 = RC2.Create())
            {
                key = rc2.Key;
                iv = rc2.IV;
            }

            // Create a string to encrypt.
            string original = "Here is some data to encrypt.";
            // The name/path of the file to write.
            string filename = "CText.enc";

            // Encrypt the string to a file.
            EncryptTextToFile(original, filename, key, iv);

            // Decrypt the file back to a string.
            string decrypted = DecryptTextFromFile(filename, key, iv);

            // Display the decrypted string to the console.
            Console.WriteLine(decrypted);
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
    }

    public static void EncryptTextToFile(string text, string path, byte[] key, byte[] iv)
    {
        try
        {
            // Create or open the specified file.
            using (FileStream fStream = File.Open(path, FileMode.Create))
            // Create a new RC2 object.
            using (RC2 rc2 = RC2.Create())
            // Create an RC2 encryptor from the key and IV
            using (ICryptoTransform encryptor = rc2.CreateEncryptor(key, iv))
            // Create a CryptoStream using the FileStream and encryptor
            using (var cStream = new CryptoStream(fStream, encryptor, CryptoStreamMode.Write))
            {
                // Convert the provided string to a byte array.
                byte[] toEncrypt = Encoding.UTF8.GetBytes(text);

                // Write the byte array to the crypto stream.
                cStream.Write(toEncrypt, 0, toEncrypt.Length);
            }
        }
        catch (CryptographicException e)
        {
            Console.WriteLine("A Cryptographic error occurred: {0}", e.Message);
            throw;
        }
    }

    public static string DecryptTextFromFile(string path, byte[] key, byte[] iv)
    {
        try
        {
            // Open the specified file
            using (FileStream fStream = File.OpenRead(path))
            // Create a new RC2 object.
            using (RC2 rc2 = RC2.Create())
            // Create an RC2 decryptor from the key and IV
            using (ICryptoTransform decryptor = rc2.CreateDecryptor(key, iv))
            // Create a CryptoStream using the FileStream and decryptor
            using (var cStream = new CryptoStream(fStream, decryptor, CryptoStreamMode.Read))
            // Create a StreamReader to turn the bytes back into text
            using (StreamReader reader = new StreamReader(cStream, Encoding.UTF8))
            {
                // Read back all of the text from the StreamReader, which receives
                // the decrypted bytes from the CryptoStream, which receives the
                // encrypted bytes from the FileStream.
                return reader.ReadToEnd();
            }
        }
        catch (CryptographicException e)
        {
            Console.WriteLine("A Cryptographic error occurred: {0}", e.Message);
            throw;
        }
    }
}

Imports System.IO
Imports System.Security.Cryptography
Imports System.Text

Module RC2Sample

    Sub Main()
        Try
            Dim key As Byte()
            Dim iv As Byte()

            ' Create a new RC2 object to generate a key
            ' and initialization vector (IV).
            Using rc2 As RC2 = RC2.Create
                key = rc2.Key
                iv = rc2.IV
            End Using

            ' Create a string to encrypt.
            Dim original As String = "Here is some data to encrypt."
            ' The name/path of the file to write.
            Dim filename As String = "CText.enc"

            ' Encrypt the string to a file.
            EncryptTextToFile(original, filename, key, iv)

            ' Decrypt the file back to a string.
            Dim decrypted As String = DecryptTextFromFile(filename, key, iv)

            ' Display the decrypted string to the console.
            Console.WriteLine(decrypted)
        Catch e As Exception
            Console.WriteLine(e.Message)
        End Try
    End Sub


    Sub EncryptTextToFile(text As String, path As String, key As Byte(), iv As Byte())
        Try
            ' Create or open the specified file.
            ' Create a new RC2 object,
            ' Create an RC2 encryptor from the key and IV,
            ' Create a CryptoStream using the MemoryStream And encryptor
            Using fStream As FileStream = File.Open(path, FileMode.Create),
                rc2 As RC2 = RC2.Create,
                encryptor As ICryptoTransform = rc2.CreateEncryptor(key, iv),
                cStream = New CryptoStream(fStream, encryptor, CryptoStreamMode.Write)

                ' Convert the passed string to a byte array.
                Dim toEncrypt As Byte() = Encoding.UTF8.GetBytes(text)

                ' Write the byte array to the crypto stream.
                cStream.Write(toEncrypt, 0, toEncrypt.Length)
            End Using

        Catch e As CryptographicException
            Console.WriteLine("A Cryptographic error occurred: {0}", e.Message)
            Throw
        End Try
    End Sub


    Function DecryptTextFromFile(path As String, key As Byte(), iv As Byte()) As String
        Try
            ' Open the specified file
            ' Create a new RC2 object.
            ' Create an RC2 decryptor from the key and IV
            ' Create a CryptoStream using the MemoryStream and decryptor
            ' Create a StreamReader to turn the bytes back into text
            Using mStream As FileStream = File.OpenRead(path),
                rc2 As RC2 = RC2.Create,
                decryptor As ICryptoTransform = rc2.CreateDecryptor(key, iv),
                cStream = New CryptoStream(mStream, decryptor, CryptoStreamMode.Read),
                reader = New StreamReader(cStream, Encoding.UTF8)

                ' Read back all of the text from the StreamReader, which receives
                ' the decrypted bytes from the CryptoStream, which receives the
                ' encrypted bytes from the FileStream.
                Return reader.ReadToEnd()
            End Using
        Catch e As CryptographicException
            Console.WriteLine("A Cryptographic error occurred: {0}", e.Message)
            Return Nothing
        End Try
    End Function
End Module

Das folgende Beispiel zeigt, wie Sie ein RC2-Objekt erstellen und verwenden, um Daten im Arbeitsspeicher zu verschlüsseln und zu entschlüsseln.

using namespace System;
using namespace System::Security::Cryptography;
using namespace System::Text;
using namespace System::IO;

array<Byte>^ EncryptTextToMemory(String^ text, array<Byte>^ key, array<Byte>^ iv);
String^ DecryptTextFromMemory(array<Byte>^ encrypted, array<Byte>^ key, array<Byte>^ iv);

int main()
{
    try
    {
        array<Byte>^ key;
        array<Byte>^ iv;

        // Create a new RC2 object to generate a random key
        // and initialization vector (IV).
        {
            RC2^ rc2;

            try
            {
                rc2 = RC2::Create();
                key = rc2->Key;
                iv = rc2->IV;
            }
            finally
            {
                delete rc2;
            }
        }

        // Create a string to encrypt.
        String^ original = "Here is some data to encrypt.";

        // Encrypt the string to an in-memory buffer.
        array<Byte>^ encrypted = EncryptTextToMemory(original, key, iv);

        // Decrypt the buffer back to a string.
        String^ decrypted = DecryptTextFromMemory(encrypted, key, iv);

        // Display the decrypted string to the console.
        Console::WriteLine(decrypted);
    }
    catch (Exception^ e)
    {
        Console::WriteLine(e->Message);
    }
}

array<Byte>^ EncryptTextToMemory(String^ text, array<Byte>^ key, array<Byte>^ iv)
{
    MemoryStream^ mStream = nullptr;

    try
    {
        // Create a MemoryStream.
        mStream = gcnew MemoryStream;

        RC2^ rc2 = nullptr;
        ICryptoTransform^ encryptor = nullptr;
        CryptoStream^ cStream = nullptr;

        try
        {
            // Create a new RC2 object.
            rc2 = RC2::Create();
            // Create an RC2 encryptor from the key and IV
            encryptor = rc2->CreateEncryptor(key, iv);
            // Create a CryptoStream using the MemoryStream and encryptor
            cStream = gcnew CryptoStream(mStream, encryptor, CryptoStreamMode::Write);

            // Convert the provided string to a byte array.
            array<Byte>^ toEncrypt = Encoding::UTF8->GetBytes(text);

            // Write the byte array to the crypto stream.
            cStream->Write(toEncrypt, 0, toEncrypt->Length);

            // Disposing the CryptoStream completes the encryption and flushes the stream.
            delete cStream;

            // Get an array of bytes from the MemoryStream that holds the encrypted data.
            array<Byte>^ ret = mStream->ToArray();

            // Return the encrypted buffer.
            return ret;
        }
        finally
        {
            if (cStream != nullptr)
                delete cStream;

            if (encryptor != nullptr)
                delete encryptor;

            if (rc2 != nullptr)
                delete rc2;
        }
    }
    catch (CryptographicException^ e)
    {
        Console::WriteLine("A Cryptographic error occurred: {0}", e->Message);
        throw;
    }
    finally
    {
        if (mStream != nullptr)
            delete mStream;
    }
}

String^ DecryptTextFromMemory(array<Byte>^ encrypted, array<Byte>^ key, array<Byte>^ iv)
{
    MemoryStream^ mStream = nullptr;
    RC2^ rc2 = nullptr;
    ICryptoTransform^ decryptor = nullptr;
    CryptoStream^ cStream = nullptr;

    try
    {
        // Create buffer to hold the decrypted data.
        // RC2-encrypted data will always be slightly bigger than the decrypted data.
        array<Byte>^ decrypted = gcnew array<Byte>(encrypted->Length);
        Int32 offset = 0;

        // Create a new MemoryStream using the provided array of encrypted data.
        mStream = gcnew MemoryStream(encrypted);
        // Create a new RC2 object.
        rc2 = RC2::Create();
        // Create an RC2 decryptor from the key and IV
        decryptor = rc2->CreateDecryptor(key, iv);
        // Create a CryptoStream using the MemoryStream and decryptor
        cStream = gcnew CryptoStream(mStream, decryptor, CryptoStreamMode::Read);

        // Keep reading from the CryptoStream until it finishes (returns 0).
        Int32 read = 1;

        while (read > 0)
        {
            read = cStream->Read(decrypted, offset, decrypted->Length - offset);
            offset += read;
        }

        // Convert the buffer into a string and return it.
        return Encoding::UTF8->GetString(decrypted, 0, offset);
    }
    catch (CryptographicException^ e)
    {
        Console::WriteLine("A Cryptographic error occurred: {0}", e->Message);
        throw;
    }
    finally
    {
        if (cStream != nullptr)
            delete cStream;

        if (decryptor != nullptr)
            delete decryptor;

        if (rc2 != nullptr)
            delete rc2;

        if (mStream != nullptr)
            delete mStream;
    }
}

using System;
using System.Security.Cryptography;
using System.Text;
using System.IO;

class RC2Sample2
{
    static void Main()
    {
        try
        {
            byte[] key;
            byte[] iv;

            // Create a new RC2 object to generate a random key
            // and initialization vector (IV).
            using (RC2 rc2 = RC2.Create())
            {
                key = rc2.Key;
                iv = rc2.IV;
            }

            // Create a string to encrypt.
            string original = "Here is some data to encrypt.";

            // Encrypt the string to an in-memory buffer.
            byte[] encrypted = EncryptTextToMemory(original, key, iv);

            // Decrypt the buffer back to a string.
            string decrypted = DecryptTextFromMemory(encrypted, key, iv);

            // Display the decrypted string to the console.
            Console.WriteLine(decrypted);
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
    }

    public static byte[] EncryptTextToMemory(string text, byte[] key, byte[] iv)
    {
        try
        {
            // Create a MemoryStream.
            using (MemoryStream mStream = new MemoryStream())
            {
                // Create a new RC2 object.
                using (RC2 rc2 = RC2.Create())
                // Create an RC2 encryptor from the key and IV
                using (ICryptoTransform encryptor = rc2.CreateEncryptor(key, iv))
                // Create a CryptoStream using the MemoryStream and encryptor
                using (var cStream = new CryptoStream(mStream, encryptor, CryptoStreamMode.Write))
                {
                    // Convert the provided string to a byte array.
                    byte[] toEncrypt = Encoding.UTF8.GetBytes(text);

                    // Write the byte array to the crypto stream and flush it.
                    cStream.Write(toEncrypt, 0, toEncrypt.Length);

                    // Ending the using statement for the CryptoStream completes the encryption.
                }

                // Get an array of bytes from the MemoryStream that holds the encrypted data.
                byte[] ret = mStream.ToArray();

                // Return the encrypted buffer.
                return ret;
            }
        }
        catch (CryptographicException e)
        {
            Console.WriteLine("A Cryptographic error occurred: {0}", e.Message);
            throw;
        }
    }

    public static string DecryptTextFromMemory(byte[] encrypted, byte[] key, byte[] iv)
    {
        try
        {
            // Create a buffer to hold the decrypted data.
            // RC2-encrypted data will always be slightly bigger than the decrypted data.
            byte[] decrypted = new byte[encrypted.Length];
            int offset = 0;

            // Create a new MemoryStream using the provided array of encrypted data.
            using (MemoryStream mStream = new MemoryStream(encrypted))
            {
                // Create a new RC2 object.
                using (RC2 rc2 = RC2.Create())
                // Create an RC2 decryptor from the key and IV
                using (ICryptoTransform decryptor = rc2.CreateDecryptor(key, iv))
                // Create a CryptoStream using the MemoryStream and decryptor
                using (var cStream = new CryptoStream(mStream, decryptor, CryptoStreamMode.Read))
                {
                    // Keep reading from the CryptoStream until it finishes (returns 0).
                    int read = 1;

                    while (read > 0)
                    {
                        read = cStream.Read(decrypted, offset, decrypted.Length - offset);
                        offset += read;
                    }
                }
            }

            // Convert the buffer into a string and return it.
            return Encoding.UTF8.GetString(decrypted, 0, offset);
        }
        catch (CryptographicException e)
        {
            Console.WriteLine("A Cryptographic error occurred: {0}", e.Message);
            throw;
        }
    }
}

Imports System.Security.Cryptography
Imports System.Text
Imports System.IO

Module RC2Sample

    Sub Main()
        Try
            Dim key As Byte()
            Dim iv As Byte()

            ' Create a new RC2 object to generate a key
            ' and initialization vector (IV).
            Using rc2 As RC2 = RC2.Create
                key = rc2.Key
                iv = rc2.IV
            End Using

            ' Create a string to encrypt.
            Dim original As String = "Here is some data to encrypt."

            ' Encrypt the string to an in-memory buffer.
            Dim encrypted As Byte() = EncryptTextToMemory(original, key, iv)

            ' Decrypt the buffer back to a string.
            Dim decrypted As String = DecryptTextFromMemory(encrypted, key, iv)

            ' Display the decrypted string to the console.
            Console.WriteLine(decrypted)
        Catch e As Exception
            Console.WriteLine(e.Message)
        End Try
    End Sub


    Function EncryptTextToMemory(text As String, key As Byte(), iv As Byte()) As Byte()
        Try
            ' Create a MemoryStream.
            Using mStream As New MemoryStream
                ' Create a new RC2 object,
                ' Create an RC2 encryptor from the key and IV,
                ' Create a CryptoStream using the MemoryStream And encryptor
                Using rc2 As RC2 = RC2.Create,
                    encryptor As ICryptoTransform = rc2.CreateEncryptor(key, iv),
                    cStream = New CryptoStream(mStream, encryptor, CryptoStreamMode.Write)

                    ' Convert the passed string to a byte array.
                    Dim toEncrypt As Byte() = Encoding.UTF8.GetBytes(text)

                    ' Write the byte array to the crypto stream and flush it.
                    cStream.Write(toEncrypt, 0, toEncrypt.Length)

                    ' Ending the using block for the CryptoStream completes the encryption.
                End Using

                ' Get an array of bytes from the MemoryStream that holds the encrypted data.
                Dim ret As Byte() = mStream.ToArray()

                ' Return the encrypted buffer.
                Return ret
            End Using
        Catch e As CryptographicException
            Console.WriteLine("A Cryptographic error occurred: {0}", e.Message)
            Throw
        End Try
    End Function


    Function DecryptTextFromMemory(encrypted As Byte(), key As Byte(), iv As Byte()) As String
        Try
            ' Create a buffer to hold the decrypted data.
            ' RC2-encrypted data will always be slightly bigger than the decrypted data.
            Dim decrypted(encrypted.Length - 1) As Byte
            Dim offset As Integer = 0

            ' Create a new MemoryStream using the provided array of encrypted data.
            ' Create a new RC2 object.
            ' Create an RC2 decryptor from the key and IV
            ' Create a CryptoStream using the MemoryStream and decryptor
            Using mStream As New MemoryStream(encrypted),
                rc2 As RC2 = RC2.Create,
                decryptor As ICryptoTransform = rc2.CreateDecryptor(key, iv),
                cStream = New CryptoStream(mStream, decryptor, CryptoStreamMode.Read)

                ' Keep reading from the CryptoStream until it finishes (returns 0).
                Dim read As Integer = 1

                While (read > 0)
                    read = cStream.Read(decrypted, offset, decrypted.Length - offset)
                    offset += read
                End While
            End Using

            ' Convert the buffer into a string and return it.
            Return New ASCIIEncoding().GetString(decrypted, 0, offset)
        Catch e As CryptographicException
            Console.WriteLine("A Cryptographic error occurred: {0}", e.Message)
            Return Nothing
        End Try
    End Function
End Module

Hinweise

Verwenden Sie diese Methode, um eine Instanz der RC2-Klasse zu erstellen, die Sie zum Verschlüsseln und Entschlüsseln von Daten verwenden können.

Weitere Informationen

• Kryptografische Dienste

Quelle:

RC2.cs

Quelle:

RC2.cs

Quelle:

RC2.cs

public:
 static System::Security::Cryptography::RC2 ^ Create(System::String ^ AlgName);

public static System.Security.Cryptography.RC2? Create (string AlgName);

[System.Obsolete("Cryptographic factory methods accepting an algorithm name are obsolete. Use the parameterless Create factory method on the algorithm type instead.", DiagnosticId="SYSLIB0045", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
public static System.Security.Cryptography.RC2? Create (string AlgName);

public static System.Security.Cryptography.RC2 Create (string AlgName);

static member Create : string -> System.Security.Cryptography.RC2

[<System.Obsolete("Cryptographic factory methods accepting an algorithm name are obsolete. Use the parameterless Create factory method on the algorithm type instead.", DiagnosticId="SYSLIB0045", UrlFormat="https://aka.ms/dotnet-warnings/{0}")>]
static member Create : string -> System.Security.Cryptography.RC2

Public Shared Function Create (AlgName As String) As RC2

Parameter

Gibt zurück

Eine Instanz eines Kryptografieobjekts.

Attribute

ObsoleteAttribute

Ausnahmen

Weitere Informationen

• Kryptografische Dienste