Add DummyHandler, NotAHandler, CrossHandlerTest, LegacyFormatRejectionTest, BaseHandlerTest, EncryptTest, EncryptionExceptionTest, OpenSSLTest, and SodiumTest

Author: muhammetsafak

tests/Fixtures/DummyHandler.php

@@ -0,0 +1,80 @@
+<?php
+
+declare(strict_types=1);
+
+namespace InitPHP\Encryption\Tests\Fixtures;
+
+use InitPHP\Encryption\BaseHandler;
+
+/**
+ * Minimal concrete handler used to drive {@see BaseHandler} from unit tests
+ * without depending on the openssl or sodium extensions. The cryptographic
+ * operations are stubbed; only the option and serialization machinery is real.
+ *
+ * Protected helpers are re-exposed as public methods so tests can assert on
+ * them directly.
+ */
+final class DummyHandler extends BaseHandler
+{
+    public function encrypt(mixed $data, array $options = []): string
+    {
+        $resolved = $this->resolveOptions($options);
+        $flag = $this->serializerFlag($resolved);
+
+        return $this->serializePayload($data, $flag);
+    }
+
+    public function decrypt(string $data, array $options = []): mixed
+    {
+        $resolved = $this->resolveOptions($options);
+        $flag = $this->serializerFlag($resolved);
+
+        return $this->unserializePayload($data, $flag);
+    }
+
+    /**
+     * @param array<string, mixed> $options
+     */
+    public function callRequireKey(array $options): string
+    {
+        return $this->requireKey($options);
+    }
+
+    /**
+     * @param array<string, mixed> $options
+     */
+    public function callSerializerFlag(array $options): int
+    {
+        return $this->serializerFlag($options);
+    }
+
+    public function callSerializePayload(mixed $data, int $flag): string
+    {
+        return $this->serializePayload($data, $flag);
+    }
+
+    public function callUnserializePayload(string $data, int $flag): mixed
+    {
+        return $this->unserializePayload($data, $flag);
+    }
+
+    /**
+     * @param array<string, mixed> $options
+     *
+     * @return array<string, mixed>
+     */
+    public function callResolveOptions(array $options): array
+    {
+        return $this->resolveOptions($options);
+    }
+
+    public function jsonFlag(): int
+    {
+        return self::SERIALIZER_FLAG_JSON;
+    }
+
+    public function phpFlag(): int
+    {
+        return self::SERIALIZER_FLAG_PHP;
+    }
+}

tests/Fixtures/NotAHandler.php

@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace InitPHP\Encryption\Tests\Fixtures;
+
+/**
+ * A class that intentionally does not implement
+ * {@see \InitPHP\Encryption\HandlerInterface}. Exists only to exercise the
+ * "class is not a handler" error path of {@see \InitPHP\Encryption\Encrypt::use()}.
+ */
+final class NotAHandler
+{
+    /**
+     * @param array<string, mixed> $options
+     */
+    public function __construct(public readonly array $options = [])
+    {
+    }
+}

tests/Integration/CrossHandlerTest.php

@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace InitPHP\Encryption\Tests\Integration;
+
+use InitPHP\Encryption\Exceptions\EncryptionException;
+use InitPHP\Encryption\OpenSSL;
+use InitPHP\Encryption\Sodium;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Verifies that ciphertext from one handler cannot be misinterpreted by the
+ * other. Each handler has its own on-wire layout following the shared 2-byte
+ * header; the rest of the bytes are not interchangeable.
+ *
+ * @requires extension openssl
+ * @requires extension sodium
+ */
+final class CrossHandlerTest extends TestCase
+{
+    private const KEY = 'cross-handler-shared-key';
+
+    public function testOpenSSLCannotDecryptSodiumCiphertext(): void
+    {
+        $sodium = new Sodium(['key' => self::KEY]);
+        $openssl = new OpenSSL(['key' => self::KEY]);
+        $ciphertext = $sodium->encrypt(['payload' => 'cross']);
+
+        $this->expectException(EncryptionException::class);
+
+        $openssl->decrypt($ciphertext);
+    }
+
+    public function testSodiumCannotDecryptOpenSSLCiphertext(): void
+    {
+        $openssl = new OpenSSL(['key' => self::KEY]);
+        $sodium = new Sodium(['key' => self::KEY]);
+        $ciphertext = $openssl->encrypt(['payload' => 'cross']);
+
+        $this->expectException(EncryptionException::class);
+
+        $sodium->decrypt($ciphertext);
+    }
+}

tests/Integration/LegacyFormatRejectionTest.php

@@ -0,0 +1,72 @@
+<?php
+
+declare(strict_types=1);
+
+namespace InitPHP\Encryption\Tests\Integration;
+
+use InitPHP\Encryption\BaseHandler;
+use InitPHP\Encryption\Exceptions\EncryptionException;
+use InitPHP\Encryption\OpenSSL;
+use InitPHP\Encryption\Sodium;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Documents the BC-break introduced in 2.0: ciphertexts produced by 1.x do
+ * not carry a version byte, so feeding 1.x-shaped data into a 2.x handler
+ * must produce a clear, recognisable error rather than a silent failure or
+ * undefined behaviour.
+ *
+ * We cannot include real 1.x-produced ciphertexts without depending on the
+ * 1.x release, so we synthesise input that LOOKS like 1.x output to a 2.x
+ * parser: a hex-encoded blob whose first byte is something other than the
+ * documented v2 magic.
+ *
+ * @requires extension openssl
+ * @requires extension sodium
+ */
+final class LegacyFormatRejectionTest extends TestCase
+{
+    private const KEY = 'legacy-format-test-key';
+
+    public function testOpenSSLRejectsV1ShapedCiphertext(): void
+    {
+        // Mimic 1.x output: hex-encoded blob without a 2-byte header, just
+        // bytes whose first byte happens to be != FORMAT_VERSION.
+        $fake = bin2hex(\chr(0x01) . random_bytes(64));
+
+        $handler = new OpenSSL(['key' => self::KEY]);
+
+        $this->expectException(EncryptionException::class);
+        $this->expectExceptionMessage('Unsupported ciphertext format version');
+
+        $handler->decrypt($fake);
+    }
+
+    public function testSodiumRejectsV1ShapedCiphertext(): void
+    {
+        $fake = bin2hex(\chr(0x01) . random_bytes(64));
+
+        $handler = new Sodium(['key' => self::KEY]);
+
+        $this->expectException(EncryptionException::class);
+        $this->expectExceptionMessage('Unsupported ciphertext format version');
+
+        $handler->decrypt($fake);
+    }
+
+    public function testErrorMessageGuidesUsersTowardsV2(): void
+    {
+        $fake = bin2hex(\chr(0x01) . random_bytes(64));
+        $handler = new OpenSSL(['key' => self::KEY]);
+
+        try {
+            $handler->decrypt($fake);
+            self::fail('expected EncryptionException for v1 input');
+        } catch (EncryptionException $e) {
+            $message = $e->getMessage();
+
+            self::assertStringContainsString(\sprintf('0x%02x', BaseHandler::FORMAT_VERSION), $message);
+            self::assertStringContainsString('1.x', $message);
+        }
+    }
+}