Kriptografi ROT13 Menggunakan Java (Source Code)

ROT13 (rotate by 13 places) adalah algoritma substitusi sederhana yang mengganti setiap huruf dengan huruf ke-13 setelahnya di alfabet. ROT13 merupakan kasus khusus dari Caesar cipher dengan pergeseran 13. Algoritma ini sering dipakai di forum internet untuk menyembunyikan spoiler atau jawaban teka-teki agar tidak terbaca sekilas.

Di artikel ini kita akan:

1. Memahami cara kerja ROT13 dan mengapa enkripsi sekaligus dekripsinya memakai fungsi yang sama
2. Membuat program ROT13 dengan Java
3. Mengembangkannya menjadi Caesar cipher dengan pergeseran bebas
4. Mencoba variasi sandi berkunci waktu, yaitu modifikasi Caesar cipher yang kuncinya diambil dari jam dan menit

Cara kerja ROT13

Alfabet Latin punya 26 huruf. ROT13 memasangkan setengah alfabet pertama dengan setengah kedua:

Pemetaan ini berlaku dua arah: N menjadi A, O menjadi B, dan seterusnya. Karena 13 + 13 = 26 (satu putaran penuh), menjalankan ROT13 dua kali mengembalikan teks semula. Itulah sebabnya fungsi enkripsi dan dekripsi ROT13 sama persis.

Secara matematis, untuk huruf pada posisi x (A = 0, B = 1, …, Z = 25):

E(x) = (x + 13) mod 26

Angka, spasi, dan tanda baca tidak diubah.

Source code ROT13 di Java

public class Rot13 {

    public static String rot13(String teks) {
        StringBuilder hasil = new StringBuilder(teks.length());
        for (char c : teks.toCharArray()) {
            if (c >= 'a' && c <= 'z') {
                hasil.append((char) ('a' + (c - 'a' + 13) % 26));
            } else if (c >= 'A' && c <= 'Z') {
                hasil.append((char) ('A' + (c - 'A' + 13) % 26));
            } else {
                hasil.append(c); // angka, spasi, dan tanda baca tidak diubah
            }
        }
        return hasil.toString();
    }

    public static void main(String[] args) {
        String plain = "Belajar Kriptografi di Ngodingdulu!";
        String cipher = rot13(plain);
        String dekripsi = rot13(cipher); // ROT13 dua kali = teks semula

        System.out.println("Plaintext : " + plain);
        System.out.println("Ciphertext: " + cipher);
        System.out.println("Dekripsi  : " + dekripsi);
    }
}

Output program:

Plaintext : Belajar Kriptografi di Ngodingdulu!
Ciphertext: Orynwne Xevcgbtensv qv Atbqvatqhyh!
Dekripsi  : Belajar Kriptografi di Ngodingdulu!

Penjelasan bagian pentingnya:

• c - 'a' mengubah huruf menjadi angka 0–25, misalnya 'c' - 'a' = 2.
• + 13) % 26 menggeser 13 posisi, dan % 26 membuat hitungan kembali ke awal setelah Z.
• 'a' + … mengubah angka kembali menjadi huruf.
• Huruf besar dan kecil diproses terpisah, sehingga kapitalisasi tetap terjaga.

Mengembangkan ke Caesar cipher

ROT13 hanyalah Caesar cipher dengan kunci 13. Dengan sedikit perubahan, kita bisa membuat versi dengan pergeseran bebas:

public static String geser(String teks, int kunci) {
    int k = ((kunci % 26) + 26) % 26; // normalisasi, termasuk kunci negatif
    StringBuilder hasil = new StringBuilder(teks.length());
    for (char c : teks.toCharArray()) {
        if (Character.isLowerCase(c) && c <= 'z') {
            hasil.append((char) ('a' + (c - 'a' + k) % 26));
        } else if (Character.isUpperCase(c) && c <= 'Z') {
            hasil.append((char) ('A' + (c - 'A' + k) % 26));
        } else {
            hasil.append(c);
        }
    }
    return hasil.toString();
}

// enkripsi: geser(plain, 3)
// dekripsi: geser(cipher, -3)

Berbeda dengan ROT13, untuk kunci selain 13 dekripsinya memakai kunci negatif.

Variasi: sandi berkunci waktu

Versi awal artikel ini memuat program buatan penulis yang mengembangkan ide ROT13 menjadi sandi dengan kunci berupa jam dan menit saat pesan dienkripsi, misalnya 20:59. Cara kerjanya:

1. Karakter yang dipakai adalah 95 karakter ASCII yang bisa dicetak, dari spasi (kode 32) sampai ~ (kode 126). Jadi bukan hanya huruf, tetapi juga angka dan tanda baca.
2. Karakter di posisi genap digeser sebanyak nilai jam, dan karakter di posisi ganjil digeser sebanyak nilai menit.
3. Jam dan menit (4 digit) disamarkan dengan pergeseran 13, lalu ditaruh sebagai header di depan ciphertext, sehingga penerima bisa mendekripsi tanpa diberi tahu kuncinya.

Gambar di atas adalah tabel karakter ASCII yang menjadi dasar pergeseran. Berikut versi kode yang sudah dirapikan:

public class SandiWaktu {

    // karakter ASCII yang bisa dicetak: spasi (32) sampai ~ (126) = 95 karakter
    private static final int AWAL = 32;
    private static final int JUMLAH = 95;

    private static char geser(char c, int k) {
        if (c < AWAL || c >= AWAL + JUMLAH) return c; // di luar tabel: tidak diubah
        int posisi = c - AWAL;
        return (char) (AWAL + ((posisi + k) % JUMLAH + JUMLAH) % JUMLAH);
    }

    /** kunci berformat "HH:MM", misalnya jam saat pesan dienkripsi: "20:59" */
    public static String enkripsi(String plain, String kunci) {
        String[] bagian = kunci.split(":");
        int jam = Integer.parseInt(bagian[0]);
        int menit = Integer.parseInt(bagian[1]);

        StringBuilder hasil = new StringBuilder();
        // 1) header 4 karakter: jam & menit yang disamarkan dengan geser 13
        for (char c : String.format("%02d%02d", jam, menit).toCharArray()) {
            hasil.append(geser(c, 13));
        }
        // 2) isi: posisi genap digeser sebanyak jam, posisi ganjil sebanyak menit
        for (int i = 0; i < plain.length(); i++) {
            hasil.append(geser(plain.charAt(i), i % 2 == 0 ? jam : menit));
        }
        return hasil.toString();
    }

    public static String dekripsi(String cipher) {
        // baca kembali jam & menit dari header
        StringBuilder hhmm = new StringBuilder();
        for (char c : cipher.substring(0, 4).toCharArray()) {
            hhmm.append(geser(c, -13));
        }
        int jam = Integer.parseInt(hhmm.substring(0, 2));
        int menit = Integer.parseInt(hhmm.substring(2, 4));

        String isi = cipher.substring(4);
        StringBuilder hasil = new StringBuilder();
        for (int i = 0; i < isi.length(); i++) {
            hasil.append(geser(isi.charAt(i), -(i % 2 == 0 ? jam : menit)));
        }
        return hasil.toString();
    }

    public static void main(String[] args) {
        String plain = "lembaga peduli pendidikan";
        String kunci = "20:59";

        String cipher = enkripsi(plain, kunci);
        System.out.println("Plaintext : " + plain);
        System.out.println("Kunci     : " + kunci);
        System.out.println("Ciphertext: " + cipher);
        System.out.println("Dekripsi  : " + dekripsi(cipher));
    }
}

Output program:

Plaintext : lembaga peduli pendidikan
Kunci     : 20:59
Ciphertext: ?=BF!A">uCu[%AxQ!E4LyJxExE =#
Dekripsi  : lembaga peduli pendidikan

Empat karakter pertama (?=BF) adalah header berisi 2059 yang disamarkan. Perhatikan juga bahwa huruf e yang sama menghasilkan karakter berbeda tergantung posisinya, ganjil atau genap. Inilah yang membuat sandi ini sedikit lebih sulit ditebak daripada ROT13.

Seberapa aman ROT13?

ROT13 sama sekali tidak aman untuk melindungi data, dan memang tidak dirancang untuk itu:

• Kuncinya selalu 13 dan diketahui semua orang.
• Caesar cipher hanya punya 25 kemungkinan kunci, jadi bisa dibobol dengan mencoba semuanya (brute force) dalam sekejap.
• Pola huruf tetap terlihat, sehingga bisa dipecahkan dengan analisis frekuensi.

Variasi berkunci waktu juga tidak aman, karena kuncinya ikut tersimpan di dalam ciphertext. Siapa pun yang tahu algoritmanya bisa langsung mendekripsi. Variasi ini bagus untuk latihan logika pemrograman dan memahami konsep substitusi, tetapi bukan untuk keamanan sungguhan.

Untuk data penting, gunakan algoritma modern yang sudah teruji seperti AES lewat library standar Java (javax.crypto). Contoh algoritma lain yang lebih kuat ada di seri ini: Vernam Cipher, RC4, dan RC6.

Pertanyaan yang sering diajukan

Apa bedanya ROT13 dan Caesar cipher? Caesar cipher menggeser huruf sejauh k posisi, dengan k bisa 1 sampai 25. ROT13 adalah Caesar cipher dengan k = 13, satu-satunya nilai yang membuat enkripsi dan dekripsi memakai fungsi yang sama.

Mengapa angka tidak ikut berubah di ROT13? ROT13 hanya didefinisikan untuk 26 huruf alfabet. Untuk angka ada varian lain seperti ROT5 (0–9 digeser 5), dan untuk semua karakter ASCII yang bisa dicetak ada ROT47.

Bagaimana menjalankan kode di atas tanpa NetBeans? Dengan JDK 11 ke atas, simpan kode sebagai Rot13.java, lalu jalankan java Rot13.java dari terminal. Panduan instalasi JDK ada di artikel Cara Cek Compiler Java.

Kesimpulan

ROT13 menggeser setiap huruf 13 posisi, dan karena alfabet punya 26 huruf, fungsi yang sama dipakai untuk enkripsi dan dekripsi. Implementasinya di Java cukup beberapa baris dengan operasi % 26. ROT13 dan variasinya sangat baik untuk belajar konsep kriptografi klasik, tetapi untuk melindungi data sungguhan gunakan algoritma modern seperti AES.