Memahami File .crt, .key, dan Implementasi SSL/TLS pada Web Server & Database MySQL

November 4, 2026 · 34 min read

Ucup TopekoX

TimposuLabs creator

Kriptografi

Ketika membangun sebuah aplikasi web, keamanan komunikasi antara client dan server merupakan salah satu aspek penting yang tidak boleh diabaikan.

Bayangkan ketika pengguna membuka sebuah aplikasi melalui browser. Pengguna mengirimkan informasi seperti username, password, token autentikasi, atau data pribadi ke server.

Jika komunikasi tersebut tidak dilindungi, informasi yang dikirimkan berpotensi disadap oleh pihak lain ketika melewati jaringan.

Untuk mengatasi masalah tersebut, kita menggunakan teknologi SSL/TLS (Secure Sockets Layer / Transport Layer Security).

SSL/TLS merupakan protokol keamanan yang digunakan untuk melindungi komunikasi data antara dua sistem melalui jaringan.

Dalam implementasinya, SSL/TLS menggunakan sertifikat digital dan pasangan kunci kriptografi. Beberapa file yang sering ditemukan adalah:

.crt - Certificate File.
.key - Private Key File.
.csr - Certificate Signing Request.
.pem - Privacy Enhanced Mail.
ca.crt - Certificate Authority Certificate.

Pada materi ini, kita akan mempelajari bagaimana file-file tersebut bekerja, bagaimana membuat sertifikat sendiri menggunakan OpenSSL, serta bagaimana mengimplementasikannya pada Nginx, Apache, Node.js, dan database MySQL.

1.1 Apa Itu SSL dan TLS?

SSL merupakan protokol keamanan yang dikembangkan untuk melindungi komunikasi jaringan. Namun, SSL versi lama sudah tidak aman dan tidak lagi direkomendasikan.

Sebagai penerusnya, digunakan TLS (Transport Layer Security).

Saat ini, istilah SSL masih sering digunakan dalam percakapan teknis, meskipun teknologi yang sebenarnya digunakan adalah TLS.

Contohnya:

Istilah	Penjelasan
SSL	Protokol keamanan generasi lama.
TLS	Penerus SSL yang digunakan saat ini.
HTTPS	HTTP yang diamankan menggunakan TLS.
FTPS	FTP yang diamankan menggunakan TLS.
MySQL SSL/TLS	Mekanisme enkripsi komunikasi antara client dan server MySQL.

info

Ketika seseorang mengatakan memasang SSL Certificate pada website, biasanya yang dimaksud adalah memasang sertifikat digital untuk mengaktifkan HTTPS menggunakan TLS.

1.2 Apa Itu File .crt?

File .crt merupakan file sertifikat digital yang berisi informasi identitas pemilik sertifikat dan public key.

Sertifikat ini dapat digunakan untuk membuktikan identitas server kepada client.

Informasi yang biasanya terdapat dalam sertifikat meliputi:

Common Name (CN).
Subject Alternative Name (SAN).
Public Key.
Issuer atau penerbit sertifikat.
Masa berlaku sertifikat.
Signature dari Certificate Authority (CA).

Contoh isi informasi sertifikat:

Certificate:
    Data:
        Version: 3
        Serial Number: 123456789
        Signature Algorithm: sha256WithRSAEncryption
        Issuer: CN=My Local CA
        Subject: CN=localhost
        Subject Public Key Info:
            Public Key Algorithm: rsaEncryption
        X509v3 extensions:
            X509v3 Subject Alternative Name:
                DNS:localhost, IP Address:127.0.0.1
        Validity:
            Not Before: Nov 04 00:00:00 2026 GMT
            Not After : Nov 04 00:00:00 2027 GMT

File .crt bukan sekadar file konfigurasi. File ini merupakan bukti identitas digital yang dapat diverifikasi oleh client.

1.3 Apa Itu File .key?

File .key merupakan file yang menyimpan private key atau kunci privat.

Private key digunakan dalam operasi kriptografi yang berkaitan dengan identitas server, termasuk proses pembuktian kepemilikan sertifikat dan pembentukan koneksi TLS.

Berbeda dengan file .crt, file .key harus dijaga kerahasiaannya.

Contoh format private key:

-----BEGIN PRIVATE KEY-----
MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBK...
...
-----END PRIVATE KEY-----

Format lain yang mungkin ditemukan:

-----BEGIN RSA PRIVATE KEY-----
MIIEowIBAAKCAQEA...
...
-----END RSA PRIVATE KEY-----

danger

Jangan pernah membagikan file .key ke GitHub publik, mengirimkannya melalui chat tanpa perlindungan, atau menyimpannya di direktori yang dapat diakses pengguna umum.

Jika private key bocor, pihak lain berpotensi menyalahgunakannya untuk menyamar sebagai server yang sah atau melakukan serangan lain sesuai kondisi sertifikat dan infrastrukturnya.

1.4 Perbedaan File .crt dan .key

Untuk memudahkan pemahaman, bayangkan sertifikat digital seperti kartu identitas.

.crt adalah kartu identitas yang dapat diperlihatkan kepada orang lain.
.key adalah bukti rahasia yang digunakan untuk membuktikan bahwa kartu identitas tersebut benar-benar milik Anda.

Perbandingan:

Aspek	`.crt`	`.key`
Nama	Certificate	Private Key
Jenis	Public	Private
Isi	Identitas dan public key	Private key
Boleh dibagikan	Ya, umumnya	Tidak
Fungsi	Identifikasi dan verifikasi	Operasi kriptografi privat
Digunakan oleh	Client dan server	Pemilik identitas/server
Risiko kebocoran	Relatif rendah	Sangat tinggi
Contoh	server.crt	server.key

1.5 Apa Itu File .csr?

CSR merupakan singkatan dari Certificate Signing Request.

File ini dibuat ketika seseorang ingin mendapatkan sertifikat digital dari Certificate Authority.

Alur sederhananya:

Administrator membuat private key.
Administrator membuat CSR menggunakan private key.
CSR dikirimkan ke Certificate Authority.
CA memverifikasi permintaan sertifikat.
CA menerbitkan sertifikat .crt.

Contoh:

CSR tidak mengandung private key. File ini berisi informasi identitas dan public key yang akan dimasukkan ke sertifikat.

1.6 Apa Itu Certificate Authority (CA)?

Certificate Authority merupakan pihak yang memiliki kewenangan menerbitkan dan menandatangani sertifikat digital.

CA bertugas memastikan bahwa sertifikat yang diterbitkan dapat dipercaya oleh client yang memiliki CA tersebut dalam daftar kepercayaannya.

Contoh Certificate Authority publik:

Let's Encrypt.
DigiCert.
Sectigo.
GlobalSign.

Selain CA publik, kita juga dapat membuat CA sendiri untuk kebutuhan internal perusahaan, laboratorium, development, maupun komunikasi database.

Contoh struktur sertifikat:

Dalam lingkungan internal, struktur tersebut juga dapat dibuat lebih sederhana:

File ca.crt merupakan sertifikat publik CA yang digunakan client untuk memverifikasi sertifikat yang ditandatangani oleh CA tersebut.

Perlu diperhatikan bahwa ca.key merupakan private key milik CA dan harus dijaga jauh lebih ketat daripada sertifikat publiknya.

2. Mengenal Format Sertifikat Digital

Sebelum melakukan implementasi, kita perlu memahami beberapa format file yang sering ditemukan dalam pengelolaan SSL/TLS.

2.1 Format PEM

PEM merupakan format encoding yang umum digunakan untuk menyimpan sertifikat dan kunci kriptografi dalam bentuk teks Base64.

Contohnya:

-----BEGIN CERTIFICATE-----
MIID...
-----END CERTIFICATE-----

Private key juga dapat menggunakan format PEM:

-----BEGIN PRIVATE KEY-----
MIIE...
-----END PRIVATE KEY-----

2.2 Perbedaan PEM, CRT, CER, dan KEY

Ekstensi	Keterangan
`.pem`	Format encoding yang dapat berisi sertifikat atau private key.
`.crt`	Umumnya digunakan untuk menyimpan sertifikat digital.
`.cer`	Sertifikat digital, dapat menggunakan DER atau PEM.
`.key`	Umumnya digunakan untuk menyimpan private key.
`.csr`	Certificate Signing Request.
`.p12`	Container PKCS#12 yang dapat berisi sertifikat dan private key.
`.pfx`	Umumnya merupakan ekstensi lain untuk container PKCS#12.

note

Ekstensi file tidak selalu menentukan format encoding di dalamnya. File .crt bisa saja menggunakan format PEM maupun DER.

Untuk memastikan formatnya, kita dapat menggunakan perintah OpenSSL.

2.3 Mengenali Format Menggunakan OpenSSL

Periksa sertifikat:

openssl x509 -in server.crt -text -noout

Periksa private key:

openssl pkey -in server.key -text -noout

Periksa CSR:

openssl req -in server.csr -text -noout

Jika sertifikat menggunakan DER, gunakan:

openssl x509 -inform DER -in server.cer -text -noout

Untuk mengubah DER menjadi PEM:

openssl x509 -inform DER -in server.cer -out server.crt

3. Mengenal OpenSSL

OpenSSL merupakan toolkit kriptografi yang digunakan untuk mengelola sertifikat digital, private key, public key, CSR, dan berbagai kebutuhan keamanan jaringan.

OpenSSL dapat digunakan untuk:

Membuat private key.
Membuat sertifikat self-signed.
Membuat Certificate Authority.
Membuat CSR.
Memeriksa sertifikat.
Menguji koneksi TLS.
Mengubah format sertifikat.

3.1 Memeriksa Instalasi OpenSSL

Linux:

openssl version

Ubuntu/Debian:

sudo apt update
sudo apt install openssl -y

macOS menggunakan Homebrew:

brew install openssl

Windows:

Kita dapat menggunakan OpenSSL melalui Git Bash, WSL, atau instalasi OpenSSL untuk Windows.

Periksa kembali:

openssl version -a

Contoh hasil:

OpenSSL 3.x.x

4. Praktik Mandiri: Membuat Sertifikat Self-Signed

Pada bagian ini, kita akan membuat sertifikat SSL/TLS sendiri menggunakan OpenSSL.

Praktik ini menggunakan localhost sehingga cocok untuk:

Pengembangan aplikasi.
Testing HTTPS.
Laboratorium DevOps.
Simulasi konfigurasi web server.
Pembelajaran SSL/TLS.

4.1 Apa Itu Self-Signed Certificate?

Self-Signed Certificate adalah sertifikat digital yang ditandatangani menggunakan private key miliknya sendiri, bukan oleh CA publik yang sudah dipercaya browser.

Dengan kata lain, kita bertindak sebagai penerbit sertifikat sekaligus pemilik sertifikat.

Kelebihannya:

Gratis.
Tidak membutuhkan domain publik.
Cocok untuk localhost.
Dapat dibuat sendiri.

Kekurangannya:

Tidak otomatis dipercaya browser.
Tidak cocok untuk layanan publik.
Membutuhkan konfigurasi kepercayaan secara manual.

4.2 Membuat Direktori SSL

Buat direktori kerja:

mkdir ssl-lab
cd ssl-lab

Buat direktori untuk menyimpan sertifikat:

mkdir certs

Struktur direktori:

ssl-lab/
└── certs/

4.3 Membuat Private Key

Buat private key menggunakan algoritma RSA dengan panjang 2048 bit:

openssl genrsa -out certs/server.key 2048

Penjelasan:

Parameter	Fungsi
`genrsa`	Membuat RSA private key.
`-out`	Menentukan nama file output.
`2048`	Panjang kunci dalam bit.

Periksa private key:

openssl pkey -in certs/server.key -check -noout

Jika berhasil:

Key is valid

4.4 Membuat Sertifikat Self-Signed

Setelah memiliki private key, kita dapat membuat sertifikat digital.

Gunakan perintah berikut:

openssl req -x509 \
  -new \
  -key certs/server.key \
  -sha256 \
  -days 365 \
  -out certs/server.crt \
  -subj "/C=ID/ST=Central Sulawesi/L=Palu/O=DevOps Lab/OU=Development/CN=localhost" \
  -addext "subjectAltName=DNS:localhost,IP:127.0.0.1"

Penjelasan parameter:

Parameter	Fungsi
`req`	Menjalankan fungsi pengelolaan CSR.
`-x509`	Menghasilkan sertifikat X.509 secara langsung.
`-new`	Membuat permintaan sertifikat baru.
`-key`	Menggunakan private key yang sudah dibuat.
`-sha256`	Menggunakan SHA-256 untuk signature.
`-days 365`	Masa berlaku sertifikat 365 hari.
`-out`	Menentukan file sertifikat output.
`-subj`	Menentukan identitas pemilik sertifikat.
`-addext`	Menambahkan ekstensi sertifikat.

Perhatikan bagian:

subjectAltName=DNS:localhost,IP:127.0.0.1

SAN atau Subject Alternative Name digunakan untuk menentukan nama domain maupun alamat IP yang berlaku untuk sertifikat.

SAN sangat penting karena browser dan client TLS modern memeriksa identitas server menggunakan SAN.

4.5 Memeriksa Hasil Pembuatan Sertifikat

Periksa isi sertifikat:

openssl x509 -in certs/server.crt -text -noout

Periksa tanggal berlaku:

openssl x509 -in certs/server.crt -noout -dates

Periksa subject:

openssl x509 -in certs/server.crt -noout -subject

Periksa issuer:

openssl x509 -in certs/server.crt -noout -issuer

Karena sertifikat dibuat secara self-signed, issuer dan subject biasanya sama.

4.6 Memastikan File .crt dan .key Cocok

Ini merupakan salah satu langkah penting dalam pengelolaan sertifikat.

Server membutuhkan pasangan sertifikat dan private key yang sesuai.

Jika file tidak cocok, web server biasanya akan gagal dijalankan.

Salah satu metode tradisional untuk memeriksa kecocokan adalah menggunakan MD5 modulus.

Periksa modulus private key:

openssl rsa -in certs/server.key -noout -modulus | openssl md5

Periksa modulus sertifikat:

openssl x509 -in certs/server.crt -noout -modulus | openssl md5

Contoh hasil:

MD5(stdin)= 7c8a123456789abcdef123456789abcd

Hasil kedua perintah harus sama.

Jika hasilnya berbeda, kemungkinan sertifikat dan private key bukan pasangan yang sama.

warning

MD5 modulus hanya merupakan metode pemeriksaan kecocokan key untuk pasangan RSA. MD5 tidak boleh digunakan sebagai algoritma signature sertifikat baru atau mekanisme keamanan modern.

Untuk metode yang lebih umum dan dapat digunakan pada berbagai jenis key, bandingkan public key dari sertifikat dengan public key yang diturunkan dari private key menggunakan SHA-256.

Alternatif yang direkomendasikan:

openssl x509 -in certs/server.crt -pubkey -noout \
  | openssl pkey -pubin -outform DER \
  | openssl dgst -sha256

Kemudian:

openssl pkey -in certs/server.key -pubout -outform DER \
  | openssl dgst -sha256

Kedua fingerprint harus identik.

4.7 Verifikasi Sertifikat Self-Signed

Jalankan:

openssl verify -CAfile certs/server.crt certs/server.crt

Contoh:

certs/server.crt: OK

Perintah ini memverifikasi sertifikat dengan menjadikan sertifikat tersebut sebagai trust anchor.

Untuk memeriksa apakah sertifikat memiliki SAN:

openssl x509 -in certs/server.crt -noout -ext subjectAltName

Contoh:

X509v3 Subject Alternative Name:
    DNS:localhost, IP Address:127.0.0.1

4.8 Struktur Akhir

Setelah praktik selesai, struktur direktori menjadi:

ssl-lab/
└── certs/
    ├── server.key
    └── server.crt

Kita sudah memiliki:

Private key: server.key.
Sertifikat: server.crt.

Kedua file ini dapat digunakan untuk mengaktifkan HTTPS pada web server lokal.

5. Implementasi SSL/TLS pada Nginx

Nginx merupakan web server sekaligus reverse proxy yang banyak digunakan untuk menjalankan aplikasi web.

Kita akan mengaktifkan HTTPS menggunakan sertifikat yang sudah dibuat sebelumnya.

5.1 Instalasi Nginx

Ubuntu/Debian:

sudo apt update
sudo apt install nginx -y

Periksa status:

sudo systemctl status nginx

5.2 Menyalin Sertifikat

Buat direktori sertifikat:

sudo mkdir -p /etc/nginx/ssl

Salin sertifikat:

sudo cp certs/server.crt /etc/nginx/ssl/

Salin private key:

sudo cp certs/server.key /etc/nginx/ssl/

Atur permission:

sudo chmod 644 /etc/nginx/ssl/server.crt
sudo chmod 600 /etc/nginx/ssl/server.key

Atur kepemilikan file sesuai kebutuhan sistem operasi dan proses Nginx.

danger

Jangan memberikan permission 777 pada private key. Nginx membutuhkan hak baca terhadap private key, tetapi pengguna lain tidak seharusnya memiliki akses bebas.

5.3 Konfigurasi Nginx

Buat file konfigurasi:

sudo nano /etc/nginx/sites-available/ssl-lab

Masukkan konfigurasi berikut:

server {
    listen 80;
    server_name localhost;

    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl;
    server_name localhost;

    ssl_certificate /etc/nginx/ssl/server.crt;
    ssl_certificate_key /etc/nginx/ssl/server.key;

    ssl_protocols TLSv1.2 TLSv1.3;

    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 10m;

    root /var/www/html;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }
}

Penjelasan:

Konfigurasi	Fungsi
`listen 80`	Menerima koneksi HTTP.
`listen 443 ssl`	Mengaktifkan HTTPS.
`server_name`	Nama domain yang dilayani.
`ssl_certificate`	Lokasi sertifikat `.crt`.
`ssl_certificate_key`	Lokasi private key `.key`.
`ssl_protocols`	Versi TLS yang diizinkan.
`return 301`	Mengarahkan HTTP ke HTTPS.

5.4 Mengaktifkan Konfigurasi

Buat symbolic link:

sudo ln -s /etc/nginx/sites-available/ssl-lab \
  /etc/nginx/sites-enabled/ssl-lab

Periksa konfigurasi:

sudo nginx -t

Jika berhasil:

syntax is ok
test is successful

Restart Nginx:

sudo systemctl reload nginx

5.5 Menguji HTTPS

Buka browser:

https://localhost

Atau gunakan curl:

curl -vk https://localhost

Opsi -k digunakan untuk melewati verifikasi sertifikat server oleh curl.

Untuk pengujian dengan verifikasi sertifikat, gunakan:

curl --cacert certs/server.crt https://localhost

Karena sertifikat memiliki SAN localhost, hostname dapat diverifikasi dengan benar.

6. Implementasi SSL/TLS pada Apache

Apache HTTP Server juga mendukung HTTPS melalui modul SSL.

6.1 Instalasi Apache

Ubuntu/Debian:

sudo apt update
sudo apt install apache2 -y

Aktifkan modul SSL:

sudo a2enmod ssl

Aktifkan konfigurasi virtual host:

sudo a2enmod headers

6.2 Menyiapkan Sertifikat

Buat direktori:

sudo mkdir -p /etc/apache2/ssl

Salin sertifikat:

sudo cp certs/server.crt /etc/apache2/ssl/
sudo cp certs/server.key /etc/apache2/ssl/

Atur permission:

sudo chmod 644 /etc/apache2/ssl/server.crt
sudo chmod 600 /etc/apache2/ssl/server.key

6.3 Membuat Virtual Host HTTPS

Buat konfigurasi:

sudo nano /etc/apache2/sites-available/ssl-lab.conf

Isi konfigurasi:

<VirtualHost *:80>
    ServerName localhost

    Redirect permanent / https://localhost/
</VirtualHost>

<VirtualHost *:443>
    ServerName localhost

    DocumentRoot /var/www/html

    SSLEngine on

    SSLCertificateFile /etc/apache2/ssl/server.crt
    SSLCertificateKeyFile /etc/apache2/ssl/server.key

    SSLProtocol all -SSLv3 -TLSv1 -TLSv1.1

    <Directory /var/www/html>
        AllowOverride All
        Require all granted
    </Directory>

    ErrorLog ${APACHE_LOG_DIR}/ssl-error.log
    CustomLog ${APACHE_LOG_DIR}/ssl-access.log combined
</VirtualHost>

Penjelasan:

Konfigurasi	Fungsi
`VirtualHost *:80`	Virtual host HTTP.
`VirtualHost *:443`	Virtual host HTTPS.
`SSLEngine on`	Mengaktifkan SSL/TLS.
`SSLCertificateFile`	Lokasi sertifikat.
`SSLCertificateKeyFile`	Lokasi private key.
`SSLProtocol`	Mengatur protokol yang diizinkan.

6.4 Mengaktifkan Virtual Host

sudo a2ensite ssl-lab.conf

Periksa konfigurasi:

sudo apache2ctl configtest

Jika berhasil:

Syntax OK

Restart Apache:

sudo systemctl restart apache2

6.5 Menguji Apache HTTPS

Buka:

https://localhost

Atau:

curl --cacert certs/server.crt https://localhost

7. Implementasi SSL/TLS pada Node.js

Node.js memiliki modul bawaan bernama https yang dapat digunakan untuk menjalankan server HTTPS tanpa membutuhkan Nginx atau Apache.

Kita akan membuat aplikasi sederhana menggunakan Express dan HTTPS Native Node.js.

7.1 Persiapan Project

Buat direktori:

mkdir node-ssl-lab
cd node-ssl-lab

Inisialisasi project:

npm init -y

Instal Express:

npm install express

Buat struktur:

node-ssl-lab/
├── certs/
│   ├── server.crt
│   └── server.key
├── app.js
└── package.json

Salin sertifikat yang sudah dibuat ke direktori certs.

7.2 Implementasi HTTPS dengan Express

Buat file:

nano app.js

Isi:

const fs = require("fs");
const https = require("https");
const express = require("express");

const app = express();

const sslOptions = {
    key: fs.readFileSync("./certs/server.key"),
    cert: fs.readFileSync("./certs/server.crt"),
};

app.get("/", (req, res) => {
    res.json({
        message: "HTTPS Server Berhasil Berjalan",
        protocol: req.protocol,
        secure: req.secure,
    });
});

https.createServer(sslOptions, app).listen(4430, () => {
    console.log("HTTPS Server berjalan di https://localhost:4430");
});

Jalankan aplikasi:

node app.js

Buka browser:

https://localhost:4430

Pengujian menggunakan curl:

curl -k https://localhost:4430

7.3 Implementasi HTTPS Native Node.js

Selain Express, kita juga dapat menggunakan modul bawaan Node.js.

Buat file:

nano native-https.js

Isi:

const https = require("https");
const fs = require("fs");

const options = {
    key: fs.readFileSync("./certs/server.key"),
    cert: fs.readFileSync("./certs/server.crt"),
};

const server = https.createServer(options, (req, res) => {
    res.writeHead(200, {
        "Content-Type": "application/json",
    });

    res.end(JSON.stringify({
        message: "Native HTTPS Node.js berhasil",
        secure: true,
    }));
});

server.listen(4431, () => {
    console.log("Server berjalan di https://localhost:4431");
});

Jalankan:

node native-https.js

7.4 Mengapa Browser Menampilkan Connection Is Not Private?

Ketika menggunakan sertifikat self-signed, browser biasanya menampilkan peringatan seperti:

Your connection is not private

NET::ERR_CERT_AUTHORITY_INVALID

Atau:

Warning: Potential Security Risk Ahead

Mengapa?

Karena browser tidak mengenali pihak yang menerbitkan sertifikat tersebut.

Browser tidak memiliki dasar kepercayaan untuk memastikan bahwa sertifikat tersebut diterbitkan oleh CA yang tepercaya.

Hal ini bukan berarti konfigurasi HTTPS pasti salah.

Ada dua kondisi yang perlu dibedakan:

Sertifikat valid secara teknis, tetapi CA belum dipercaya browser.
Sertifikat memang tidak valid, misalnya sudah kedaluwarsa, hostname tidak sesuai, atau tanda tangannya tidak valid.

7.5 Cara Melewati Peringatan Saat Testing

Untuk lingkungan localhost, terdapat beberapa pilihan.

Pilihan 1: Melanjutkan melalui browser

Pada browser tertentu, pengguna dapat memilih:

Advanced
Proceed to localhost (unsafe)

Langkah ini hanya untuk pengujian dan dapat berbeda antarbrowser.

Pilihan 2: Menggunakan curl -k

curl -k https://localhost:4430

Opsi -k atau --insecure menonaktifkan verifikasi sertifikat server.

Pilihan 3: Mempercayai CA lokal

Untuk solusi yang lebih baik, buat CA lokal dan tambahkan sertifikat CA tersebut ke trust store sistem operasi atau browser.

Setelah CA dipercaya, sertifikat server yang ditandatangani CA tersebut dapat diverifikasi tanpa mengabaikan pemeriksaan keamanan.

danger

Jangan membiasakan menggunakan curl -k, menonaktifkan validasi sertifikat di Node.js, atau mengabaikan peringatan browser pada lingkungan production.

Jangan menggunakan NODE_TLS_REJECT_UNAUTHORIZED=0 sebagai solusi permanen. Pengaturan tersebut menonaktifkan verifikasi sertifikat TLS secara global pada proses Node.js.

8. Implementasi SSL/TLS pada Database MySQL

Setelah memahami implementasi HTTPS pada web server, selanjutnya kita akan membahas SSL/TLS pada database MySQL.

MySQL merupakan sistem manajemen basis data relasional yang banyak digunakan dalam aplikasi web.

Dalam implementasi normal, aplikasi mengirimkan query SQL melalui jaringan menuju server database.

Contohnya:

Jika komunikasi tidak dienkripsi, data yang melewati jaringan berpotensi disadap oleh pihak lain yang memiliki kemampuan melakukan pemantauan jaringan.

Data yang berisiko antara lain:

Username database.
Password database.
Query SQL.
Hasil query.
Informasi pengguna.
Data transaksi.

Dengan SSL/TLS, komunikasi antara aplikasi dan MySQL dapat dienkripsi.

8.1 Mengapa MySQL Membutuhkan 3 File?

Dalam konfigurasi SSL/TLS MySQL, kita sering menemukan tiga file utama:

server.crt
server.key
ca.crt

Ketiganya memiliki fungsi yang berbeda.

File	Fungsi	Sifat
`server.crt`	Sertifikat identitas server MySQL.	Public
`server.key`	Private key server MySQL.	Private
`ca.crt`	Sertifikat CA untuk memverifikasi sertifikat.	Public

Mengapa harus ada ca.crt?

Karena client perlu memastikan bahwa sertifikat yang diterima benar-benar diterbitkan oleh CA yang dipercaya.

Bayangkan:

server.crt adalah identitas server.
server.key adalah kunci rahasia server.
ca.crt adalah referensi identitas penerbit yang dipercaya client.

Hubungan ketiganya:

Namun, ada satu hal yang perlu dipahami.

Ketiga file tersebut tidak berarti MySQL selalu membutuhkan tiga file untuk setiap client.

Pada konfigurasi TLS biasa:

Server membutuhkan sertifikat dan private key.
Client membutuhkan CA certificate untuk memverifikasi identitas server.
Client tidak wajib memiliki sertifikat dan private key sendiri.

Jika menggunakan mutual TLS (mTLS), client juga dapat memiliki sertifikat dan private key sendiri.

Contohnya:

Client:
    client.crt
    client.key

Server:
    server.crt
    server.key

CA:
    ca.crt

Dalam mTLS, server juga dapat meminta client membuktikan identitasnya menggunakan sertifikat yang ditandatangani oleh CA tepercaya.

9. Membuat Certificate Authority Khusus MySQL

Sekarang kita akan membuat CA sendiri untuk kebutuhan komunikasi MySQL.

CA ini akan digunakan untuk menandatangani sertifikat server MySQL.

9.1 Membuat Struktur Direktori

Buat direktori:

mkdir mysql-ssl-lab
cd mysql-ssl-lab

Buat struktur:

mkdir -p ca server client

Struktur awal:

mysql-ssl-lab/
├── ca/
├── server/
└── client/

Keterangan:

ca/ menyimpan CA certificate dan CA private key.
server/ menyimpan sertifikat dan private key server MySQL.
client/ disiapkan untuk kebutuhan mutual TLS.

9.2 Membuat CA Private Key

Jalankan:

openssl genrsa -out ca/ca.key 4096

Atur permission:

chmod 600 ca/ca.key

CA private key merupakan kunci paling sensitif dalam struktur ini.

Siapa pun yang memiliki akses terhadap CA private key berpotensi menerbitkan sertifikat baru yang dipercaya oleh client yang menggunakan CA tersebut.

9.3 Membuat CA Certificate

Buat sertifikat CA:

openssl req -x509 \
  -new \
  -key ca/ca.key \
  -sha256 \
  -days 3650 \
  -out ca/ca.crt \
  -subj "/C=ID/ST=Central Sulawesi/L=Palu/O=Internal Infrastructure/OU=Database Security/CN=MySQL Root CA" \
  -addext "basicConstraints=critical,CA:TRUE" \
  -addext "keyUsage=critical,keyCertSign,cRLSign"

Penjelasan:

Parameter	Fungsi
`-x509`	Membuat sertifikat CA.
`-new`	Membuat sertifikat baru.
`-key`	Menggunakan CA private key.
`-days 3650`	Masa berlaku 10 tahun.
`basicConstraints`	Menandai sertifikat sebagai CA.
`keyUsage`	Mengizinkan penggunaan untuk menandatangani sertifikat.

Periksa hasil:

openssl x509 -in ca/ca.crt -text -noout

9.4 Membuat Private Key Server MySQL

Buat private key:

openssl genrsa -out server/server.key 2048

Atur permission:

chmod 600 server/server.key

9.5 Membuat CSR Server MySQL

Buat CSR:

openssl req -new \
  -key server/server.key \
  -out server/server.csr \
  -subj "/C=ID/ST=Central Sulawesi/L=Palu/O=Internal Infrastructure/OU=Database/CN=mysql.internal"

Pada contoh ini, kita menggunakan hostname:

mysql.internal

Hostname tersebut harus disesuaikan dengan hostname yang digunakan oleh aplikasi untuk mengakses database.

9.6 Membuat Extension Sertifikat Server

Untuk memastikan sertifikat memiliki SAN dan penggunaan yang sesuai, buat file konfigurasi:

nano server/server.ext

Isi:

basicConstraints = critical,CA:FALSE
keyUsage = critical,digitalSignature,keyEncipherment
extendedKeyUsage = serverAuth
subjectAltName = DNS:mysql.internal,DNS:localhost,IP:127.0.0.1

Perhatikan bagian SAN.

Jika MySQL diakses melalui hostname atau IP lain, tambahkan hostname atau IP tersebut.

Misalnya:

subjectAltName = DNS:mysql.internal,DNS:db.example.local,IP:192.168.1.10

9.7 Menandatangani CSR Menggunakan CA

Sekarang gunakan CA untuk menerbitkan sertifikat server:

openssl x509 -req \
  -in server/server.csr \
  -CA ca/ca.crt \
  -CAkey ca/ca.key \
  -CAcreateserial \
  -out server/server.crt \
  -days 825 \
  -sha256 \
  -extfile server/server.ext

Penjelasan:

-in: CSR yang akan ditandatangani.
-CA: Sertifikat CA.
-CAkey: Private key CA.
-CAcreateserial: Membuat file serial number jika belum ada.
-out: Sertifikat server hasil penerbitan.
-extfile: Konfigurasi ekstensi sertifikat.

9.8 Memverifikasi Sertifikat MySQL

Periksa sertifikat:

openssl x509 -in server/server.crt -text -noout

Verifikasi rantai kepercayaan:

openssl verify \
  -CAfile ca/ca.crt \
  server/server.crt

Hasil yang diharapkan:

server/server.crt: OK

Periksa SAN:

openssl x509 -in server/server.crt \
  -noout -ext subjectAltName

Periksa kecocokan private key dan sertifikat menggunakan SHA-256:

openssl x509 -in server/server.crt -pubkey -noout \
  | openssl pkey -pubin -outform DER \
  | openssl dgst -sha256

openssl pkey -in server/server.key -pubout -outform DER \
  | openssl dgst -sha256

Kedua hasil harus sama.

9.9 Struktur Sertifikat MySQL

Setelah proses selesai:

mysql-ssl-lab/
├── ca/
│   ├── ca.key
│   ├── ca.crt
│   └── ca.srl
│
├── server/
│   ├── server.key
│   ├── server.csr
│   ├── server.crt
│   └── server.ext
│
└── client/

File yang akan digunakan oleh MySQL Server:

server/server.crt
server/server.key
ca/ca.crt

CA private key tidak perlu ditempatkan pada server MySQL setelah proses penandatanganan selesai. Simpan CA private key di lokasi aman dan terpisah.

10. Konfigurasi SSL/TLS pada MySQL Server

Setelah sertifikat selesai dibuat, kita perlu mengonfigurasi MySQL agar menggunakan sertifikat tersebut.

10.1 Mengetahui Lokasi File Konfigurasi MySQL

Pada Ubuntu/Debian, konfigurasi MySQL umumnya berada di:

/etc/mysql/mysql.conf.d/mysqld.cnf

Pada beberapa distribusi Linux atau instalasi lainnya, lokasi konfigurasi dapat berbeda.

Periksa lokasi konfigurasi:

mysql --help | grep -A 1 "Default options"

10.2 Menyalin Sertifikat ke Direktori MySQL

Buat direktori:

sudo mkdir -p /etc/mysql/ssl

Salin sertifikat:

sudo cp ca/ca.crt /etc/mysql/ssl/
sudo cp server/server.crt /etc/mysql/ssl/
sudo cp server/server.key /etc/mysql/ssl/

Atur permission:

sudo chmod 644 /etc/mysql/ssl/ca.crt
sudo chmod 644 /etc/mysql/ssl/server.crt
sudo chmod 600 /etc/mysql/ssl/server.key

Atur kepemilikan sesuai user yang menjalankan MySQL.

Pada Ubuntu/Debian, umumnya:

sudo chown -R mysql:mysql /etc/mysql/ssl

Pastikan direktori induk juga dapat diakses oleh user MySQL.

10.3 Mengonfigurasi my.cnf

Edit file konfigurasi:

sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf

Tambahkan konfigurasi berikut di bagian [mysqld]:

[mysqld]

# SSL/TLS Configuration
ssl_ca = /etc/mysql/ssl/ca.crt
ssl_cert = /etc/mysql/ssl/server.crt
ssl_key = /etc/mysql/ssl/server.key

# Enforce encrypted client connections
require_secure_transport = ON

Penjelasan:

Parameter	Fungsi
`ssl_ca`	Lokasi sertifikat CA.
`ssl_cert`	Lokasi sertifikat server.
`ssl_key`	Lokasi private key server.
`require_secure_transport`	Mewajibkan koneksi menggunakan transportasi aman.

warning

require_secure_transport = ON mewajibkan koneksi aman, tetapi tidak otomatis mewajibkan setiap client menggunakan sertifikat client.

TLS dengan verifikasi CA server dan mutual TLS merupakan dua tingkat konfigurasi yang berbeda.

10.4 Restart MySQL

Restart service:

sudo systemctl restart mysql

Periksa status:

sudo systemctl status mysql

Jika MySQL gagal berjalan, periksa log:

sudo journalctl -u mysql -n 100 --no-pager

Periksa juga:

Path sertifikat.
Permission private key.
Kepemilikan file.
Format sertifikat.
Kecocokan sertifikat dan private key.
SAN sertifikat.
Konfigurasi my.cnf.

10.5 Memeriksa Status SSL MySQL

Masuk ke MySQL:

mysql -u root -p

Periksa status SSL:

SHOW VARIABLES LIKE 'have_ssl';

Contoh hasil:

+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| have_ssl      | YES   |
+---------------+-------+

Periksa sertifikat CA:

SHOW VARIABLES LIKE 'ssl_ca';

Periksa sertifikat server:

SHOW VARIABLES LIKE 'ssl_cert';

Periksa private key:

SHOW VARIABLES LIKE 'ssl_key';

Periksa kewajiban transportasi aman:

SHOW VARIABLES LIKE 'require_secure_transport';

Contoh:

+---------------------------+-------+
| Variable_name             | Value |
+---------------------------+-------+
| require_secure_transport  | ON    |
+---------------------------+-------+

10.6 Memeriksa Koneksi SSL Aktif

Jalankan:

SHOW STATUS LIKE 'Ssl_cipher';

Jika koneksi menggunakan TLS, kolom Value biasanya menampilkan cipher yang digunakan.

Contoh:

+---------------+-----------------------------+
| Variable_name | Value                       |
+---------------+-----------------------------+
| Ssl_cipher    | TLS_AES_256_GCM_SHA384       |
+---------------+-----------------------------+

Jika Value kosong, koneksi saat ini tidak menggunakan TLS.

Periksa informasi versi TLS:

SHOW STATUS LIKE 'Ssl_version';

Contoh:

+---------------+---------+
| Variable_name | Value   |
+---------------+---------+
| Ssl_version   | TLSv1.3 |
+---------------+---------+

Perlu diperhatikan bahwa SHOW STATUS tersebut memeriksa koneksi session yang sedang digunakan, bukan seluruh koneksi client di server.

10.7 Membuat User MySQL

Buat user aplikasi:

CREATE USER 'appuser'@'%' IDENTIFIED BY 'StrongPassword123!';

GRANT SELECT, INSERT, UPDATE, DELETE
ON application_db.*
TO 'appuser'@'%';

Periksa user:

SELECT user, host
FROM mysql.user
WHERE user = 'appuser';

Untuk lingkungan production, batasi host sesuai alamat aplikasi daripada menggunakan % jika memungkinkan.

11. Menguji Koneksi MySQL Menggunakan TLS

Setelah server MySQL dikonfigurasi, kita akan menguji koneksi menggunakan MySQL Client.

11.1 Koneksi dengan Verifikasi CA

Jalankan:

mysql \
  --host=mysql.internal \
  --port=3306 \
  --user=appuser \
  --password \
  --ssl-mode=VERIFY_CA \
  --ssl-ca=/etc/mysql/ssl/ca.crt

Pada VERIFY_CA, client memverifikasi bahwa sertifikat server ditandatangani oleh CA yang dipercaya.

11.2 Koneksi dengan Verifikasi Identitas Server

Untuk keamanan yang lebih baik, gunakan:

mysql \
  --host=mysql.internal \
  --port=3306 \
  --user=appuser \
  --password \
  --ssl-mode=VERIFY_IDENTITY \
  --ssl-ca=/etc/mysql/ssl/ca.crt

Perbedaan:

Mode	Fungsi
`DISABLED`	Tidak menggunakan TLS.
`PREFERRED`	Menggunakan TLS jika tersedia.
`REQUIRED`	Mewajibkan TLS tanpa verifikasi CA.
`VERIFY_CA`	Mewajibkan TLS dan memverifikasi CA.
`VERIFY_IDENTITY`	Mewajibkan TLS, memverifikasi CA, dan identitas hostname server.

success

Untuk aplikasi production, gunakan verifikasi identitas server seperti VERIFY_IDENTITY, dengan syarat hostname koneksi sesuai dengan SAN sertifikat.

11.3 Memeriksa Koneksi dari MySQL Client

Setelah berhasil terhubung:

SHOW STATUS LIKE 'Ssl_cipher';

Jika cipher terisi, koneksi menggunakan TLS.

Untuk melihat detail koneksi:

\s

Pada bagian status koneksi, perhatikan informasi SSL.

12. Implementasi SSL/TLS MySQL pada Node.js Menggunakan mysql2

Sekarang kita akan menghubungkan aplikasi Node.js ke database MySQL menggunakan TLS.

Kita menggunakan library mysql2.

12.1 Persiapan Project

Buat direktori:

mkdir node-mysql-ssl
cd node-mysql-ssl

Inisialisasi:

npm init -y

Instal dependency:

npm install mysql2 dotenv

Struktur project:

node-mysql-ssl/
├── certs/
│   └── ca.crt
├── .env
├── .gitignore
├── db.js
└── app.js

Salin CA certificate:

cp ../mysql-ssl-lab/ca/ca.crt certs/ca.crt

Perhatikan bahwa aplikasi hanya membutuhkan CA certificate untuk memverifikasi identitas server dalam skenario TLS satu arah.

Aplikasi tidak membutuhkan server.key.

12.2 Membuat File Environment

Buat file .env:

DB_HOST=mysql.internal
DB_PORT=3306
DB_USER=appuser
DB_PASSWORD=StrongPassword123!
DB_NAME=application_db

Buat file .gitignore:

node_modules/
.env

# Private keys
*.key

# Local certificates and secrets
certs/*.key

CA certificate boleh didistribusikan kepada client sebagai trust anchor, tetapi tetap pastikan sumber dan integritasnya dapat dipercaya.

12.3 Membuat Database Connection

Buat file:

nano db.js

Isi:

const mysql = require("mysql2/promise");
const fs = require("fs");
const path = require("path");
require("dotenv").config();

const pool = mysql.createPool({
    host: process.env.DB_HOST,
    port: Number(process.env.DB_PORT),
    user: process.env.DB_USER,
    password: process.env.DB_PASSWORD,
    database: process.env.DB_NAME,

    ssl: {
        ca: fs.readFileSync(
            path.join(__dirname, "certs", "ca.crt")
        ),
        rejectUnauthorized: true,
    },

    waitForConnections: true,
    connectionLimit: 10,
    queueLimit: 0,
});

module.exports = pool;

Penjelasan:

Parameter	Fungsi
`host`	Hostname MySQL.
`port`	Port MySQL.
`user`	Username database.
`password`	Password database.
`database`	Nama database.
`ssl.ca`	CA certificate untuk verifikasi server.
`rejectUnauthorized`	Menolak sertifikat yang tidak dapat diverifikasi.
`connectionLimit`	Jumlah maksimum koneksi dalam pool.

Penting: rejectUnauthorized: true tidak boleh diubah menjadi false sebagai solusi untuk mengatasi kesalahan sertifikat di production.

Pastikan juga hostname yang digunakan pada DB_HOST cocok dengan SAN sertifikat server.

12.4 Membuat File Aplikasi

Buat file:

nano app.js

Isi:

const pool = require("./db");

async function main() {
    let connection;

    try {
        connection = await pool.getConnection();

        console.log("Berhasil terhubung ke MySQL melalui TLS");

        const [rows] = await connection.query(
            "SHOW STATUS LIKE 'Ssl_cipher'"
        );

        console.log("SSL Status:", rows);

        const [version] = await connection.query(
            "SHOW STATUS LIKE 'Ssl_version'"
        );

        console.log("TLS Version:", version);

        const [result] = await connection.query(
            "SELECT NOW() AS server_time"
        );

        console.log("Database Time:", result);

    } catch (error) {
        console.error("Database connection error:", error.message);
        process.exitCode = 1;

    } finally {
        if (connection) {
            connection.release();
        }

        await pool.end();
    }
}

main();

Jalankan:

node app.js

Contoh hasil:

Berhasil terhubung ke MySQL melalui TLS

SSL Status:
[
  {
    Variable_name: 'Ssl_cipher',
    Value: 'TLS_AES_256_GCM_SHA384'
  }
]

TLS Version:
[
  {
    Variable_name: 'Ssl_version',
    Value: 'TLSv1.3'
  }
]

Database Time:
[
  {
    server_time: '2026-11-04T00:00:00.000Z'
  }
]

Nilai di atas merupakan ilustrasi hasil. Nilai aktual bergantung pada versi MySQL, Node.js, OpenSSL, dan konfigurasi TLS.

13. Implementasi Mutual TLS pada MySQL (Opsional)

Pada implementasi sebelumnya, aplikasi hanya memverifikasi sertifikat server.

Jika ingin meningkatkan keamanan, kita dapat menerapkan Mutual TLS atau mTLS.

Dalam mTLS, kedua pihak saling membuktikan identitas:

Client memverifikasi sertifikat server.
Server memverifikasi sertifikat client.

13.1 Membuat Client Private Key

openssl genrsa -out client/client.key 2048

13.2 Membuat Client CSR

openssl req -new \
  -key client/client.key \
  -out client/client.csr \
  -subj "/C=ID/ST=Central Sulawesi/L=Palu/O=Internal Infrastructure/OU=Application/CN=nodejs-client"

13.3 Membuat Extension Client

Buat file:

nano client/client.ext

Isi:

basicConstraints = critical,CA:FALSE
keyUsage = critical,digitalSignature,keyEncipherment
extendedKeyUsage = clientAuth

13.4 Menandatangani Sertifikat Client

openssl x509 -req \
  -in client/client.csr \
  -CA ca/ca.crt \
  -CAkey ca/ca.key \
  -CAserial ca/ca.srl \
  -out client/client.crt \
  -days 825 \
  -sha256 \
  -extfile client/client.ext

Verifikasi:

openssl verify \
  -CAfile ca/ca.crt \
  client/client.crt

Hasil:

client/client.crt: OK

13.5 Memaksa User MySQL Menggunakan Sertifikat Client

Masuk ke MySQL:

ALTER USER 'appuser'@'%'
REQUIRE X509;

Dengan konfigurasi tersebut, user yang bersangkutan harus menggunakan sertifikat client yang valid.

Jika ingin membatasi identitas sertifikat, MySQL juga menyediakan persyaratan seperti:

ALTER USER 'appuser'@'%'
REQUIRE SUBJECT '/CN=nodejs-client';

Atau:

ALTER USER 'appuser'@'%'
REQUIRE ISSUER '/CN=MySQL Root CA';

Nilai SUBJECT dan ISSUER harus sesuai dengan Distinguished Name sertifikat yang sebenarnya.

13.6 Konfigurasi mysql2 Menggunakan Client Certificate

Ubah konfigurasi db.js:

const mysql = require("mysql2/promise");
const fs = require("fs");
const path = require("path");
require("dotenv").config();

const certPath = path.join(__dirname, "certs");

const pool = mysql.createPool({
    host: process.env.DB_HOST,
    port: Number(process.env.DB_PORT),
    user: process.env.DB_USER,
    password: process.env.DB_PASSWORD,
    database: process.env.DB_NAME,

    ssl: {
        ca: fs.readFileSync(
            path.join(certPath, "ca.crt")
        ),

        cert: fs.readFileSync(
            path.join(certPath, "client.crt")
        ),

        key: fs.readFileSync(
            path.join(certPath, "client.key")
        ),

        rejectUnauthorized: true,
    },

    waitForConnections: true,
    connectionLimit: 10,
});

module.exports = pool;

Sekarang aplikasi Node.js menggunakan:

ca.crt
client.crt
client.key

Sementara MySQL Server menggunakan:

ca.crt
server.crt
server.key

Kedua pihak memiliki identitas masing-masing dan melakukan verifikasi sertifikat selama proses TLS.

danger

Jangan pernah menyalin ca.key ke server aplikasi atau menyertakannya dalam repository aplikasi. CA private key hanya digunakan untuk menerbitkan sertifikat dan harus disimpan secara terpisah.

14. Troubleshooting SSL/TLS

Pada implementasi SSL/TLS, terdapat beberapa kesalahan yang sering ditemukan.

Berikut beberapa masalah dan cara mengatasinya.

14.1 Error: SSL_CTX_use_PrivateKey_file Failed

Contoh:

SSL_CTX_use_PrivateKey_file failed

Penyebab:

File private key tidak ditemukan.
Permission tidak sesuai.
Format private key tidak valid.
File private key rusak.

Solusi:

Periksa file:

openssl pkey -in server.key -check -noout

Periksa permission:

ls -l server.key

14.2 Error: Certificate and Private Key Do Not Match

Penyebab:

Sertifikat dan private key berasal dari pasangan yang berbeda.

Solusi:

Periksa public key fingerprint:

openssl x509 -in server.crt -pubkey -noout \
  | openssl pkey -pubin -outform DER \
  | openssl dgst -sha256

openssl pkey -in server.key -pubout -outform DER \
  | openssl dgst -sha256

Pastikan hasilnya sama.

14.3 Error: Certificate Verify Failed

Contoh:

certificate verify failed

Penyebab:

CA certificate tidak dikenali.
Sertifikat ditandatangani CA yang berbeda.
Sertifikat kedaluwarsa.
Sertifikat belum berlaku.
Sertifikat tidak memiliki chain yang benar.

Solusi:

openssl verify \
  -CAfile ca.crt \
  server.crt

14.4 Error: Hostname Mismatch

Contoh:

Hostname/IP does not match certificate's altnames

Penyebab:

Hostname yang digunakan client tidak tercantum dalam SAN sertifikat.

Misalnya:

Client mengakses:

mysql.internal

Tetapi sertifikat hanya memiliki:

DNS:localhost

Solusi:

Buat ulang sertifikat dengan SAN yang benar.

subjectAltName = DNS:mysql.internal,DNS:localhost,IP:127.0.0.1

14.5 Error: MySQL Server Cannot Start

Periksa log:

sudo journalctl -u mysql -n 100 --no-pager

Periksa konfigurasi:

sudo mysql --help

Pastikan:

File CA tersedia.
File sertifikat tersedia.
File private key tersedia.
Permission benar.
MySQL dapat membaca direktori sertifikat.
Private key tidak menggunakan password yang tidak dapat ditangani oleh konfigurasi server.
Sertifikat dan private key cocok.

14.6 Error: Access Denied pada mTLS

Jika menggunakan:

ALTER USER 'appuser'@'%'
REQUIRE X509;

Client wajib mengirimkan sertifikat client yang diterbitkan oleh CA tepercaya.

Pastikan konfigurasi Node.js memiliki:

ssl: {
    ca: fs.readFileSync("./certs/ca.crt"),
    cert: fs.readFileSync("./certs/client.crt"),
    key: fs.readFileSync("./certs/client.key"),
    rejectUnauthorized: true,
}

Jangan tertukar antara sertifikat server dan sertifikat client.

14.7 Menguji Koneksi TLS Menggunakan OpenSSL

Kita juga dapat menggunakan OpenSSL untuk memeriksa TLS handshake MySQL.

Jalankan:

openssl s_client \
  -connect mysql.internal:3306 \
  -starttls mysql \
  -CAfile ca/ca.crt \
  -verify_return_error \
  -verify_hostname mysql.internal

Perintah ini membantu memeriksa:

Negosiasi TLS.
Sertifikat server.
Rantai sertifikat.
Validasi CA.
Kesesuaian hostname.

Perhatikan bahwa pengujian ini tidak menggantikan pengujian autentikasi database menggunakan MySQL Client atau aplikasi.

15. Best Practices Pengelolaan Sertifikat SSL/TLS

Setelah memahami pembuatan dan implementasi sertifikat, kita perlu menerapkan prinsip pengelolaan keamanan yang baik.

15.1 Lindungi Private Key

Private key merupakan aset yang sangat sensitif.

Rekomendasi:

chmod 600 server.key

Batasi akses file hanya kepada user dan service yang membutuhkan.

Jangan:

Mengunggah private key ke GitHub publik.
Menyimpan private key di repository aplikasi.
Mengirim private key melalui komunikasi yang tidak aman.
Menggunakan private key yang sama untuk seluruh server tanpa pertimbangan keamanan.
Memberikan permission 777.

15.2 Gunakan Certificate Authority yang Tepercaya

Untuk website production yang diakses publik, gunakan CA publik yang dipercaya browser.

Contohnya:

Let's Encrypt.
DigiCert.
Sectigo.

Untuk database internal, CA private dapat digunakan selama proses distribusi dan pengelolaan trust dilakukan dengan benar.

15.3 Gunakan SAN

Jangan hanya mengandalkan Common Name (CN).

Pastikan sertifikat memiliki Subject Alternative Name yang sesuai dengan hostname atau IP yang digunakan client.

15.4 Gunakan TLS Modern

Hindari protokol lama seperti:

SSLv2.
SSLv3.
TLS 1.0.
TLS 1.1.

Gunakan TLS 1.2 atau TLS 1.3 sesuai dukungan platform.

15.5 Lakukan Rotasi Sertifikat

Sertifikat memiliki masa berlaku.

Administrator perlu memantau masa berlaku dan melakukan pembaruan sebelum sertifikat kedaluwarsa.

Periksa masa berlaku:

openssl x509 -in server.crt -noout -dates

Periksa sisa masa berlaku:

openssl x509 -in server.crt -checkend 2592000 -noout

Angka 2592000 menunjukkan 30 hari dalam satuan detik.

Jika exit code menunjukkan kegagalan, sertifikat akan kedaluwarsa dalam 30 hari atau sudah kedaluwarsa.

15.6 Pisahkan CA Private Key dari Server

CA private key sebaiknya disimpan di lokasi terpisah dengan kontrol akses ketat.

Server hanya membutuhkan sertifikat CA publik untuk memverifikasi sertifikat yang diterbitkan oleh CA tersebut.

15.7 Gunakan Secret Management

Untuk lingkungan production, pertimbangkan menggunakan:

HashiCorp Vault.
AWS Secrets Manager.
Azure Key Vault.
Google Cloud Secret Manager.

Tujuannya adalah mengelola kredensial dan material kriptografi secara terpusat, dengan kontrol akses, audit, dan rotasi.

15.8 Monitoring Sertifikat

Administrator perlu memonitor:

Masa berlaku sertifikat.
Kegagalan TLS handshake.
Perubahan sertifikat.
Kegagalan verifikasi CA.
Koneksi database yang tidak menggunakan TLS.
Penggunaan cipher dan versi TLS.

16. Rangkuman Alur Implementasi

Untuk memahami hubungan antara semua komponen yang sudah dipelajari, berikut rangkuman implementasi SSL/TLS.

16.1 Alur HTTPS pada Web Server

16.2 Alur Pembuatan Sertifikat

16.3 Alur SSL/TLS pada MySQL

16.4 Perbedaan TLS Biasa dan Mutual TLS

17. Kesimpulan

File .crt dan .key merupakan komponen penting dalam implementasi SSL/TLS.

Keduanya memiliki fungsi yang berbeda:

.crt menyimpan sertifikat digital yang berisi identitas dan public key.
.key menyimpan private key yang harus dijaga kerahasiaannya.
ca.crt digunakan untuk memverifikasi sertifikat yang diterbitkan oleh Certificate Authority.
.csr digunakan untuk mengajukan penerbitan sertifikat kepada CA.

Dalam implementasi web server, Nginx, Apache, dan Node.js menggunakan sertifikat dan private key untuk menyediakan koneksi HTTPS.

Sementara itu, MySQL menggunakan SSL/TLS untuk melindungi komunikasi antara aplikasi dan database.

Untuk konfigurasi MySQL yang lebih aman, aplikasi sebaiknya memverifikasi sertifikat CA sekaligus identitas hostname server. Jika membutuhkan autentikasi dua arah, kita dapat menerapkan Mutual TLS menggunakan sertifikat client.

Hal paling penting yang perlu diingat adalah private key harus selalu dilindungi. Sertifikat publik dapat didistribusikan kepada pihak yang membutuhkan, tetapi private key tidak boleh dibagikan secara sembarangan.

Dengan memahami konsep dan praktik ini, kita memiliki dasar yang kuat untuk mengelola keamanan komunikasi pada infrastruktur web server, aplikasi, dan database.

18. Latihan Praktik

Untuk menguji pemahaman, kerjakan beberapa latihan berikut.

Praktik 1 - Membuat Self-Signed Certificate

Target:

Membuat private key menggunakan OpenSSL.
Membuat sertifikat self-signed.
Memeriksa isi sertifikat.
Memverifikasi kecocokan public key.

Pertanyaan:

Apa perbedaan file .crt dan .key?
Mengapa private key tidak boleh dibagikan?
Apa fungsi SAN pada sertifikat?
Mengapa browser menampilkan peringatan pada self-signed certificate?

Praktik 2 - Implementasi HTTPS

Target:

Mengaktifkan HTTPS pada Nginx.
Mengaktifkan HTTPS pada Apache.
Menjalankan HTTPS menggunakan Node.js.
Menguji koneksi menggunakan curl.

Pertanyaan:

Apa perbedaan HTTP dan HTTPS?
Apa fungsi port 443?
Apa fungsi ssl_certificate pada Nginx?
Apa fungsi SSLEngine on pada Apache?
Mengapa Node.js membutuhkan private key dan sertifikat?

Praktik 3 - Implementasi SSL/TLS MySQL

Target:

Membuat CA sendiri.
Membuat sertifikat server MySQL.
Mengonfigurasi SSL pada my.cnf.
Mengaktifkan require_secure_transport.
Memverifikasi koneksi menggunakan MySQL Client.

Pertanyaan:

Mengapa MySQL menggunakan CA certificate?
Apa perbedaan VERIFY_CA dan VERIFY_IDENTITY?
Apa fungsi Ssl_cipher?
Apa fungsi require_secure_transport?
Apa perbedaan TLS biasa dan mutual TLS?

Praktik 4 - Koneksi Node.js ke MySQL

Target:

Menginstal mysql2.
Mengonfigurasi CA certificate.
Mengaktifkan verifikasi sertifikat.
Membuat koneksi menggunakan connection pool.
Memastikan koneksi menggunakan TLS.

Pertanyaan:

Mengapa aplikasi membutuhkan ca.crt?
Mengapa aplikasi tidak membutuhkan server.key?
Apa fungsi rejectUnauthorized?
Mengapa hostname aplikasi harus sesuai dengan SAN?
Bagaimana cara memastikan koneksi MySQL benar-benar menggunakan TLS?

19. Referensi Dokumentasi

Berikut beberapa referensi resmi untuk mempelajari SSL/TLS lebih lanjut.

Akhir Materi

Materi ini dapat digunakan sebagai panduan praktik mandiri untuk memahami pengelolaan sertifikat digital, konfigurasi HTTPS, serta pengamanan komunikasi database MySQL menggunakan TLS.

1.1 Apa Itu SSL dan TLS?​

1.2 Apa Itu File .crt?​

1.3 Apa Itu File .key?​

1.4 Perbedaan File .crt dan .key​

1.5 Apa Itu File .csr?​

1.6 Apa Itu Certificate Authority (CA)?​

2. Mengenal Format Sertifikat Digital​

2.1 Format PEM​

2.2 Perbedaan PEM, CRT, CER, dan KEY​

2.3 Mengenali Format Menggunakan OpenSSL​

3. Mengenal OpenSSL​

3.1 Memeriksa Instalasi OpenSSL​

4. Praktik Mandiri: Membuat Sertifikat Self-Signed​

4.1 Apa Itu Self-Signed Certificate?​

4.2 Membuat Direktori SSL​

4.3 Membuat Private Key​

4.4 Membuat Sertifikat Self-Signed​

4.5 Memeriksa Hasil Pembuatan Sertifikat​

4.6 Memastikan File .crt dan .key Cocok​

4.7 Verifikasi Sertifikat Self-Signed​

4.8 Struktur Akhir​

5. Implementasi SSL/TLS pada Nginx​

5.1 Instalasi Nginx​

5.2 Menyalin Sertifikat​

5.3 Konfigurasi Nginx​

5.4 Mengaktifkan Konfigurasi​

5.5 Menguji HTTPS​

6. Implementasi SSL/TLS pada Apache​

6.1 Instalasi Apache​

6.2 Menyiapkan Sertifikat​

6.3 Membuat Virtual Host HTTPS​

6.4 Mengaktifkan Virtual Host​

6.5 Menguji Apache HTTPS​

7. Implementasi SSL/TLS pada Node.js​

7.1 Persiapan Project​

7.2 Implementasi HTTPS dengan Express​

7.3 Implementasi HTTPS Native Node.js​

7.4 Mengapa Browser Menampilkan Connection Is Not Private?​

7.5 Cara Melewati Peringatan Saat Testing​

8. Implementasi SSL/TLS pada Database MySQL​

8.1 Mengapa MySQL Membutuhkan 3 File?​

9. Membuat Certificate Authority Khusus MySQL​

9.1 Membuat Struktur Direktori​

9.2 Membuat CA Private Key​

9.3 Membuat CA Certificate​

9.4 Membuat Private Key Server MySQL​

9.5 Membuat CSR Server MySQL​

9.6 Membuat Extension Sertifikat Server​

9.7 Menandatangani CSR Menggunakan CA​

9.8 Memverifikasi Sertifikat MySQL​

9.9 Struktur Sertifikat MySQL​

10. Konfigurasi SSL/TLS pada MySQL Server​

10.1 Mengetahui Lokasi File Konfigurasi MySQL​

10.2 Menyalin Sertifikat ke Direktori MySQL​

10.3 Mengonfigurasi my.cnf​

10.4 Restart MySQL​

10.5 Memeriksa Status SSL MySQL​

10.6 Memeriksa Koneksi SSL Aktif​

10.7 Membuat User MySQL​

11. Menguji Koneksi MySQL Menggunakan TLS​

11.1 Koneksi dengan Verifikasi CA​

11.2 Koneksi dengan Verifikasi Identitas Server​

11.3 Memeriksa Koneksi dari MySQL Client​

12. Implementasi SSL/TLS MySQL pada Node.js Menggunakan mysql2​

12.1 Persiapan Project​

12.2 Membuat File Environment​

12.3 Membuat Database Connection​

12.4 Membuat File Aplikasi​

13. Implementasi Mutual TLS pada MySQL (Opsional)​

13.1 Membuat Client Private Key​

13.2 Membuat Client CSR​

13.3 Membuat Extension Client​

13.4 Menandatangani Sertifikat Client​

13.5 Memaksa User MySQL Menggunakan Sertifikat Client​

13.6 Konfigurasi mysql2 Menggunakan Client Certificate​

14. Troubleshooting SSL/TLS​

14.1 Error: SSL_CTX_use_PrivateKey_file Failed​

14.2 Error: Certificate and Private Key Do Not Match​

14.3 Error: Certificate Verify Failed​

14.4 Error: Hostname Mismatch​

1.1 Apa Itu SSL dan TLS?

1.2 Apa Itu File .crt?

1.3 Apa Itu File .key?

1.4 Perbedaan File .crt dan .key

1.5 Apa Itu File .csr?

1.6 Apa Itu Certificate Authority (CA)?

2. Mengenal Format Sertifikat Digital

2.1 Format PEM

2.2 Perbedaan PEM, CRT, CER, dan KEY

2.3 Mengenali Format Menggunakan OpenSSL

3. Mengenal OpenSSL

3.1 Memeriksa Instalasi OpenSSL

4. Praktik Mandiri: Membuat Sertifikat Self-Signed

4.1 Apa Itu Self-Signed Certificate?

4.2 Membuat Direktori SSL

4.3 Membuat Private Key

4.4 Membuat Sertifikat Self-Signed

4.5 Memeriksa Hasil Pembuatan Sertifikat

4.6 Memastikan File .crt dan .key Cocok

4.7 Verifikasi Sertifikat Self-Signed

4.8 Struktur Akhir

5. Implementasi SSL/TLS pada Nginx

5.1 Instalasi Nginx

5.2 Menyalin Sertifikat

5.3 Konfigurasi Nginx

5.4 Mengaktifkan Konfigurasi

5.5 Menguji HTTPS

6. Implementasi SSL/TLS pada Apache

6.1 Instalasi Apache

6.2 Menyiapkan Sertifikat

6.3 Membuat Virtual Host HTTPS

6.4 Mengaktifkan Virtual Host

6.5 Menguji Apache HTTPS

7. Implementasi SSL/TLS pada Node.js

7.1 Persiapan Project

7.2 Implementasi HTTPS dengan Express

7.3 Implementasi HTTPS Native Node.js

7.4 Mengapa Browser Menampilkan Connection Is Not Private?

7.5 Cara Melewati Peringatan Saat Testing

8. Implementasi SSL/TLS pada Database MySQL

8.1 Mengapa MySQL Membutuhkan 3 File?

9. Membuat Certificate Authority Khusus MySQL

9.1 Membuat Struktur Direktori

9.2 Membuat CA Private Key

9.3 Membuat CA Certificate

9.4 Membuat Private Key Server MySQL

9.5 Membuat CSR Server MySQL

9.6 Membuat Extension Sertifikat Server

9.7 Menandatangani CSR Menggunakan CA

9.8 Memverifikasi Sertifikat MySQL

9.9 Struktur Sertifikat MySQL

10. Konfigurasi SSL/TLS pada MySQL Server

10.1 Mengetahui Lokasi File Konfigurasi MySQL

10.2 Menyalin Sertifikat ke Direktori MySQL

10.3 Mengonfigurasi my.cnf

10.4 Restart MySQL

10.5 Memeriksa Status SSL MySQL

10.6 Memeriksa Koneksi SSL Aktif

10.7 Membuat User MySQL

11. Menguji Koneksi MySQL Menggunakan TLS

11.1 Koneksi dengan Verifikasi CA

11.2 Koneksi dengan Verifikasi Identitas Server

11.3 Memeriksa Koneksi dari MySQL Client

12. Implementasi SSL/TLS MySQL pada Node.js Menggunakan mysql2

12.1 Persiapan Project

12.2 Membuat File Environment

12.3 Membuat Database Connection

12.4 Membuat File Aplikasi

13. Implementasi Mutual TLS pada MySQL (Opsional)

13.1 Membuat Client Private Key

13.2 Membuat Client CSR

13.3 Membuat Extension Client

13.4 Menandatangani Sertifikat Client

13.5 Memaksa User MySQL Menggunakan Sertifikat Client

13.6 Konfigurasi mysql2 Menggunakan Client Certificate

14. Troubleshooting SSL/TLS

14.1 Error: SSL_CTX_use_PrivateKey_file Failed

14.2 Error: Certificate and Private Key Do Not Match

14.3 Error: Certificate Verify Failed

14.4 Error: Hostname Mismatch