Cybersecurity Cơ Bản: Bảo Mật Thông Tin Trong Kỷ Nguyên Số

An toàn thông tin là chủ đề quan trọng trong Tin học 12. Hãy cùng tìm hiểu cách bảo vệ dữ liệu cá nhân và ứng dụng web trong thực tế!

Ôn Tập Kiến Thức Lớp 12

An Toàn Thông Tin Là Gì?

Chú thích: Bảo vệ thông tin khỏi truy cập trái phép, thay đổi, hoặc phá hủy!

Ba Yếu Tố CIA (từ SGK):

1. Confidentiality (Tính bí mật):
   - Chỉ người được phép mới truy cập
   - Ví dụ: Password, mã hóa dữ liệu

2. Integrity (Tính toàn vẹn):
   - Dữ liệu không bị thay đổi trái phép
   - Ví dụ: Checksum, digital signature

3. Availability (Tính sẵn sàng):
   - Dữ liệu luôn có thể truy cập khi cần
   - Ví dụ: Backup, redundancy

Các Mối Đe Dọa

Malware (Phần mềm độc hại):
- Virus: Tự sao chép, lây lan
- Trojan: Ngụy trang thành phần mềm hợp lệ
- Ransomware: Mã hóa dữ liệu, đòi tiền chuộc
- Spyware: Thu thập thông tin

Tấn công mạng:
- Phishing: Giả mạo email/website
- DDoS: Tấn công từ chối dịch vụ
- Man-in-the-Middle: Nghe lén, thay đổi dữ liệu
- SQL Injection: Tấn công database

Mật Khẩu Mạnh

Tạo Password An Toàn

Chú thích: Password yếu = cửa mở cho hacker!

❌ Password YẾU:
- 123456
- password
- qwerty
- nguyenvana
- 01011990

✅ Password MẠNH:
- Tr0ng#2025@Secure!
- My$ecur3P@ssw0rd
- K!m_Ch1_2025#Vn

Quy tắc:
- Tối thiểu 12 ký tự
- Chữ hoa + chữ thường + số + ký tự đặc biệt
- Không dùng thông tin cá nhân
- Khác nhau cho mỗi tài khoản
- Thay đổi định kỳ

Password Manager

Công cụ quản lý mật khẩu:

1Password:
- Lưu trữ tất cả password
- Tạo password mạnh tự động
- Autofill trên mọi thiết bị

Bitwarden (Free & Open Source):
- End-to-end encryption
- Cross-platform
- Self-hosted option

LastPass, Dashlane, Keeper:
- Nhiều tính năng
- Sync đa thiết bị
- Chia sẻ password an toàn

2FA - Two-Factor Authentication

Chú thích: Xác thực 2 yếu tố = Password + Mã OTP/App!

# Ví dụ: Enable 2FA với Python
import pyotp
import qrcode

# 1. Tạo secret key
secret = pyotp.random_base32()
print(f"Secret: {secret}")

# 2. Tạo QR code cho Google Authenticator
uri = pyotp.totp.TOTP(secret).provisioning_uri(
    name="user@example.com",
    issuer_name="MyApp"
)
qrcode.make(uri).save("qr_code.png")

# 3. Verify OTP code
totp = pyotp.TOTP(secret)
code = input("Enter OTP code: ")

if totp.verify(code):
    print("✅ Login successful!")
else:
    print("❌ Invalid code!")

"""
Các loại 2FA:
- SMS OTP: Nhận mã qua tin nhắn
- Authenticator App: Google Authenticator, Authy
- Hardware Key: YubiKey, Titan Security Key
- Biometric: Vân tay, Face ID
"""

Mã Hóa (Encryption)

Symmetric Encryption

Chú thích: Dùng CÙNG khóa để mã hóa và giải mã!

from cryptography.fernet import Fernet

# 1. Tạo key
key = Fernet.generate_key()
print(f"Key: {key}")

# 2. Tạo cipher
cipher = Fernet(key)

# 3. Mã hóa
message = "Đây là thông tin bí mật!"
encrypted = cipher.encrypt(message.encode())
print(f"Encrypted: {encrypted}")

# 4. Giải mã
decrypted = cipher.decrypt(encrypted).decode()
print(f"Decrypted: {decrypted}")

"""
Output:
Key: b'gAAAAABl...'
Encrypted: b'gAAAAABl...'
Decrypted: Đây là thông tin bí mật!

Thuật toán phổ biến:
- AES (Advanced Encryption Standard): Chuẩn hiện tại
- DES, 3DES: Cũ, ít dùng
- Blowfish, Twofish
"""

Asymmetric Encryption (RSA)

Chú thích: Dùng cặp khóa Public-Private! Public key mã hóa, Private key giải mã.

from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import serialization, hashes

# 1. Tạo cặp khóa
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048
)
public_key = private_key.public_key()

# 2. Mã hóa với public key
message = b"Secret message"
encrypted = public_key.encrypt(
    message,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)
print(f"Encrypted: {encrypted[:50]}...")

# 3. Giải mã với private key
decrypted = private_key.decrypt(
    encrypted,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)
print(f"Decrypted: {decrypted}")

"""
Ứng dụng RSA:
- SSL/TLS (HTTPS)
- Email encryption (PGP)
- Digital signatures
- SSH keys
"""

Hash Functions

Chú thích: Hash = Chuyển dữ liệu thành chuỗi cố định, KHÔNG thể đảo ngược!

import hashlib

# SHA-256
message = "Hello World"
hash_object = hashlib.sha256(message.encode())
hash_hex = hash_object.hexdigest()
print(f"SHA-256: {hash_hex}")

# MD5 (không an toàn, chỉ dùng checksum)
md5_hash = hashlib.md5(message.encode()).hexdigest()
print(f"MD5: {md5_hash}")

"""
Output:
SHA-256: a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146e
MD5: b10a8db164e0754105b7a99be72e3fe5

Đặc điểm hash:
- Một chiều (không đảo ngược)
- Kết quả cố định (SHA-256 = 256 bit)
- Thay đổi nhỏ → hash hoàn toàn khác
- Va chạm rất khó xảy ra

Ứng dụng:
- Lưu password (hash + salt)
- Kiểm tra file integrity
- Blockchain (Bitcoin)
- Digital signatures
"""

# Password hashing với bcrypt
import bcrypt

# Hash password
password = b"MySecurePassword123!"
salt = bcrypt.gensalt()
hashed = bcrypt.hashpw(password, salt)
print(f"Hashed password: {hashed}")

# Verify password
if bcrypt.checkpw(password, hashed):
    print("✅ Password correct!")
else:
    print("❌ Wrong password!")

Bảo Mật Web

1. SQL Injection

Chú thích: Hacker chèn code SQL độc hại vào input!

# ❌ MÃ KHÔNG AN TOÀN
import sqlite3

def login_insecure(username, password):
    """Dễ bị SQL injection!"""
    conn = sqlite3.connect('users.db')
    cursor = conn.cursor()
    
    # Nguy hiểm: nối chuỗi trực tiếp!
    query = f"SELECT * FROM users WHERE username='{username}' AND password='{password}'"
    cursor.execute(query)
    
    user = cursor.fetchone()
    return user is not None

# Tấn công:
# username = "admin' OR '1'='1"
# password = "anything"
# Query trở thành:
# SELECT * FROM users WHERE username='admin' OR '1'='1' AND password='anything'
# → '1'='1' luôn True → Login thành công!

# ✅ MÃ AN TOÀN
def login_secure(username, password):
    """Dùng parameterized queries"""
    conn = sqlite3.connect('users.db')
    cursor = conn.cursor()
    
    # An toàn: dùng placeholders
    query = "SELECT * FROM users WHERE username=? AND password=?"
    cursor.execute(query, (username, password))
    
    user = cursor.fetchone()
    return user is not None

# Với ORM (Flask-SQLAlchemy)
from flask_sqlalchemy import SQLAlchemy

# ✅ Tự động escape
user = User.query.filter_by(username=username, password=password).first()

2. Cross-Site Scripting (XSS)

Chú thích: Hacker chèn JavaScript độc hại vào website!

# ❌ KHÔNG AN TOÀN
from flask import Flask, request

app = Flask(__name__)

@app.route('/comment')
def comment_insecure():
    """XSS vulnerable!"""
    user_input = request.args.get('text', '')
    # Hiển thị trực tiếp → Nguy hiểm!
    return f"<p>Comment: {user_input}</p>"

# Tấn công:
# /comment?text=<script>alert('Hacked!');</script>
# → Script chạy trên browser của mọi người xem!

# ✅ AN TOÀN
from flask import escape

@app.route('/comment')
def comment_secure():
    """Escape HTML"""
    user_input = request.args.get('text', '')
    # Escape: < thành &lt;, > thành &gt;
    return f"<p>Comment: {escape(user_input)}</p>"

# Hoặc dùng template engine (Jinja2)
from flask import render_template_string

@app.route('/comment')
def comment_template():
    user_input = request.args.get('text', '')
    # Jinja2 tự động escape
    return render_template_string("<p>Comment: {{ text }}</p>", text=user_input)

"""
Các loại XSS:
1. Reflected XSS: Trong URL, form
2. Stored XSS: Lưu trong database
3. DOM-based XSS: Thay đổi DOM

Phòng chống:
- Escape/sanitize input
- Content Security Policy (CSP)
- HttpOnly cookies
"""

3. Cross-Site Request Forgery (CSRF)

# ❌ KHÔNG CÓ CSRF PROTECTION
from flask import Flask, request, session

@app.route('/transfer', methods=['POST'])
def transfer_money():
    """Chuyển tiền - không có CSRF token"""
    if 'user_id' in session:
        amount = request.form.get('amount')
        to_account = request.form.get('to')
        # Thực hiện chuyển tiền...
        return "Transfer successful"
    return "Not logged in"

# Tấn công:
# Hacker tạo trang web:
"""
<form action="http://yourbank.com/transfer" method="POST">
    <input name="amount" value="1000000">
    <input name="to" value="hacker_account">
</form>
<script>document.forms[0].submit();</script>
"""
# Nếu victim đang login → Tự động chuyển tiền!

# ✅ VỚI CSRF PROTECTION
from flask_wtf.csrf import CSRFProtect

app = Flask(__name__)
app.secret_key = 'super-secret-key'
csrf = CSRFProtect(app)

@app.route('/transfer', methods=['POST'])
@csrf.exempt  # Hoặc check token thủ công
def transfer_money():
    """CSRF protected"""
    # Flask-WTF tự động check CSRF token
    if 'user_id' in session:
        amount = request.form.get('amount')
        to_account = request.form.get('to')
        return "Transfer successful"
    return "Not logged in"

# Template phải include CSRF token
"""
<form method="POST">
    {{ csrf_token() }}
    <input name="amount">
    <input name="to">
    <button type="submit">Transfer</button>
</form>
"""

4. Secure Session Management

from flask import Flask, session
from datetime import timedelta

app = Flask(__name__)
app.secret_key = 'generate-strong-random-key-here'

# Cấu hình session an toàn
app.config.update(
    SESSION_COOKIE_SECURE=True,      # Chỉ gửi qua HTTPS
    SESSION_COOKIE_HTTPONLY=True,    # Không truy cập từ JavaScript
    SESSION_COOKIE_SAMESITE='Lax',   # CSRF protection
    PERMANENT_SESSION_LIFETIME=timedelta(hours=1)  # Timeout
)

@app.route('/login', methods=['POST'])
def login():
    username = request.form.get('username')
    password = request.form.get('password')
    
    # Verify credentials (hash + salt)
    user = verify_login(username, password)
    
    if user:
        session.permanent = True
        session['user_id'] = user.id
        session['username'] = user.username
        # Regenerate session ID sau khi login
        session.modified = True
        return "Login successful"
    
    return "Invalid credentials"

@app.route('/logout')
def logout():
    # Clear session
    session.clear()
    return "Logged out"

HTTPS & SSL/TLS

Tại Sao Cần HTTPS?

Chú thích: HTTP = dữ liệu truyền dạng plain text, ai cũng đọc được!

HTTP (Not Secure):
Client → [Username: admin, Password: 123] → Server
         ↑ Hacker có thể nghe lén!

HTTPS (Secure):
Client → [Encrypted data: a8f7d9e...] → Server
         ↑ Hacker chỉ thấy rác!

HTTPS = HTTP + SSL/TLS:
- Encryption: Mã hóa dữ liệu
- Authentication: Xác thực server
- Integrity: Đảm bảo không bị sửa đổi

Certificate Authority (CA)

SSL Certificate từ Let's Encrypt (FREE):

1. Cài Certbot
   sudo apt install certbot python3-certbot-nginx

2. Tạo certificate
   sudo certbot --nginx -d yourdomain.com

3. Auto-renewal
   sudo certbot renew --dry-run

→ Website của bạn có HTTPS! 🔒

HTTPS Trong Flask

from flask import Flask

app = Flask(__name__)

@app.route('/')
def index():
    return "Hello, HTTPS!"

if __name__ == '__main__':
    # Development: self-signed certificate
    app.run(
        host='0.0.0.0',
        port=443,
        ssl_context=('cert.pem', 'key.pem')
    )

# Production: Dùng Nginx + Let's Encrypt

An Toàn Cá Nhân

Email Security

Nhận diện Phishing:

❌ Dấu hiệu Email GIẢ MẠO:
- Từ: support@paypa1.com (số 1 thay chữ l)
- Tiêu đề: "URGENT: Your account will be closed!"
- Nội dung: "Click here to verify"
- Link: http://paypal-verify-12345.suspicious.com

✅ Email THẬT:
- Domain chính xác: @paypal.com
- Không đòi mật khẩu qua email
- Link hover: kiểm tra URL thật
- Grammar tốt, professional

Social Engineering

Chú thích: Lợi dụng tâm lý con người để đánh cắp thông tin!

Kỹ thuật phổ biến:

1. Pretexting:
   "Xin chào, tôi từ IT department. Cho tôi password
    để kiểm tra hệ thống."
   → KHÔNG BAO GIỜ cho password!

2. Baiting:
   USB drive "SALARY_2025.xlsx" bỏ ở parking lot
   → Cắm vào → Malware!

3. Quid Pro Quo:
   "Trả lời survey này nhận iPhone 15 free!"
   → Yêu cầu thông tin cá nhân

4. Tailgating:
   Theo sau vào cửa không cần badge
   → "Forgot my card, can you hold the door?"

Phòng chống:
- Xác minh danh tính qua kênh chính thức
- Không chia sẻ thông tin nhạy cảm
- Báo cáo hành vi đáng ngờ
- Training nhân viên

WiFi Public

Nguy hiểm WiFi công cộng:

❌ KHÔNG AN TOÀN:
- Cafe, sân bay, khách sạn
- Không mã hóa
- Hacker có thể nghe lén
- Man-in-the-Middle attack

✅ SỬ DỤNG AN TOÀN:
1. Dùng VPN (Virtual Private Network)
   - Mã hóa toàn bộ traffic
   - NordVPN, ExpressVPN, ProtonVPN

2. Tránh:
   - Online banking
   - Shopping
   - Login tài khoản quan trọng

3. Check:
   - Website có HTTPS
   - Tắt auto-connect WiFi
   - Forget network sau khi dùng

Privacy - Quyền Riêng Tư

Browser Privacy

# Cookie Tracking Example
from flask import Flask, request, make_response
import uuid

app = Flask(__name__)

@app.route('/')
def index():
    # Đọc cookie
    user_id = request.cookies.get('user_id')
    
    if not user_id:
        # Tạo tracking cookie
        user_id = str(uuid.uuid4())
    
    response = make_response("Hello!")
    response.set_cookie('user_id', user_id, max_age=365*24*60*60)
    
    # Track user behavior...
    return response

"""
Cookie tracking:
- Third-party cookies
- Behavioral targeting
- Cross-site tracking

Bảo vệ:
- Private/Incognito mode
- Block third-party cookies
- Extensions: uBlock Origin, Privacy Badger
- Brave browser, Firefox với privacy settings
"""

Data Collection

Dữ liệu được thu thập:

Websites:
- IP address
- Location
- Device info
- Browser fingerprint
- Cookies
- Search history

Social Media:
- Posts, likes, comments
- Friend network
- Messages
- Location check-ins
- Face recognition (photos)

Mobile Apps:
- Contacts
- Photos
- Microphone
- Camera
- GPS location
- Usage time

⚠️ READ PRIVACY POLICY!
⚠️ CHECK APP PERMISSIONS!

GDPR & Data Rights

Quyền của bạn (GDPR):

1. Right to Access:
   - Xem dữ liệu công ty lưu về bạn

2. Right to Rectification:
   - Sửa dữ liệu sai

3. Right to Erasure:
   - Xóa dữ liệu ("Right to be forgotten")

4. Right to Data Portability:
   - Download dữ liệu của bạn

5. Right to Object:
   - Từ chối xử lý dữ liệu

Trong thực tế:
- Google Takeout: Download tất cả dữ liệu
- Facebook: Download your information
- Delete account: Xóa hoàn toàn

Best Practices

Checklist An Toàn

✅ Password & Authentication:
□ Dùng password manager
□ Password unique cho mỗi tài khoản
□ Enable 2FA ở mọi nơi có thể
□ Không share password

✅ Software Updates:
□ Update OS thường xuyên
□ Update apps & browsers
□ Auto-update nếu có thể
□ Update firmware router

✅ Browsing:
□ Chỉ vào HTTPS websites
□ Kiểm tra URL kỹ
□ Không download từ nguồn lạ
□ Dùng adblocker

✅ Email:
□ Không click link lạ
□ Verify sender
□ Không mở attachment lạ
□ Report phishing

✅ Social Media:
□ Privacy settings: Friends only
□ Không share quá nhiều
□ Review tagged photos
□ Careful với quizzes/apps

✅ Mobile:
□ Lock screen (PIN/biometric)
□ Review app permissions
□ Tắt location khi không cần
□ Remote wipe nếu mất

Developer Security Checklist

# Security.txt trong Flask app

"""
✅ Input Validation:
- Validate tất cả user input
- Whitelist > Blacklist
- Type checking
- Length limits

✅ Output Encoding:
- Escape HTML
- JSON encode
- URL encode

✅ Authentication:
- Hash passwords (bcrypt, argon2)
- Session timeout
- Account lockout (brute force)
- Secure password reset

✅ Authorization:
- Check permissions mỗi request
- Principle of least privilege
- Role-based access control

✅ Database:
- Parameterized queries
- Principle of least privilege
- Encrypted sensitive data
- Regular backups

✅ APIs:
- Rate limiting
- API keys/tokens
- CORS configuration
- Input validation

✅ Logging:
- Log security events
- Don't log sensitive data
- Monitor logs
- Incident response plan

✅ Dependencies:
- Keep libraries updated
- Use npm audit, pip-audit
- Snyk, Dependabot
- Remove unused dependencies

✅ HTTPS:
- Force HTTPS
- HSTS header
- Valid SSL certificate
- TLS 1.3

✅ Headers:
- Content-Security-Policy
- X-Frame-Options
- X-Content-Type-Options
- Referrer-Policy
"""

# Flask security headers
from flask import Flask
from flask_talisman import Talisman

app = Flask(__name__)
Talisman(app, force_https=True)

@app.after_request
def add_security_headers(response):
    response.headers['X-Content-Type-Options'] = 'nosniff'
    response.headers['X-Frame-Options'] = 'SAMEORIGIN'
    response.headers['X-XSS-Protection'] = '1; mode=block'
    return response

Tools & Resources

Security Tools

Scanning & Testing:
- OWASP ZAP: Web app security scanner
- Burp Suite: Penetration testing
- Nmap: Network scanner
- Wireshark: Network analyzer

Password:
- Have I Been Pwned: Check leaked passwords
- Password strength checker
- KeePass, Bitwarden

Encryption:
- VeraCrypt: Disk encryption
- GnuPG: Email encryption
- Signal: Encrypted messaging

Learning:
- OWASP Top 10
- HackTheBox: Practice hacking
- TryHackMe: Security challenges
- CTF competitions

Learning Resources

Websites:
- https://owasp.org (OWASP Top 10)
- https://portswigger.net/web-security (Web Security Academy)
- https://www.cybrary.it (Free courses)

YouTube Channels:
- NetworkChuck
- John Hammond
- LiveOverflow
- HackerSploit

Certifications:
- CompTIA Security+
- CEH (Certified Ethical Hacker)
- CISSP
- OSCP

Kết Luận

Cybersecurity là trách nhiệm của mọi người:

• ✅ Bảo vệ bản thân online
• ✅ Password mạnh + 2FA
• ✅ Nhận biết phishing
• ✅ HTTPS everywhere
• ✅ Update thường xuyên
• ✅ Think before you click!

# Cybersecurity mindset
def stay_safe_online():
    """Luôn cẩn thận!"""
    while True:
        think_before_click()
        verify_sender()
        check_url()
        use_strong_password()
        enable_2fa()
        keep_updated()
        
    print("Stay safe online! 🔒")

# Security is not a product, but a process!
# An toàn thông tin không phải một lần, mà mọi lúc!

---

Bạn đã enable 2FA cho các tài khoản chưa? Hãy làm ngay hôm nay! 🔐

Tags

#Cybersecurity #Security #Privacy #WebSecurity #2FA #TinHoc12