baseline: OpenMU upstream b5a0961 (fresh source)

tests/MUnique.OpenMU.Network.Tests/PipelinedEncryptDecryptCycleTests.cs

@@ -0,0 +1,137 @@
+// <copyright file="PipelinedEncryptDecryptCycleTests.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Network.Tests;
+
+using System.Buffers;
+using System.IO.Pipelines;
+using MUnique.OpenMU.Network.SimpleModulus;
+using MUnique.OpenMU.Network.Xor;
+
+/// <summary>
+/// Tests the cycle of encrypting and decrypting a packet purely due pipes.
+/// </summary>
+[TestFixture]
+public class PipelinedEncryptDecryptCycleTests
+{
+    /// <summary>
+    /// Tests the encryption and decryption cycle of C3-packets from client to server.
+    /// These packets get encrypted first by <see cref="PipelinedXor32Encryptor"/>, then by <see cref="PipelinedSimpleModulusEncryptor"/> using client-side keys.
+    /// Then it gets decrypted by the <see cref="PipelinedSimpleModulusDecryptor"/> using server-side keys and finally by the <see cref="PipelinedXor32Decryptor"/>.
+    /// </summary>
+    /// <returns>The task.</returns>
+    [Test]
+    public async Task ClientToServerC3Async()
+    {
+        var packet = Convert.FromBase64String("w7kxFgK8hYpGGLgdXe7ZpTZViB+r3sRI3YSqZs7/Mh5Vmh2mXqs+3dqkvURmXrL57ASs+FkJz/236Tl9ER67R+WZyMLRMkeLF6tEBiB/4X7SsXrKUznES8of73RxwMy76HZezJbvJ7m9IOGuxcjcNwe6q1+k8fOs1Hz3sULSGlbfiB6qIBXo4onADTNYFoYCQrdtthVsF/aDsvcZ93V36gaKzzyqMhby0sjV4+TAU7719W6LZWNAcnA=");
+        await this.EncryptDecryptFromClientToServerAsync(packet).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Tests the encryption of a packet where the final block doesn't have maximum size.
+    /// </summary>
+    /// <remarks>
+    /// The test uses a real ping packet which was captured from a real game client.
+    /// </remarks>
+    /// <returns>The async task.</returns>
+    [Test]
+    public async Task ClientToServerC3WithNonMaximalFinalBlockSizeAsync()
+    {
+        var packet = new byte[] { 195, 12, 14, 0, 1, 51, 254, 39, 0, 0, 0, 0 };
+        await this.EncryptDecryptFromClientToServerAsync(packet).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Tests the encryption of a C3 packet where the size is lower than the maximum block size.
+    /// </summary>
+    /// <remarks>
+    /// The test uses a real ping packet which was captured from a real game client.
+    /// </remarks>
+    /// <returns>The async task.</returns>
+    [Test]
+    public async Task ClientToServerC3WithSmallPacketAsync()
+    {
+        var packet = new byte[] { 195, 5, 14, 0, 1 };
+        await this.EncryptDecryptFromClientToServerAsync(packet).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Tests the encryption and decryption cycle of C1-packets from client to server.
+    /// These packets get encrypted first by <see cref="PipelinedXor32Encryptor"/>, then <see cref="PipelinedSimpleModulusEncryptor"/> just forwards then as-is.
+    /// Then the <see cref="PipelinedSimpleModulusDecryptor"/> forwards them as well and finally it gets decrypted by the <see cref="PipelinedXor32Decryptor"/>.
+    /// </summary>
+    /// <returns>The task.</returns>
+    [Test]
+    public async Task ClientToServerC1Async()
+    {
+        var packet = new byte[] { 0xC1, 0x06, 0x11, 0x01, 0x02, 0x03 };
+        await this.EncryptDecryptFromClientToServerAsync(packet).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Tests the encryption and decryption cycle of C3-packets from server to client.
+    /// These packets get encrypted first by the <see cref="PipelinedSimpleModulusEncryptor"/> using server-side keys.
+    /// On the client side it gets decrypted by the <see cref="PipelinedSimpleModulusDecryptor"/> using client-side keys.
+    /// </summary>
+    /// <returns>The task.</returns>
+    [Test]
+    public async Task ServerToClientC3Async()
+    {
+        var packet = Convert.FromBase64String("w7kxFgK8hYpGGLgdXe7ZpTZViB+r3sRI3YSqZs7/Mh5Vmh2mXqs+3dqkvURmXrL57ASs+FkJz/236Tl9ER67R+WZyMLRMkeLF6tEBiB/4X7SsXrKUznES8of73RxwMy76HZezJbvJ7m9IOGuxcjcNwe6q1+k8fOs1Hz3sULSGlbfiB6qIBXo4onADTNYFoYCQrdtthVsF/aDsvcZ93V36gaKzzyqMhby0sjV4+TAU7719W6LZWNAcnA=");
+        await this.EncryptDecryptFromServerToClientAsync(packet).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Tests the encryption and decryption cycle of C1-packets from server to client.
+    /// These packets are not encrypted at all, so all involved simple modulus encryptor/decryptors just forward them.
+    /// </summary>
+    /// <returns>The task.</returns>
+    [Test]
+    public async Task ServerToClientC1Async()
+    {
+        var packet = new byte[] { 0xC1, 0x06, 0x11, 0x01, 0x02, 0x03 };
+        await this.EncryptDecryptFromServerToClientAsync(packet).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Tests the encryption-decryption cycle for the packet from server to client. The specified packet must be the same after the packet has passed this cycle.
+    /// Packets from server to client are never encrypted by Xor32, so these encryptor/decryptors are not involved here.
+    /// </summary>
+    /// <param name="packet">The packet.</param>
+    /// <returns>The task.</returns>
+    private async Task EncryptDecryptFromServerToClientAsync(byte[] packet)
+    {
+        // this pipe connects the encryptor with the decryptor. You can imagine this as the server-to-client pipe of a network socket, for example.
+        var pipe = new Pipe();
+
+        var encryptor = new PipelinedSimpleModulusEncryptor(pipe.Writer);
+        var decryptor = new PipelinedSimpleModulusDecryptor(pipe.Reader, PipelinedSimpleModulusDecryptor.DefaultClientKey);
+        encryptor.Writer.Write(packet);
+        await encryptor.Writer.FlushAsync().ConfigureAwait(false);
+        var readResult = await decryptor.Reader.ReadAsync().ConfigureAwait(false);
+
+        var result = readResult.Buffer.ToArray();
+        Assert.That(result, Is.EquivalentTo(packet));
+    }
+
+    /// <summary>
+    /// Tests the encryption-decryption cycle for the packet. The specified packet must be the same after the packet has passed this cycle.
+    /// </summary>
+    /// <param name="packet">The packet.</param>
+    /// <returns>The async task.</returns>
+    private async Task EncryptDecryptFromClientToServerAsync(byte[] packet)
+    {
+        // this pipe connects the encryptor with the decryptor. You can imagine this as the client-to-server pipe of a network socket, for example.
+        var pipe = new Pipe();
+
+        var encryptor = new PipelinedXor32Encryptor(new PipelinedSimpleModulusEncryptor(pipe.Writer, PipelinedSimpleModulusEncryptor.DefaultClientKey).Writer);
+        var decryptor = new PipelinedXor32Decryptor(new PipelinedSimpleModulusDecryptor(pipe.Reader).Reader);
+        encryptor.Writer.Write(packet);
+        await encryptor.Writer.FlushAsync().ConfigureAwait(false);
+        var readResult = await decryptor.Reader.ReadAsync().ConfigureAwait(false);
+
+        var result = readResult.Buffer.ToArray();
+        Assert.That(result, Is.EquivalentTo(packet));
+    }
+}