Linux Command Line & Bash Scripting Mastery · Pelajaran

Penanganan Rahasia yang Aman dan Kebersihan Environment

Jauhkan kredensial dari daftar proses dan log menggunakan stdin, file, serta environment yang sudah dibersihkan.

Penanganan Rahasia yang Aman dan Kebersihan Environment adalah pelajaran Linux Command Line & Bash Scripting Mastery gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Linux Command Line & Bash Scripting Mastery, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Linux Command Line & Bash Scripting Mastery mencakup 4 pelajaran total.

Mengapa Kebersihan Rahasia Penting

Rahasia — kunci API, kata sandi, token — adalah data paling sensitif dalam sistem apa pun. Penanganan yang keliru dalam skrip Bash merupakan salah satu kesalahan keamanan yang paling umum dan paling merusak.

Daftar proses: Argumen yang diteruskan ke perintah muncul di ps aux, /proc/<pid>/cmdline, dan log audit sistem — terlihat oleh semua pengguna pada host.
Riwayat shell: Perintah yang diketik secara interaktif (dan terkadang skrip) dicatat dalam ~/.bash_history.
File log: Jejak set -x, log aplikasi, dan keluaran CI/CD dapat merekam nilai variabel.
Kebocoran lingkungan: Proses anak mewarisi seluruh lingkungan proses induknya, termasuk rahasia yang diekspor.

Skrip yang diperkuat memperlakukan rahasia seperti bahan radioaktif — minimalkan waktu paparan, batasi permukaan paparan, dan bersihkan semuanya saat dikeluarkan.

Permukaan Serangan pada Daftar Proses

Ketika Anda meneruskan rahasia sebagai argumen baris perintah, setiap pengguna di sistem dapat langsung membacanya melalui ps. Ini bukan sekadar teori — hal ini rutin dieksploitasi pada hosting bersama dan lingkungan kontainer.

Cuplikan di bawah menunjukkan masalah dan perbaikannya secara berdampingan.

#!/usr/bin/env bash
# DANGEROUS: password visible in 'ps aux' output
# curl -u "admin:SuperSecret123" https://api.example.com/data

# SAFE: pass credentials via stdin or a flag that reads from a file
# Many tools support reading secrets from stdin with '-' or dedicated flags:

# Option 1 — pipe the secret so it never appears in argv
echo 'SuperSecret123' | curl -u 'admin' --password-stdin \
  https://api.example.com/data 2>/dev/null || true

# Option 2 — write a temporary netrc and point curl at it
# (covered in a later scene)
echo 'Secret never touches the command line this way'

Membaca Rahasia dari stdin

Pola interaktif yang paling aman adalah membaca rahasia saat runtime menggunakan read -rs. Bendera -s menonaktifkan gema sehingga karakter tidak pernah ditampilkan, sedangkan -r mencegah interpretasi garis miring terbalik.

Poin penting:

Variabel tidak pernah diekspor, sehingga proses anak tidak dapat melihatnya melalui /proc/<pid>/environ.
Setelah digunakan, segera hapus variabel tersebut untuk memperpendek jendela paparan.
Hindari echo "$SECRET" — gunakan printf '%s' untuk mencegah baris baru di akhir merusak nilai dan agar tetap tidak terlihat dalam jejak.

#!/usr/bin/env bash
set -euo pipefail

# Prompt on stderr so stdout stays clean for piping
read -rsp 'Enter API token: ' API_TOKEN <&2
printf '\n' >&2

# Use the secret — printf keeps it out of argv
response=$(printf '%s' "$API_TOKEN" | curl -sS -X POST \
  -H 'Content-Type: application/json' \
  --data-binary @- \
  https://httpbin.org/post 2>/dev/null) || true

echo "Request sent."

# Scrub immediately — unset removes it from shell memory
unset API_TOKEN

Rahasia dalam Berkas: Hak Akses dan Kepemilikan

Ketika suatu rahasia harus disimpan di disk (misalnya, kunci akun layanan), hak akses berkas adalah pertahanan utama Anda.

Mode 0600 — hanya dapat dibaca dan ditulis oleh pemiliknya. Tidak ada akses untuk grup maupun pengguna lain.
Mode 0400 — hanya dapat dibaca oleh pemiliknya. Pilih ini untuk kunci yang tidak boleh tertimpa secara tidak sengaja.
Simpan berkas rahasia di dalam direktori khusus seperti ~/.secrets/ atau /run/secrets/ (yang terakhir merupakan tmpfs berbasis RAM pada banyak sistem Linux dan hanya bertahan hingga sistem dimulai ulang).
Jangan pernah menempatkan berkas rahasia di dalam direktori yang dilacak git tanpa .gitignore yang benar-benar kuat.

#!/usr/bin/env bash
set -euo pipefail

SECRETS_DIR="${HOME}/.secrets"
mkdir -p "$SECRETS_DIR"
chmod 700 "$SECRETS_DIR"   # directory: only owner can list contents

KEY_FILE="${SECRETS_DIR}/api_token"

# Write secret — atomically restrict permissions before writing content
install -m 0600 /dev/null "$KEY_FILE"
printf '%s' 'my-super-secret-token' > "$KEY_FILE"

echo "Permissions:"
ls -la "$KEY_FILE"

# Read back safely — no subshell, no echo
API_TOKEN=$(< "$KEY_FILE")
echo "Token length: ${#API_TOKEN} chars (value not printed)"
unset API_TOKEN

Menggunakan Berkas .netrc dengan curl

curl mendukung berkas ~/.netrc (atau jalur apa pun melalui --netrc-file) yang memetakan nama host ke kredensial. Dengan begitu, data autentikasi sepenuhnya tidak terlihat dari baris perintah dan isi skrip.

Format berkasnya sederhana:

machine api.example.com
  login admin
  password s3cr3t

Praktik terbaik:

Selalu tetapkan chmod 0600 ~/.netrc — curl menolak berkas tersebut jika dapat dibaca oleh pengguna lain pada beberapa sistem.
Gunakan --netrc-file /run/secrets/netrc untuk menunjuk ke rahasia yang didukung tmpfs atau disuntikkan ke kontainer.
Bersihkan berkas netrc sementara dengan trap pada EXIT.

#!/usr/bin/env bash
set -euo pipefail

TMP_NETRC=$(mktemp)
chmod 0600 "$TMP_NETRC"

# Trap ensures cleanup even on error or signal
trap 'rm -f "$TMP_NETRC"' EXIT

# Write credentials to the temp netrc
cat > "$TMP_NETRC" <<'EOF'
machine httpbin.org
  login myuser
  password mypassword
EOF

curl -fsS --netrc-file "$TMP_NETRC" \
  https://httpbin.org/basic-auth/myuser/mypassword \
  -o /dev/null -w 'HTTP %{http_code}\n' || true

# trap fires here: $TMP_NETRC is deleted
echo 'Temp netrc cleaned up by trap.'

Kebersihan Variabel Lingkungan

Variabel lingkungan adalah cara populer untuk memasukkan rahasia ke dalam skrip (aplikasi 12-factor, pipeline CI/CD). Namun, variabel tersebut bocor ke setiap proses anak dan muncul di /proc/<pid>/environ selama masa hidup proses.

Pola perlindungan:

Segera masukkan rahasia ke variabel lokal dan hapus variabel lingkungan agar proses anak tidak dapat mewarisinya.
Teruskan rahasia hanya ke perintah tertentu menggunakan env -i atau penetapan sebaris, bukan seluruh lingkungan yang diwarisi.
Jangan pernah export variabel rahasia — jika memungkinkan, gunakan penetapan saja (tanpa export).

#!/usr/bin/env bash
set -euo pipefail

# Simulate a secret arriving via environment (e.g., from CI system)
export DB_PASSWORD='hunter2'   # set by CI — we did not choose this

# Capture locally, then strip from environment immediately
db_password="$DB_PASSWORD"
unset DB_PASSWORD

# Verify the env var is gone before spawning any child process
if printenv DB_PASSWORD 2>/dev/null; then
  echo 'ERROR: DB_PASSWORD still in environment!' >&2
  exit 1
fi

echo 'Secret captured and env var scrubbed.'
echo "Password length: ${#db_password}"
unset db_password

Mencegah Rahasia Muncul dalam Jejak set -x

set -x (xtrace) sangat berguna untuk men-debug, tetapi akan mencetak nilai setiap variabel yang diperluas — termasuk rahasia — ke stderr. Jejak ini sering berakhir di log CI atau syslog.

Strategi untuk melindungi rahasia sambil tetap mempertahankan penelusuran yang berguna:

Nonaktifkan penelusuran sementara di sekitar operasi sensitif dengan { set +x; } 2>/dev/null.
Aktifkan kembali setelahnya dengan set -x.
Alihkan keluaran xtrace ke deskriptor berkas terpisah yang mengarah ke berkas log terlindungi, bukan ke aliran log publik.

#!/usr/bin/env bash
set -euo pipefail
set -x   # tracing ON — safe for non-sensitive sections

echo 'Building application...'
SRC_DIR='/tmp/build'
mkdir -p "$SRC_DIR"

# Disable xtrace around secret handling (suppress the set +x line itself)
{ set +x; } 2>/dev/null

read -rsp 'Token (hidden from trace): ' SECRET_TOKEN <&2
printf '\n' >&2
token_len=${#SECRET_TOKEN}
unset SECRET_TOKEN

set -x  # tracing back ON

echo "Token captured (length=$token_len). Continuing build..."
ls "$SRC_DIR"

Membersihkan Rahasia dari Berkas Log

Meskipun Anda sudah berhati-hati, rahasia terkadang masuk ke keluaran log — terutama dalam skrip bertele-tele atau lama. Fungsi pembungkus pencatatan yang menyamarkan pola yang telah diketahui dapat menjadi lapisan pengaman tambahan.

Pola ini menggunakan penggantian berbasis regex pada seluruh keluaran log. Ini adalah lapisan pilihan terakhir, bukan pengganti praktik kebersihan lain yang telah dibahas.

#!/usr/bin/env bash
set -euo pipefail

# A logging function that scrubs common secret patterns before writing
log() {
  local line
  # Replace anything that looks like key=VALUE or password=VALUE
  line=$(printf '%s\n' "$*" \
    | sed -E 's/(password|token|secret|key)=[^[:space:]]*/\1=***REDACTED***/gi')
  printf '[%s] %s\n' "$(date -u '+%T')" "$line"
}

# Usage:
log 'Connecting to database with password=hunter2'
log 'Loaded API token=sk-abc123xyz secret'
log 'Build step completed successfully'   # unchanged

Lingkungan Terisolasi dengan env -i

env -i menjalankan perintah dengan lingkungan yang sepenuhnya kosong, sehingga semua variabel yang diwarisi — termasuk rahasia yang tidak sengaja terbawa — tidak sampai ke proses anak. Setelah itu, Anda meneruskan secara eksplisit hanya hal-hal yang diperlukan.

Ini sangat berguna saat menjalankan skrip yang tidak tepercaya, alat pembangunan, atau utilitas pihak ketiga yang mungkin mengeksfiltrasi data lingkungan.

#!/usr/bin/env bash
set -euo pipefail

# Polluted parent environment (simulating a CI runner)
export AWS_SECRET_ACCESS_KEY='AKIAIOSFODNN7EXAMPLE'
export GITHUB_TOKEN='ghp_faketoken123'
export HOME="$HOME"
export PATH="$PATH"

echo '--- Child sees full environment:'
env | grep -E 'AWS|GITHUB' | head -5

echo '--- Sanitised child (env -i) sees nothing secret:'
env -i HOME="$HOME" PATH="$PATH" TERM="${TERM:-dumb}" \
  bash -c 'env | grep -E "AWS|GITHUB" || echo "No secrets visible"'

unset AWS_SECRET_ACCESS_KEY GITHUB_TOKEN

Berkas Rahasia Sementara di tmpfs

tmpfs adalah sistem berkas berbasis RAM. Berkas yang ditulis di sana tidak pernah disimpan ke disk, sehingga menghilangkan risiko rahasia bertahan di ruang swap, tembolok disk, atau snapshot.

Di Linux, /dev/shm dan /run/user/<uid> biasanya merupakan kait tmpfs.
Selalu gunakan tmpfs bersama trap EXIT untuk menghapus berkas saat skrip selesai.
Dalam kontainer (Docker, Kubernetes), rahasia dapat dikaitkan sebagai volume tmpfs langsung ke /run/secrets.

#!/usr/bin/env bash
set -euo pipefail

# Prefer /run/user/$UID (user-owned tmpfs) or /dev/shm (world-readable dir!)
if [[ -d "/run/user/$UID" ]]; then
  TMPFS_DIR="/run/user/$UID"
elif [[ -d '/dev/shm' ]]; then
  TMPFS_DIR='/dev/shm'
else
  # Fallback: warn that disk will be used
  echo 'WARNING: No tmpfs available; using /tmp (disk-backed)' >&2
  TMPFS_DIR='/tmp'
fi

SECRET_FILE=$(mktemp "${TMPFS_DIR}/secret.XXXXXX")
chmod 0600 "$SECRET_FILE"
trap 'shred -u "$SECRET_FILE" 2>/dev/null || rm -f "$SECRET_FILE"' EXIT

printf '%s' 'my-runtime-token' > "$SECRET_FILE"
echo "Secret stored in: $SECRET_FILE"
df -T "$SECRET_FILE" | awk 'NR==2 {print "Filesystem type:", $2}'

# Use the secret...
token=$(< "$SECRET_FILE")
echo "Token length: ${#token}"
unset token
# trap fires on exit: file shredded

Menggabungkan Semuanya: Skrip Deployment yang Diperkuat

Skrip berikut menggabungkan setiap teknik dari pelajaran ini menjadi pembantu deployment yang realistis. Perhatikan bagaimana setiap lapisan pertahanan memperkuat lapisan lainnya:

pembacaan stdin dengan -s — tidak ada gema terminal
berkas rahasia tmpfs dengan pembersihan trap
pembersihan lingkungan — rahasia dihapus sebelum subprocess apa pun dijalankan
pelindung xtrace — penelusuran dihentikan sementara di sekitar kode sensitif
penyamaran log — regex pengaman sebelum menulis ke log

#!/usr/bin/env bash
set -euo pipefail

### 1. Redacting logger
log() {
  local msg
  msg=$(printf '%s' "$*" \
    | sed -E 's/(password|token|secret|key)=[^[:space:]]*/\1=***/gi')
  printf '[%s] %s\n' "$(date -u +%T)" "$msg"
}

### 2. tmpfs secret store
TMPFS_DIR="${XDG_RUNTIME_DIR:-/tmp}"
SECRET_FILE=$(mktemp "${TMPFS_DIR}/deploy_token.XXXXXX")
chmod 0600 "$SECRET_FILE"
trap 'rm -f "$SECRET_FILE"; log "Secret file cleaned up."' EXIT

### 3. Read secret without trace
{ set +x; } 2>/dev/null
read -rsp 'Deploy token: ' _tok <&2; printf '\n' >&2
printf '%s' "$_tok" > "$SECRET_FILE"
unset _tok
set -x

### 4. Scrub inherited env vars before subprocess
unset DEPLOY_TOKEN 2>/dev/null || true

log 'Starting deployment...'
# Simulate deploy using secret from file (token never in argv)
# curl -H "Authorization: Bearer $(< $SECRET_FILE)" https://api.example.com/deploy
log 'Deployment complete. token=hidden_by_redactor'

echo 'Done.'

Uji Pengetahuan: Paparan Rahasia melalui Daftar Proses

Uji pemahaman Anda tentang cara rahasia bocor melalui daftar proses dan cara mencegahnya.

Rangkuman Pelajaran: Penanganan Rahasia yang Aman

Anda telah menyelesaikan Penanganan Rahasia yang Aman dan Kebersihan Lingkungan. Berikut referensi singkat tentang semua hal yang telah dibahas:

Daftar proses: Jangan pernah meneruskan rahasia sebagai argumen baris perintah — rahasia akan muncul di ps aux dan /proc/<pid>/cmdline. Gunakan pengaliran stdin atau --netrc-file.
Pembacaan stdin: Gunakan read -rs untuk mengambil rahasia secara interaktif tanpa gema terminal atau paparan dalam riwayat shell.
Hak akses berkas: Berkas rahasia harus menggunakan chmod 0600 (atau 0400). Gunakan install -m 0600 untuk pembuatan atomik.
Berkas netrc: Serahkan kredensial ke berkas sementara yang ditunjuk oleh --netrc-file; bersihkan dengan trap EXIT.
Kebersihan lingkungan: Segera unset variabel lingkungan rahasia setelah menyimpannya secara lokal; jangan pernah export secara tidak perlu; gunakan env -i untuk mengisolasi proses anak.
Pelindung xtrace: Bungkus kode sensitif dengan { set +x; } 2>/dev/null ... set -x untuk mencegah jejak debug membocorkan nilai.
Penyamaran log: Gunakan pencatat berbasis sed sebagai jaring pengaman pilihan terakhir.
tmpfs: Simpan rahasia runtime di /run/user/$UID atau /dev/shm agar tidak pernah menyentuh disk; hancurkan saat keluar.

Pertahanan berlapis adalah pola pikir utama: tidak ada satu tindakan yang cukup, tetapi menggabungkannya membuat kebocoran rahasia sangat sulit terjadi.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Penanganan Rahasia yang Aman dan Kebersihan Environment” gratis?

Ya — teks lengkap “Penanganan Rahasia yang Aman dan Kebersihan Environment” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Linux Command Line & Bash Scripting Mastery, upgrade ke CoddyKit PRO. Kursus Linux Command Line & Bash Scripting Mastery mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Penanganan Rahasia yang Aman dan Kebersihan Environment”?

Jauhkan kredensial dari daftar proses dan log menggunakan stdin, file, serta environment yang sudah dibersihkan. Kamu berlatih Linux Command Line & Bash Scripting Mastery dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Linux Command Line & Bash Scripting Mastery?

Tidak diperlukan pengalaman sebelumnya. Linux Command Line & Bash Scripting Mastery di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Penanganan Rahasia yang Aman dan Kebersihan Environment” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Linux Command Line & Bash Scripting Mastery ini?

Ya. Setiap pelajaran Linux Command Line & Bash Scripting Mastery menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Mencegah Injeksi Perintah dan Argumen
Penanganan Rahasia yang Aman dan Kebersihan Environment
Eksekusi dengan Hak Minimum dan Disiplin sudo
Analisis Statis dan Audit dengan ShellCheck

← Kembali ke Linux Command Line & Bash Scripting Mastery