Cybersecurity & Ethical Hacking dengan Python - Tutorial Lengkap

Security Lab Demo kriptografi dapat dijalankan. Fitur jaringan butuh terminal lokal.

Python sering disebut sebagai "bahasa hacker". Mengapa? Karena Python memiliki ribuan pustaka keamanan yang powerful dan sintaks yang memungkinkan penulisan skrip serangan atau pertahanan dengan sangat cepat.

Profesional keamanan siber menggunakan Python untuk:

• Penetration Testing - Menguji keamanan sistem
• Analisis Malware - Membongkar kode berbahaya
• Forensik Digital - Investigasi insiden keamanan
• Automasi Keamanan - Scripting untuk defense/offense

⚠️ Disclaimer: Tutorial ini ditujukan semata-mata untuk tujuan pendidikan (Ethical Hacking). Jangan gunakan ilmu ini untuk menyerang sistem tanpa izin tertulis. Itu ilegal dan tidak etis.

Konsep Dasar: CIA Triad

Sebelum masuk ke kode, pahami tiga pilar keamanan informasi:

        ┌──────────────────┐
        │  CONFIDENTIALITY │
        │   (Kerahasiaan)  │
        └────────┬─────────┘
                 │
    ┌────────────┼────────────┐
    │            │            │
    ▼            ▼            ▼
┌───────┐   ┌───────┐   ┌───────┐
│ DATA  │◄──│PROTECT│──►│ACCESS │
└───────┘   └───────┘   └───────┘
    ▲            ▲            ▲
    │            │            │
    └────────────┼────────────┘
                 │
        ┌────────┴─────────┐
        │    INTEGRITY     │     ┌──────────────┐
        │   (Keutuhan)     │     │ AVAILABILITY │
        └──────────────────┘     │(Ketersediaan)│
                                 └──────────────┘

Kriptografi dengan Python

Kriptografi adalah seni mengamankan komunikasi. Mari pelajari dari yang paling dasar.

1. Encoding vs Encryption vs Hashing

2. Base64 Encoding (Interactive!)

Base64 bukan enkripsi, tapi sering digunakan untuk mentransfer data biner via teks.

import base64

# Encoding
pesan_asli = "Rahasia: Kode Akses 12345"
pesan_bytes = pesan_asli.encode('utf-8')
encoded = base64.b64encode(pesan_bytes)

print(f"Pesan Asli: {pesan_asli}")
print(f"Base64 Encoded: {encoded.decode()}")

# Decoding
decoded_bytes = base64.b64decode(encoded)
decoded = decoded_bytes.decode('utf-8')
print(f"Decoded: {decoded}")

3. Hashing Password dengan SHA-256

Password TIDAK BOLEH disimpan dalam teks biasa. Gunakan hash!

import hashlib

def hash_password(password):
    # SHA-256 menghasilkan 256-bit hash
    return hashlib.sha256(password.encode()).hexdigest()

# Simulasi: User mendaftar
password_user = "MySecretPass123!"
password_hash = hash_password(password_user)

print(f"Password Asli: {password_user}")
print(f"SHA-256 Hash: {password_hash}")
print(f"Panjang Hash: {len(password_hash)} karakter")

# Simulasi: User login
input_login = "MySecretPass123!"
if hash_password(input_login) == password_hash:
    print("\n[SUCCESS] Login berhasil!")
else:
    print("\n[FAILED] Password salah!")

4. Hashing dengan Salt (Lebih Aman!)

Hash biasa rentan terhadap Rainbow Table Attack. Tambahkan salt!

import hashlib
import secrets

def generate_salt():
    # Generate random salt 16 bytes
    return secrets.token_hex(16)

def hash_with_salt(password, salt):
    # Gabungkan password + salt, lalu hash
    salted = password + salt
    return hashlib.sha256(salted.encode()).hexdigest()

# Registrasi
password = "UserPassword123"
salt = generate_salt()
hashed = hash_with_salt(password, salt)

print(f"Password: {password}")
print(f"Salt: {salt}")
print(f"Hash (salted): {hashed}")

# Simpan di database: salt + hash
# Saat login, ambil salt dari database, hash input, bandingkan

# Verifikasi login
input_password = "UserPassword123"
if hash_with_salt(input_password, salt) == hashed:
    print("\n[SUCCESS] Verifikasi berhasil!")

5. HMAC (Hash-based Message Authentication Code)

HMAC memastikan pesan tidak diubah (integrity) DAN berasal dari pengirim yang sah (authenticity).

import hmac
import hashlib

# Kunci rahasia yang dishare antara pengirim dan penerima
secret_key = b"super_secret_key_12345"

# Pesan yang akan dikirim
message = "Transfer $1000 ke rekening 12345"

# Buat HMAC
signature = hmac.new(secret_key, message.encode(), hashlib.sha256).hexdigest()

print(f"Pesan: {message}")
print(f"HMAC Signature: {signature}")

# Verifikasi di sisi penerima
received_message = "Transfer $1000 ke rekening 12345"
expected_sig = hmac.new(secret_key, received_message.encode(), hashlib.sha256).hexdigest()

if hmac.compare_digest(signature, expected_sig):
    print("\n[VERIFIED] Pesan valid dan tidak diubah!")
else:
    print("\n[WARNING] Pesan telah dimodifikasi!")

Enkripsi Simetris dengan Fernet

Untuk enkripsi yang bisa didekripsi, gunakan library cryptography. Berikut konsepnya:

# Catatan: cryptography library tidak tersedia di browser
# Jalankan di terminal lokal Anda

# pip install cryptography

# from cryptography.fernet import Fernet

# # Generate key
# key = Fernet.generate_key()
# cipher = Fernet(key)

# # Encrypt
# message = b"Data rahasia perusahaan"
# encrypted = cipher.encrypt(message)
# print(f"Encrypted: {encrypted}")

# # Decrypt
# decrypted = cipher.decrypt(encrypted)
# print(f"Decrypted: {decrypted.decode()}")

print("Contoh kode Fernet ada di komentar di atas.")
print("Install: pip install cryptography")
print("Lalu jalankan di terminal lokal Anda.")

Analisis String & Pattern (Defensive)

Sebagai defender (Blue Team), Anda perlu menganalisis input untuk mendeteksi serangan.

Deteksi SQL Injection Sederhana

import re

def detect_sql_injection(user_input):
    # Pattern umum SQL injection
    dangerous_patterns = [
        r"(\b(SELECT|INSERT|UPDATE|DELETE|DROP|UNION)\b)",
        r"(--|#|/\*)",  # SQL comments
        r"(\bOR\b\s+\d+\s*=\s*\d+)",  # OR 1=1
        r"('\s*(OR|AND)\s*')",
        r"(;\s*(DROP|DELETE|UPDATE))",
    ]
    
    for pattern in dangerous_patterns:
        if re.search(pattern, user_input, re.IGNORECASE):
            return True, pattern
    return False, None

# Test cases
test_inputs = [
    "john_doe",
    "admin' OR '1'='1",
    "SELECT * FROM users",
    "normal_user123",
    "'; DROP TABLE users;--",
]

print("=== SQL INJECTION DETECTOR ===\n")
for inp in test_inputs:
    is_dangerous, matched = detect_sql_injection(inp)
    status = "[BLOCKED]" if is_dangerous else "[OK]"
    print(f"{status} Input: {inp[:30]}...")

Validasi & Sanitasi Input

import re
import html

def sanitize_input(user_input):
    # 1. Strip whitespace
    cleaned = user_input.strip()
    
    # 2. Escape HTML entities (prevent XSS)
    cleaned = html.escape(cleaned)
    
    # 3. Remove null bytes
    cleaned = cleaned.replace('\x00', '')
    
    return cleaned

def validate_username(username):
    # Hanya alfanumerik dan underscore, 3-20 karakter
    pattern = r'^[a-zA-Z0-9_]{3,20}$'
    return bool(re.match(pattern, username))

def validate_email(email):
    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
    return bool(re.match(pattern, email))

# Test
print("=== INPUT VALIDATION ===\n")

test_username = "admin<script>alert('xss')</script>"
sanitized = sanitize_input(test_username)
print(f"Original: {test_username}")
print(f"Sanitized: {sanitized}")
print(f"Valid username? {validate_username(sanitized)}")

print()
emails = ["[email protected]", "invalid-email", "[email protected]"]
for email in emails:
    print(f"Email '{email}': {'Valid' if validate_email(email) else 'Invalid'}")

Password Strength Checker

Tool untuk mengecek kekuatan password:

import re

def check_password_strength(password):
    score = 0
    feedback = []
    
    # Length check
    if len(password) >= 8:
        score += 1
    else:
        feedback.append("- Minimal 8 karakter")
    
    if len(password) >= 12:
        score += 1
    
    # Uppercase
    if re.search(r'[A-Z]', password):
        score += 1
    else:
        feedback.append("- Tambahkan huruf besar")
    
    # Lowercase
    if re.search(r'[a-z]', password):
        score += 1
    else:
        feedback.append("- Tambahkan huruf kecil")
    
    # Numbers
    if re.search(r'\d', password):
        score += 1
    else:
        feedback.append("- Tambahkan angka")
    
    # Special characters
    if re.search(r'[!@#$%^&*(),.?":{}|<>]', password):
        score += 1
    else:
        feedback.append("- Tambahkan karakter spesial (!@#$%...)")
    
    # Common password check
    common_passwords = ['password', '123456', 'qwerty', 'admin', 'letmein']
    if password.lower() in common_passwords:
        score = 0
        feedback = ["- Password terlalu umum!"]
    
    # Rating
    if score <= 2:
        strength = "LEMAH"
    elif score <= 4:
        strength = "SEDANG"
    else:
        strength = "KUAT"
    
    return strength, score, feedback

# Test
passwords = ["123456", "Password1", "MyS3cur3P@ss!", "abc"]

print("=== PASSWORD STRENGTH CHECKER ===\n")
for pwd in passwords:
    strength, score, feedback = check_password_strength(pwd)
    print(f"Password: {pwd}")
    print(f"Kekuatan: {strength} ({score}/6)")
    if feedback:
        print("Saran:")
        for f in feedback:
            print(f"  {f}")
    print()

Port Scanner (Konsep - Local Only)

Berikut adalah konsep Port Scanner. Kode ini membutuhkan akses jaringan dan harus dijalankan di terminal lokal.

import socket
import datetime

# PERINGATAN: Jalankan hanya pada sistem yang Anda miliki izin!
# Kode ini tidak bisa dijalankan di browser.

target = "127.0.0.1"  # Ganti dengan target ANDA SENDIRI

def port_scan(target_ip, start_port=1, end_port=100):
    print(f"--- Scanning {target_ip} ---")
    print(f"Waktu mulai: {datetime.datetime.now()}")
    print(f"Port range: {start_port}-{end_port}\n")
    
    open_ports = []
    
    for port in range(start_port, end_port + 1):
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        socket.setdefaulttimeout(0.5)
        
        result = sock.connect_ex((target_ip, port))
        if result == 0:
            open_ports.append(port)
            print(f"[+] Port {port}: OPEN")
        
        sock.close()
    
    print(f"\nTotal port terbuka: {len(open_ports)}")
    return open_ports

# Uncomment untuk menjalankan (di terminal lokal):
# port_scan(target, 20, 80)

print("Port Scanner membutuhkan akses jaringan.")
print("Jalankan di terminal lokal dengan: python scanner.py")

OWASP Top 10 - Awareness

Setiap developer dan security professional harus tahu OWASP Top 10 (kerentanan web paling umum):

Library Security Python yang Wajib Diketahui

Tips Keamanan untuk Developer Python

Do's ✅

1. Gunakan secrets untuk random, bukan random

   import secrets
   token = secrets.token_hex(32)  # Cryptographically secure
   

2. Validasi SEMUA input dari user

3. Gunakan parameterized queries untuk database

   # BENAR
   cursor.execute("SELECT * FROM users WHERE id = ?", (user_id,))
   
   # SALAH (vulnerable to SQL injection)
   # cursor.execute(f"SELECT * FROM users WHERE id = {user_id}")
   

4. Update dependencies secara berkala

   pip list --outdated
   pip install --upgrade package_name
   

Don'ts ❌

1. Jangan simpan secrets di kode - Gunakan environment variables
2. Jangan gunakan MD5 atau SHA1 untuk password - Gunakan bcrypt atau Argon2
3. Jangan disable SSL verification - verify=False adalah red flag

FAQ: Cybersecurity dengan Python

Sumber Daya Tambahan

Buku

• Black Hat Python - Justin Seitz (Wajib baca!)
• Violent Python - TJ O'Connor

Website

• OWASP: owasp.org
• Hack The Box: hackthebox.com
• TryHackMe: tryhackme.com

Tools

• Kali Linux: kali.org
• Burp Suite: Web application security testing
• Wireshark: Network packet analyzer

Kesimpulan

Python memberikan kekuatan besar di tangan praktisi keamanan. Dengan skrip beberapa baris, Anda bisa:

• Mengotomatisasi pengujian keamanan
• Menganalisis data forensik
• Membangun tools pertahanan

Namun, ingatlah etika White Hat:

"Dengan kekuatan besar, datang tanggung jawab besar."

Gunakan kemampuan Anda untuk mengamankan dan melindungi sistem, bukan merusaknya.

Edit tutorial ini