Caesar Cipher di PHP - Panduan Lengkap

iklan

Tentang Tutorial Ini

PHP adalah bahasa server-side yang sangat baik untuk mengimplementasikan algoritma enkripsi dan membangun sistem backend yang aman. Tutorial komprehensif ini akan memandu Anda mengimplementasikan Caesar cipher di PHP, mulai dari fungsi dasar hingga integrasi Laravel dan RESTful API endpoint. Baik Anda sedang membangun tools edukasi atau mempelajari konsep kriptografi dalam konteks backend, panduan ini mencakup semua yang Anda butuhkan. Sebelum masuk ke kode, silakan baca Panduan Pemula Caesar Cipher untuk memahami dasar-dasar enkripsinya.

Memahami Dasar-Dasarnya

Caesar cipher menggeser setiap huruf dalam plaintext sebanyak posisi tetap dalam alfabet. Di PHP, kita akan menggunakan fungsi ord() dan chr() bersama dengan aritmatika modular untuk mengimplementasikannya secara efisien untuk aplikasi server-side dan API.

Contoh:

Dengan pergeseran 3, "HELLO" menjadi "KHOOR"

Implementasi Dasar PHP

Mari kita mulai dengan fungsi enkripsi sederhana yang mendemonstrasikan konsep dasarnya: 

<?php
/**
 * Encrypts text using Caesar cipher with given shift value.
 *
 * @param string $text Text to encrypt
 * @param int $shift Number of positions to shift (1-25)
 * @return string Encrypted text
 */
function caesarEncrypt(string $text, int $shift): string
{
    $result = '';
    $textLength = strlen($text);

    for ($i = 0; $i < $textLength; $i++) {
        $char = $text[$i];

        // Check if character is uppercase letter
        if ($char >= 'A' && $char <= 'Z') {
            // Shift within uppercase letters (A-Z)
            $code = ord($char);
            $char = chr((($code - 65 + $shift) % 26) + 65);
        }
        // Check if character is lowercase letter
        elseif ($char >= 'a' && $char <= 'z') {
            // Shift within lowercase letters (a-z)
            $code = ord($char);
            $char = chr((($code - 97 + $shift) % 26) + 97);
        }
        // Keep non-alphabetic characters unchanged

        $result .= $char;
    }

    return $result;
}

// Example usage
$plaintext = "Hello World!";
$shift = 3;
$encrypted = caesarEncrypt($plaintext, $shift);

echo "Original: $plaintext\n";
echo "Encrypted: $encrypted\n";

// Output:
// Original: Hello World!
// Encrypted: Khoor Zruog!

Cara Kerja Implementasi PHP

Memahami fungsi-fungsi PHP utama yang digunakan dalam Caesar cipher:

Fungsi ord()

Mengembalikan nilai ASCII dari sebuah karakter. Untuk 'A', ord('A') mengembalikan 65. Ini penting untuk mengonversi huruf menjadi angka untuk operasi matematis.

Fungsi chr()

Mengonversi nilai ASCII kembali menjadi karakter. chr(65) mengembalikan 'A'. Digunakan untuk membangun kembali string terenkripsi setelah pergeseran.

Aritmatika Modulo (% 26)

Operator modulo membungkus huruf di sekitar alfabet. Ketika 'Z' + 1 melebihi alfabet, ia kembali ke 'A'. Sangat penting untuk menjaga batasan abjad.

Fungsi String

str_split(), strlen(), dan konkatenasi string memungkinkan pemrosesan teks yang efisien. PHP modern juga mendukung fungsi mb_* untuk Unicode.

Implementasi PHP 8+ Modern

Menggunakan fitur PHP modern termasuk type declaration, named argument, dan match expression: 

<?php

declare(strict_types=1);

/**
 * Modern PHP 8+ Caesar cipher implementation
 */
function caesarCipher(string $text, int $shift): string
{
    $shift = (($shift % 26) + 26) % 26; // Normalize shift

    return implode('', array_map(
        fn($char) => match(true) {
            ctype_upper($char) => chr(((ord($char) - 65 + $shift) % 26) + 65),
            ctype_lower($char) => chr(((ord($char) - 97 + $shift) % 26) + 97),
            default => $char
        },
        str_split($text)
    ));
}

function caesarDecrypt(string $text, int $shift): string
{
    return caesarCipher($text, -$shift);
}

// Example usage with modern features
$message = "PHP is powerful for backend development!";
$encrypted = caesarCipher($message, 7);
$decrypted = caesarDecrypt($encrypted, 7);

echo "Original: $message\n";
echo "Encrypted: $encrypted\n";
echo "Decrypted: $decrypted\n";

Integrasi dengan Laravel

Buat service class Laravel untuk operasi Caesar cipher dengan dependency injection dan error handling yang tepat: 

<?php

namespace App\Services;

/**
 * Caesar Cipher Service for Laravel applications
 */
class CaesarCipherService
{
    private int $shift;

    public function __construct(int $shift = 3)
    {
        $this->setShift($shift);
    }

    /**
     * Encrypt text using Caesar cipher
     */
    public function encrypt(string $text): string
    {
        return $this->transform($text, $this->shift);
    }

    /**
     * Decrypt text using Caesar cipher
     */
    public function decrypt(string $text): string
    {
        return $this->transform($text, -$this->shift);
    }

    /**
     * Transform text with given shift
     */
    private function transform(string $text, int $shift): string
    {
        $result = '';
        $shift = (($shift % 26) + 26) % 26;

        foreach (str_split($text) as $char) {
            if (ctype_upper($char)) {
                $result .= chr(((ord($char) - 65 + $shift) % 26) + 65);
            } elseif (ctype_lower($char)) {
                $result .= chr(((ord($char) - 97 + $shift) % 26) + 97);
            } else {
                $result .= $char;
            }
        }

        return $result;
    }

    /**
     * Set new shift value
     */
    public function setShift(int $shift): self
    {
        if ($shift < 0 || $shift > 25) {
            throw new \InvalidArgumentException(
                'Shift must be between 0 and 25'
            );
        }

        $this->shift = $shift;
        return $this;
    }

    /**
     * Get current shift value
     */
    public function getShift(): int
    {
        return $this->shift;
    }
}

Membangun RESTful API Endpoint

Buat Laravel API controller untuk mengekspos fungsionalitas Caesar cipher melalui HTTP endpoint: 

<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Services\CaesarCipherService;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;

class CaesarCipherController extends Controller
{
    public function __construct(
        private CaesarCipherService $cipherService
    ) {}

    /**
     * Encrypt text using Caesar cipher
     *
     * @param Request $request
     * @return JsonResponse
     */
    public function encrypt(Request $request): JsonResponse
    {
        $validator = Validator::make($request->all(), [
            'text' => 'required|string|max:10000',
            'shift' => 'required|integer|min:1|max:25'
        ]);

        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'errors' => $validator->errors()
            ], 422);
        }

        try {
            $this->cipherService->setShift($request->input('shift'));
            $encrypted = $this->cipherService->encrypt(
                $request->input('text')
            );

            return response()->json([
                'success' => true,
                'data' => [
                    'original' => $request->input('text'),
                    'encrypted' => $encrypted,
                    'shift' => $request->input('shift')
                ]
            ]);
        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => 'Encryption failed: ' . $e->getMessage()
            ], 500);
        }
    }

    /**
     * Decrypt text using Caesar cipher
     *
     * @param Request $request
     * @return JsonResponse
     */
    public function decrypt(Request $request): JsonResponse
    {
        $validator = Validator::make($request->all(), [
            'text' => 'required|string|max:10000',
            'shift' => 'required|integer|min:1|max:25'
        ]);

        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'errors' => $validator->errors()
            ], 422);
        }

        try {
            $this->cipherService->setShift($request->input('shift'));
            $decrypted = $this->cipherService->decrypt(
                $request->input('text')
            );

            return response()->json([
                'success' => true,
                'data' => [
                    'encrypted' => $request->input('text'),
                    'decrypted' => $decrypted,
                    'shift' => $request->input('shift')
                ]
            ]);
        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => 'Decryption failed: ' . $e->getMessage()
            ], 500);
        }
    }
}

// routes/api.php
// Route::post('/caesar/encrypt', [CaesarCipherController::class, 'encrypt']);
// Route::post('/caesar/decrypt', [CaesarCipherController::class, 'decrypt']);

Implementasi Berbasis Class Lanjutan

Untuk aplikasi produksi, pendekatan berbasis class yang komprehensif memberikan organisasi, validasi, dan reusabilitas yang lebih baik: 

<?php

declare(strict_types=1);

/**
 * Comprehensive Caesar Cipher implementation with advanced features
 */
class CaesarCipher
{
    private int $shift;
    private string $alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';

    public function __construct(int $shift = 3)
    {
        $this->setShift($shift);
    }

    /**
     * Encrypt text
     */
    public function encrypt(string $text): string
    {
        return $this->transform($text, $this->shift);
    }

    /**
     * Decrypt text
     */
    public function decrypt(string $text): string
    {
        return $this->transform($text, -$this->shift);
    }

    /**
     * Transform text with given shift
     */
    private function transform(string $text, int $shift): string
    {
        $result = '';
        $shift = (($shift % 26) + 26) % 26;

        foreach (str_split($text) as $char) {
            if (ctype_upper($char)) {
                $result .= chr(((ord($char) - 65 + $shift) % 26) + 65);
            } elseif (ctype_lower($char)) {
                $result .= chr(((ord($char) - 97 + $shift) % 26) + 97);
            } else {
                $result .= $char;
            }
        }

        return $result;
    }

    /**
     * Brute force attack - try all possible shifts
     *
     * @param string $encryptedText Text to decrypt
     * @return array All 26 possible decryptions
     */
    public function bruteForce(string $encryptedText): array
    {
        $results = [];

        for ($shift = 0; $shift < 26; $shift++) {
            $results[] = [
                'shift' => $shift,
                'text' => $this->transform($encryptedText, -$shift)
            ];
        }

        return $results;
    }

    /**
     * Encrypt/decrypt file contents
     */
    public function processFile(
        string $inputFile,
        string $outputFile,
        bool $encrypt = true
    ): bool {
        if (!file_exists($inputFile)) {
            throw new \RuntimeException("Input file not found");
        }

        $content = file_get_contents($inputFile);
        $processed = $encrypt
            ? $this->encrypt($content)
            : $this->decrypt($content);

        return file_put_contents($outputFile, $processed) !== false;
    }

    /**
     * Set shift value with validation
     */
    public function setShift(int $shift): self
    {
        $this->shift = (($shift % 26) + 26) % 26;
        return $this;
    }

    /**
     * Get current shift value
     */
    public function getShift(): int
    {
        return $this->shift;
    }

    /**
     * ROT13 - Caesar cipher with shift of 13
     */
    public static function rot13(string $text): string
    {
        return (new self(13))->encrypt($text);
    }

    /**
     * Check if text is likely encrypted with Caesar cipher
     */
    public function isLikelyEncrypted(string $text): bool
    {
        // Simple heuristic: check letter frequency distribution
        $letterCount = preg_match_all('/[a-zA-Z]/', $text);
        if ($letterCount === 0) {
            return false;
        }

        // Count common English letters (E, T, A, O, I, N)
        $commonLetters = preg_match_all('/[etaoinETAOIN]/', $text);
        $ratio = $commonLetters / $letterCount;

        // If ratio is very low, text might be encrypted
        return $ratio < 0.3;
    }
}

// Example usage
$cipher = new CaesarCipher(5);

// Encryption
$message = "PHP is great for backend development!";
$encrypted = $cipher->encrypt($message);
echo "Original: $message\n";
echo "Encrypted: $encrypted\n";

// Decryption
$decrypted = $cipher->decrypt($encrypted);
echo "Decrypted: $decrypted\n";

// Brute force attack
$mysteryText = "Mjqqt Btwqi";
echo "\nBrute force results:\n";
foreach (array_slice($cipher->bruteForce($mysteryText), 0, 5) as $result) {
    echo "Shift {$result['shift']}: {$result['text']}\n";
}

// ROT13
$rot13Text = CaesarCipher::rot13("Hello World");
echo "\nROT13: $rot13Text\n";

Best Practice PHP

Implementasi kita mengikuti standar dan best practice PHP modern:

  • Type Declaration: Gunakan strict typing dengan declare(strict_types=1) untuk keamanan kode yang lebih baik
  • Komentar PHPDoc: Dokumentasi yang jelas menjelaskan parameter, return type, dan exception
  • Standar Coding PSR-12: Ikuti standar PHP-FIG untuk gaya kode yang konsisten
  • Error Handling: Gunakan exception untuk kondisi error daripada return code
  • Validasi Input: Selalu validasi dan sanitasi input pengguna, terutama dalam konteks web
  • Dependency Injection: Gunakan service container Laravel untuk testability yang lebih baik

Kesalahan Umum yang Harus Dihindari

Perhatikan kesalahan-kesalahan umum ini saat mengimplementasikan Caesar cipher di PHP:

  • Masalah Character Encoding: Selalu gunakan encoding UTF-8 dan pertimbangkan fungsi mb_* untuk karakter internasional
  • Lupa Modulo: Tanpa % 26, kode karakter bisa melebihi rentang ASCII yang valid
  • Tidak Menormalisasi Shift: Tangani shift negatif dan nilai > 26 dengan benar
  • Case Sensitivity: Tangani huruf besar dan kecil dengan nilai base yang berbeda (65 untuk A, 97 untuk a)
  • Kesalahpahaman Keamanan: Jangan pernah gunakan Caesar cipher untuk keamanan nyata - ini hanya untuk edukasi

Penggunaan Command-Line Interface (CLI)

Script PHP dapat dijalankan dari command line untuk batch processing dan automation: 

<?php
// caesar-cli.php - Command-line Caesar cipher tool

declare(strict_types=1);

require_once 'CaesarCipher.php';

function displayHelp(): void
{
    echo <<<HELP
    Caesar Cipher CLI Tool

    Usage:
        php caesar-cli.php [operation] [text] [shift]

    Operations:
        encrypt    Encrypt the provided text
        decrypt    Decrypt the provided text
        brute      Try all shifts (brute force attack)

    Examples:
        php caesar-cli.php encrypt "Hello World" 3
        php caesar-cli.php decrypt "Khoor Zruog" 3
        php caesar-cli.php brute "Mjqqt Btwqi"

    HELP;
}

// Parse command-line arguments
if ($argc < 2) {
    displayHelp();
    exit(1);
}

$operation = $argv[1] ?? '';
$text = $argv[2] ?? '';
$shift = isset($argv[3]) ? (int)$argv[3] : 3;

try {
    $cipher = new CaesarCipher($shift);

    switch ($operation) {
        case 'encrypt':
            if (empty($text)) {
                throw new InvalidArgumentException('Text is required');
            }
            $result = $cipher->encrypt($text);
            echo "Encrypted: $result\n";
            break;

        case 'decrypt':
            if (empty($text)) {
                throw new InvalidArgumentException('Text is required');
            }
            $result = $cipher->decrypt($text);
            echo "Decrypted: $result\n";
            break;

        case 'brute':
            if (empty($text)) {
                throw new InvalidArgumentException('Text is required');
            }
            echo "Brute force results:\n";
            foreach ($cipher->bruteForce($text) as $result) {
                printf(
                    "Shift %2d: %s\n",
                    $result['shift'],
                    $result['text']
                );
            }
            break;

        default:
            displayHelp();
            exit(1);
    }
} catch (Exception $e) {
    echo "Error: " . $e->getMessage() . "\n";
    exit(1);
}

Kasus Penggunaan Praktis

Implementasi Caesar cipher PHP sangat cocok untuk:

Membangun aplikasi web edukasi dan API
Membuat backend service untuk tools cipher
Mengimplementasikan mekanik game puzzle
Belajar fundamental kriptografi di PHP
Mengajarkan praktik coding yang aman
Memproses tugas enkripsi batch melalui CLI

Pertimbangan Performa

Implementasi ini memiliki kompleksitas waktu O(n) di mana n adalah panjang teks. Untuk performa optimal di PHP:

  • Gunakan str_split() dan fungsi array daripada iterasi karakter per karakter
  • Pertimbangkan caching alfabet terenkripsi untuk operasi massal
  • Gunakan ekstensi mb_string untuk penanganan teks UTF-8
  • Untuk file besar, proses dalam chunk untuk mengelola penggunaan memori
  • Aktifkan OPcache di produksi untuk bytecode caching
  • Profile dengan Xdebug atau Blackfire untuk peluang optimasi

Testing Implementasi Anda

Test case PHPUnit yang komprehensif untuk memverifikasi Caesar cipher Anda berfungsi dengan benar: 

<?php

namespace Tests\Unit;

use PHPUnit\Framework\TestCase;
use App\Services\CaesarCipherService;

class CaesarCipherTest extends TestCase
{
    private CaesarCipherService $cipher;

    protected function setUp(): void
    {
        $this->cipher = new CaesarCipherService(3);
    }

    /** @test */
    public function it_encrypts_basic_text_correctly()
    {
        $this->assertEquals('DEF', $this->cipher->encrypt('ABC'));
    }

    /** @test */
    public function it_handles_wrap_around_from_z_to_a()
    {
        $this->assertEquals('ABC', $this->cipher->encrypt('XYZ'));
    }

    /** @test */
    public function it_preserves_case()
    {
        $this->assertEquals('Khoor', $this->cipher->encrypt('Hello'));
    }

    /** @test */
    public function it_keeps_non_alphabetic_characters_unchanged()
    {
        $encrypted = $this->cipher->encrypt('Hello, World!');
        $this->assertEquals('Khoor, Zruog!', $encrypted);
    }

    /** @test */
    public function encryption_and_decryption_are_reversible()
    {
        $original = 'PHP Programming';
        $encrypted = $this->cipher->encrypt($original);
        $decrypted = $this->cipher->decrypt($encrypted);

        $this->assertEquals($original, $decrypted);
    }

    /** @test */
    public function it_handles_shift_of_zero()
    {
        $this->cipher->setShift(0);
        $this->assertEquals('Test', $this->cipher->encrypt('Test'));
    }

    /** @test */
    public function it_throws_exception_for_invalid_shift()
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->cipher->setShift(26);
    }

    /** @test */
    public function it_handles_empty_string()
    {
        $this->assertEquals('', $this->cipher->encrypt(''));
    }

    /** @test */
    public function it_handles_long_text()
    {
        $longText = str_repeat('ABC ', 1000);
        $encrypted = $this->cipher->encrypt($longText);
        $decrypted = $this->cipher->decrypt($encrypted);

        $this->assertEquals($longText, $decrypted);
    }
}

Ide Pengembangan

Kembangkan implementasi ini dengan fitur tambahan:

Tambahkan dukungan untuk alfabet khusus (karakter non-Latin)
Implementasikan deteksi bahasa otomatis
Buat Laravel Artisan command untuk operasi CLI
Bangun RESTful API dengan rate limiting
Tambahkan penyimpanan database untuk riwayat enkripsi
Implementasikan visualisasi analisis frekuensi
Buat Laravel Blade component untuk UI
Tambahkan dukungan queue untuk batch processing

Sumber Daya Terkait

Lanjutkan perjalanan belajar kriptografi dan PHP Anda:

Kesimpulan

Anda telah mempelajari cara mengimplementasikan Caesar cipher di PHP mulai dari fungsi dasar hingga integrasi Laravel dan RESTful API. Kita membahas implementasi klasik, sintaks PHP 8+ modern, service class, API endpoint, dan command-line tool. Pengetahuan ini membentuk fondasi untuk membangun tools enkripsi server-side yang lebih sophisticated dan memahami kriptografi backend.

Praktikkan dengan membuat Laravel service Anda sendiri, bangun API lengkap dengan authentication, atau eksperimen dengan algoritma enkripsi yang lebih kompleks. Meskipun Caesar cipher tidak cocok untuk mengamankan data sensitif, ia memberikan pengenalan yang sangat baik terhadap konsep kriptografi dan manipulasi string PHP untuk backend developer.