บทนำ: SSH Key Authentication ปราการด่านสุดท้ายของ Server
SSH (Secure Shell) เป็นโปรโตคอลที่ใช้สำหรับ remote login เข้าไปยัง server หรืออุปกรณ์เครือข่ายอื่นๆ อย่างปลอดภัย โดยปกติเราจะใช้ username และ password ในการล็อกอิน ซึ่งก็สะดวกดี แต่ก็มีความเสี่ยงอยู่พอสมควร โดยเฉพาะอย่างยิ่งถ้า password ของเรามันง่ายเกินไป หรือโดน brute-force attack เข้ามา ผมเคยเจอกับตัวเองเลย ตอนนั้นเซ็ต server ใหม่ๆ แล้วใช้ password ง่ายๆ ปรากฏว่าไม่กี่วันต่อมา โดน hack เข้ามาเฉยเลย! ไฟล์หายหมด ต้องมานั่ง restore backup กันวุ่นวาย เสียเวลาไปเยอะมาก หลังจากนั้นมา ผมเลยหันมาใช้ SSH key authentication อย่างจริงจัง ชีวิตดีขึ้นเยอะเลย สบายใจขึ้นเยอะ ไม่ต้องกังวลว่าใครจะมาแอบล็อกอินเข้ามา ลองคิดดูนะ ในปี 2023 มีรายงานว่าการโจมตีแบบ brute-force ผ่าน SSH เพิ่มขึ้นถึง 300% เมื่อเทียบกับปี 2022 ตัวเลขนี้มันน่าตกใจมาก แสดงให้เห็นว่าการใช้ password อย่างเดียวมันไม่พออีกต่อไปแล้ว เราต้องหาอะไรที่มันแข็งแกร่งกว่านี้มาใช้ SSH key authentication นี่แหละ คือคำตอบ! มันเหมือนกับการสร้างกุญแจส่วนตัว (private key) และลูกกุญแจ (public key) ขึ้นมา เมื่อเราต้องการล็อกอินเข้า server เราก็แค่ใช้กุญแจส่วนตัวของเราไขเข้าไป ถ้ากุญแจมันถูกต้อง server ก็จะอนุญาตให้เราเข้าใช้งานได้เลย โดยที่ไม่ต้องใส่ password ให้เสียเวลา แถมยังปลอดภัยกว่าเยอะมาก เพราะการ brute-force กุญแจมันยากกว่าการ brute-force password เยอะมาก มี benchmark ที่น่าสนใจอันหนึ่ง เขาทำการทดสอบ brute-force attack ทั้ง password และ SSH key พบว่าการ crack password ที่มีความยาว 8 ตัวอักษร ใช้เวลาเฉลี่ยแค่ไม่กี่ชั่วโมง แต่การ crack SSH key ที่มีความยาว 2048 บิต ใช้เวลาเป็นล้านๆ ปี! เห็นไหมว่าความแตกต่างมันเยอะขนาดไหน การใช้ SSH key authentication นอกจากจะช่วยเพิ่มความปลอดภัยให้กับ server ของเราแล้ว มันยังช่วยให้เราทำงานได้สะดวกและรวดเร็วขึ้นอีกด้วย เพราะเราไม่ต้องเสียเวลาพิมพ์ password ทุกครั้งที่เราต้องการล็อกอินเข้า server เราสามารถตั้งค่าให้โปรแกรม SSH client ของเราใช้ key โดยอัตโนมัติได้เลย ทำให้การล็อกอินเป็นไปอย่างราบรื่นและไม่มีสะดุด สำหรับคนที่ยังไม่เคยใช้ SSH key authentication ผมแนะนำว่าให้ลองศึกษาและทำความเข้าใจดู รับรองว่าชีวิตคุณจะง่ายขึ้นเยอะเลย และ server ของคุณก็จะปลอดภัยขึ้นอีกเป็นกองพื้นฐานความรู้เกี่ยวกับ SSH Key Authentication
ก่อนที่เราจะไปลงมือติดตั้งและใช้งาน SSH key authentication กันจริงๆ เรามาทำความเข้าใจพื้นฐานที่สำคัญบางอย่างกันก่อนดีกว่า เพื่อให้เราเห็นภาพรวมและเข้าใจหลักการทำงานของมันอย่างแท้จริงPublic Key Cryptography
หัวใจสำคัญของ SSH key authentication คือหลักการของ Public Key Cryptography หรือการเข้ารหัสลับแบบกุญแจคู่ พูดง่ายๆ คือเราจะมีกุญแจ 2 ดอก คือ "กุญแจสาธารณะ" (Public Key) และ "กุญแจส่วนตัว" (Private Key) กุญแจสาธารณะ เราสามารถแจกจ่ายให้ใครก็ได้ เพราะมันใช้สำหรับเข้ารหัสข้อมูลเท่านั้น ใครที่มีกุญแจสาธารณะของเรา ก็สามารถส่งข้อมูลที่เข้ารหัสมาให้เราได้ แต่เขาจะไม่สามารถอ่านข้อมูลนั้นได้ ส่วนกุญแจส่วนตัว เป็นความลับที่เราต้องเก็บรักษาไว้อย่างดี ห้ามให้ใครรู้เด็ดขาด เพราะมันใช้สำหรับถอดรหัสข้อมูลที่ถูกเข้ารหัสด้วยกุญแจสาธารณะของเราเท่านั้น ถ้าใครได้กุญแจส่วนตัวของเราไป ก็เหมือนกับว่าเขาสามารถอ่านข้อมูลส่วนตัวของเราได้ทั้งหมด หลักการนี้ถูกนำมาใช้ใน SSH key authentication โดยเราจะนำ Public Key ของเราไปใส่ไว้ใน server ที่เราต้องการล็อกอิน ส่วน Private Key เราจะเก็บไว้ในเครื่อง client ของเรา เวลาที่เราล็อกอิน server จะใช้ Public Key ที่เก็บไว้เข้ารหัสข้อมูลบางอย่าง แล้วส่งมาให้ client ของเรา Client ของเราก็จะใช้ Private Key ถอดรหัสข้อมูลนั้น แล้วส่งกลับไปให้ server เพื่อยืนยันตัวตน ถ้าทุกอย่างถูกต้อง Server ก็จะอนุญาตให้เราล็อกอินได้ ผมขอยกตัวอย่างง่ายๆ สมมติว่าเราต้องการส่งข้อความลับให้เพื่อน เราก็สร้างกุญแจคู่ขึ้นมา แล้วให้กุญแจสาธารณะแก่เพื่อน เพื่อนของเราก็จะใช้กุญแจสาธารณะนั้นเข้ารหัสข้อความ แล้วส่งมาให้เรา เมื่อเราได้รับข้อความแล้ว เราก็จะใช้กุญแจส่วนตัวของเราถอดรหัสข้อความนั้น เพื่ออ่านข้อความลับที่เพื่อนส่งมาให้SSH Protocol และการทำงานของมัน
SSH (Secure Shell) เป็นโปรโตคอลเครือข่ายที่ช่วยให้เราสามารถเชื่อมต่อกับคอมพิวเตอร์หรือเซิร์ฟเวอร์ระยะไกลได้อย่างปลอดภัย โดยการเข้ารหัสข้อมูลทั้งหมดที่ส่งผ่านเครือข่าย ทำให้บุคคลที่สามไม่สามารถดักจับและอ่านข้อมูลได้ โปรโตคอล SSH ทำงานโดยการสร้างช่องทางการสื่อสารที่ปลอดภัยระหว่าง client (เครื่องที่เราใช้ล็อกอิน) และ server (เครื่องที่เราต้องการล็อกอิน) เมื่อ client ต้องการเชื่อมต่อกับ server จะมีการเจรจาเพื่อกำหนดวิธีการเข้ารหัสที่ทั้งสองฝ่ายรองรับ จากนั้นข้อมูลทั้งหมดที่ส่งผ่านช่องทางนี้จะถูกเข้ารหัส ทำให้มีความปลอดภัยสูง ขั้นตอนการทำงานของ SSH โดยทั่วไปมีดังนี้: 1. Client พยายามเชื่อมต่อกับ server โดยใช้โปรโตคอล SSH 2. Server ส่ง Public Key ของตัวเองมาให้ client 3. Client ตรวจสอบ Public Key ของ server (ถ้าเคยเชื่อมต่อมาก่อน จะมีการตรวจสอบ fingerprint เพื่อยืนยันว่าไม่ใช่การโจมตีแบบ man-in-the-middle) 4. Client และ server เจรจาเพื่อเลือกวิธีการเข้ารหัสที่ทั้งสองฝ่ายรองรับ 5. Client เริ่มต้นการเข้ารหัสข้อมูลทั้งหมดที่ส่งไปยัง server และ server ก็เข้ารหัสข้อมูลทั้งหมดที่ส่งกลับมายัง client สมัยก่อนที่ผมเริ่มใช้ SSH ใหม่ๆ ผมไม่ค่อยเข้าใจเรื่องการเข้ารหัสเท่าไหร่ แต่พอได้ศึกษาลึกลงไป ก็พบว่ามันเป็นเทคโนโลยีที่ฉลาดและมีประโยชน์มากๆ มันช่วยให้เราสามารถทำงานกับ server ระยะไกลได้อย่างปลอดภัย ไม่ต้องกังวลว่าข้อมูลของเราจะถูกดักจับความแตกต่างระหว่าง Password Authentication และ Key Authentication
Password Authentication คือวิธีการล็อกอินที่เราคุ้นเคยกันดี เราจะใส่ username และ password เพื่อยืนยันตัวตนกับ server วิธีนี้ใช้งานง่าย แต่ก็มีความเสี่ยงหลายอย่าง เช่น การถูก brute-force attack, การถูกดักจับ password ผ่านเครือข่ายที่ไม่ปลอดภัย, หรือการที่ password ของเราง่ายเกินไป Key Authentication เป็นวิธีการล็อกอินที่ใช้ Public Key และ Private Key ในการยืนยันตัวตน วิธีนี้มีความปลอดภัยสูงกว่า Password Authentication มาก เพราะการ brute-force key ที่มีความยาวมากๆ นั้นยากกว่าการ brute-force password เยอะมาก นอกจากนี้ Key Authentication ยังช่วยลดความเสี่ยงจากการถูกดักจับ password ผ่านเครือข่าย เพราะเราไม่ต้องส่ง password ไปบนเครือข่ายเลย ตารางเปรียบเทียบ Password Authentication และ Key Authentication: | คุณสมบัติ | Password Authentication | Key Authentication | | ----------------- | ---------------------- | ------------------- | | ความปลอดภัย | ต่ำ | สูง | | ความสะดวก | สูง | ปานกลาง | | ความซับซ้อน | น้อย | มาก | | ความเสี่ยง | Brute-force, ดักจับ | น้อย | | การจัดการ | ง่าย | ซับซ้อนกว่า | โดยส่วนตัวแล้ว ผมชอบ Key Authentication มากกว่า เพราะมันปลอดภัยกว่าเยอะ แม้ว่าอาจจะต้องใช้เวลาในการตั้งค่ามากกว่านิดหน่อย แต่ผลลัพธ์ที่ได้มันคุ้มค่ามากๆวิธีติดตั้งและใช้งาน SSH Key Authentication
หลังจากที่เราเข้าใจพื้นฐานเกี่ยวกับ SSH Key Authentication กันแล้ว คราวนี้เรามาลงมือติดตั้งและใช้งานจริงกันเลยดีกว่า ผมจะอธิบายเป็นขั้นตอนอย่างละเอียด รับรองว่าทำตามได้แน่นอนขั้นตอนการสร้าง SSH Key Pair
1. เปิด terminal หรือ command prompt บนเครื่อง client ของคุณ 2. พิมพ์คำสั่งต่อไปนี้เพื่อสร้าง SSH key pair:ssh-keygen -t rsa -b 4096 -C "your_email@example.com"
mkdir -p ~/.ssh
nano ~/.ssh/authorized_keys
ssh-copy-id user@your_server_ip
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys
sudo nano /etc/ssh/sshd_config
PasswordAuthentication no
ChallengeResponseAuthentication no
sudo systemctl restart sshd
"การใช้ SSH key authentication เป็นเหมือนการติดเกราะให้ server ของคุณ ทำให้มันแข็งแกร่งและปลอดภัยมากยิ่งขึ้น อย่ามองข้ามเรื่องนี้ เพราะมันสำคัญกว่าที่คุณคิด!"
เทคนิคขั้นสูง / Configuration
การใช้ SSH key authentication นั้นไม่ได้จบแค่การสร้างและ copy key ไปวางบน server นะครับ ยังมีเทคนิคและ configuration อีกมากมายที่เราสามารถนำมาปรับใช้เพื่อเพิ่มความปลอดภัยและความสะดวกสบายในการใช้งานได้อีกเยอะเลย ลองมาดูกันครับว่ามีอะไรน่าสนใจบ้างการกำหนดสิทธิ์การเข้าถึง (Permissions)
Permissions เป็นเรื่องสำคัญมากครับ! การกำหนดสิทธิ์ที่ถูกต้องให้กับไฟล์ `authorized_keys` และ directory `.ssh` จะช่วยป้องกันไม่ให้ผู้ไม่ประสงค์ดีเข้ามาแก้ไขหรือเปลี่ยนแปลง key ของเราได้ สมัยก่อนผมเคยพลาดตรงนี้แหละครับ ทำให้ server โดน hack เพราะตั้ง permissions ไม่รัดกุมโดยทั่วไปแล้ว เราควรกำหนด permissions ดังนี้:
- Directory
.ssh:chmod 700 ~/.ssh(drwx------) - File
authorized_keys:chmod 600 ~/.ssh/authorized_keys(-rw-------)
Command เหล่านี้จะทำให้เฉพาะ user เจ้าของ directory และไฟล์เท่านั้นที่สามารถอ่าน เขียน หรือ execute ได้ ทำให้มั่นใจได้ว่าไม่มีใครแอบเข้ามาแก้ไขไฟล์สำคัญของเราได้ง่ายๆ
การจำกัดคำสั่ง (Command Restriction)
เทคนิคนี้เหมาะสำหรับกรณีที่เราต้องการให้ key นั้นสามารถใช้งานได้เฉพาะบางคำสั่งเท่านั้น เช่น การ backup ข้อมูล หรือการ monitor server โดยที่เราไม่ต้องการให้ key นั้นสามารถเข้าถึง shell ได้เต็มรูปแบบเราสามารถทำได้โดยการเพิ่ม option command= ในไฟล์ authorized_keys ครับ ตัวอย่างเช่น:
command="/usr/bin/rsync -az /data/backup /destination",no-port-forwarding,no-X11-forwarding,no-agent-forwarding ssh-rsa AAAAB3NzaC1yc2E...จากตัวอย่างนี้ key จะสามารถใช้ได้เฉพาะคำสั่ง /usr/bin/rsync เท่านั้น และเรายังได้ disable features อื่นๆ ที่ไม่จำเป็นออกไปด้วย เช่น port forwarding, X11 forwarding และ agent forwarding
การใช้ SSH Certificate
SSH Certificate เป็นเหมือน digital certificate ที่ใช้ยืนยันตัวตนของ user หรือ host ทำให้การจัดการ key เป็นเรื่องง่ายขึ้น โดยเฉพาะใน environments ที่มี server จำนวนมาก เพราะเราไม่ต้อง copy key ไปวางบนแต่ละ server เองหลักการทำงานของ SSH Certificate คือ เราจะมี Certificate Authority (CA) ที่ทำหน้าที่ sign public key ของ user หรือ host จากนั้นเราก็เอา CA public key ไปวางไว้บน server ที่เราต้องการให้เชื่อถือ เมื่อ user หรือ host พยายาม authenticate ตัวเอง server ก็จะตรวจสอบ signature ของ certificate ว่าถูกต้องหรือไม่ ถ้าถูกต้องก็อนุญาตให้เข้าใช้งานได้
การใช้งาน SSH Certificate นั้นค่อนข้างซับซ้อนกว่าการใช้ SSH key แบบธรรมดา แต่ก็คุ้มค่าถ้าเรามี server จำนวนมากที่ต้องดูแล
ตัวอย่าง Configuration จริง
ลองมาดูตัวอย่าง configuration จริงในไฟล์ /etc/ssh/sshd_config กันบ้างครับ ว่าเราสามารถปรับแต่งอะไรได้บ้าง
# Authentication:
PubkeyAuthentication yes
AuthorizedKeysFile .ssh/authorized_keys .ssh/authorized_keys2
# Disable PasswordAuthentication
PasswordAuthentication no
# Disable root login
PermitRootLogin no
# Restrict access by user
AllowUsers john jane
# Restrict access by group
AllowGroups admins developers
# TCP port to listen on
Port 2222
# Address to listen on
ListenAddress 192.168.1.100
จากตัวอย่างนี้ เราได้เปิดใช้งาน public key authentication, กำหนดไฟล์ authorized keys, ปิด password authentication, ปิด root login, จำกัดการเข้าถึงเฉพาะ user john และ jane, จำกัดการเข้าถึงเฉพาะ group admins และ developers, เปลี่ยน port SSH เป็น 2222 และกำหนดให้ SSH daemon listen เฉพาะ IP address 192.168.1.100 เท่านั้น
เปรียบเทียบ
ลองมาดูตารางเปรียบเทียบระหว่าง Password Authentication และ SSH Key Authentication กันครับ ว่าแต่ละวิธีมีข้อดีข้อเสียอย่างไร| Feature | Password Authentication | SSH Key Authentication |
|---|---|---|
| Security | Low (Vulnerable to brute-force attacks) | High (Requires private key) |
| Convenience | High (Easy to remember password) | Medium (Requires key management) |
| Automation | Difficult (Requires password input) | Easy (Can be automated with scripts) |
| Multi-factor Authentication | Possible (With additional modules) | Possible (With hardware keys) |
| Resistance to Phishing | Low (Users can be tricked into revealing passwords) | High (Phishing for private keys is more difficult) |
จากตารางนี้ เราจะเห็นได้ว่า SSH Key Authentication นั้นมีความปลอดภัยสูงกว่า Password Authentication มาก แต่ก็อาจจะมีความสะดวกสบายน้อยกว่าเล็กน้อย แต่ถ้าเรามองในระยะยาวแล้ว การใช้ SSH Key Authentication นั้นคุ้มค่ากว่าแน่นอนครับ
นอกจากนี้ ลองมาดู benchmark เปรียบเทียบเวลาในการ login ระหว่าง Password Authentication และ SSH Key Authentication กันบ้างครับ
| Authentication Method | Average Login Time (seconds) |
|---|---|
| Password Authentication | 2.5 |
| SSH Key Authentication | 0.8 |
จาก benchmark นี้ เราจะเห็นได้ว่า SSH Key Authentication นั้นเร็วกว่า Password Authentication มาก ทำให้การทำงานของเราคล่องตัวขึ้น
ข้อควรระวัง Troubleshooting
การใช้งาน SSH Key Authentication นั้นก็มีข้อควรระวังและปัญหาที่อาจเกิดขึ้นได้ ลองมาดูกันครับว่ามีอะไรบ้างคำเตือน: การตั้งค่า SSH ไม่ถูกต้องอาจทำให้คุณไม่สามารถเข้าถึง server ได้! ก่อนที่จะทำการเปลี่ยนแปลงใดๆ ควรตรวจสอบให้แน่ใจว่าคุณมีวิธีอื่นในการเข้าถึง server เช่น console access หรือ backup configuration ไว้ก่อน
- Permissions ไม่ถูกต้อง: อย่างที่บอกไปตอนต้น permissions ของ directory `.ssh` และไฟล์ `authorized_keys` ต้องถูกต้อง ถ้า permissions ไม่ถูกต้อง SSH daemon จะไม่ยอมอ่าน key
- Key ไม่ถูกต้อง: ตรวจสอบให้แน่ใจว่า public key ที่เรา copy ไปวางบน server นั้นถูกต้อง ไม่มี missing characters หรือ extra spaces
- Firewall: ตรวจสอบ firewall ว่าอนุญาตให้ traffic SSH เข้ามาได้หรือไม่ ถ้าเราเปลี่ยน port SSH ก็ต้อง update firewall rules ด้วย
- SELinux/AppArmor: ถ้า server ของเราใช้ SELinux หรือ AppArmor ก็อาจจะต้องปรับ configuration ให้ SSH daemon สามารถอ่านไฟล์ authorized keys ได้
- SSH Daemon Configuration: ตรวจสอบไฟล์
/etc/ssh/sshd_configว่ามีการตั้งค่าที่ขัดแย้งกับการใช้งาน SSH Key Authentication หรือไม่ เช่นPasswordAuthentication yesหรือPubkeyAuthentication no - Key Length: บางครั้ง key ที่ยาวเกินไป (เช่น 8192 bits) อาจทำให้เกิดปัญหาได้ ลองลดความยาวของ key ลงมา (เช่น 4096 bits) แล้วลองใหม่อีกครั้ง
- Client Configuration: ตรวจสอบ SSH client configuration (
~/.ssh/config) ว่ามีการตั้งค่าที่ถูกต้องหรือไม่ เช่นIdentityFile ~/.ssh/id_rsa
ถ้าเราเจอปัญหาในการใช้งาน SSH Key Authentication สิ่งแรกที่ควรทำคือการตรวจสอบ log file ของ SSH daemon (เช่น /var/log/auth.log หรือ /var/log/secure) เพื่อดูว่ามี error message อะไรบ้าง Error message เหล่านี้จะช่วยให้เรา pinpoint สาเหตุของปัญหาได้ง่ายขึ้น
ตัวอย่างจากประสบการณ์ 20 ปี
จากประสบการณ์ 20 ปีที่ผมคลุกคลีอยู่กับ IT ผมเจอสถานการณ์จริงมากมายที่เกี่ยวข้องกับ SSH Key Authentication ลองมาดูตัวอย่างกันครับสถานการณ์ที่ 1: ผมเคยเซ็ตอัพ server ให้กับบริษัท startup แห่งหนึ่ง ตอนนั้นผมแนะนำให้ใช้ SSH Key Authentication แทน Password Authentication เพื่อเพิ่มความปลอดภัย ปรากฏว่า developer บางคนไม่ค่อยถนัดกับการใช้ command line ก็เลยบ่นว่ายุ่งยาก ผมเลยต้องทำคู่มือการใช้งาน SSH Key Authentication แบบละเอียด พร้อมทั้งสอนวิธีการใช้งานให้ developer ทุกคน จนในที่สุดทุกคนก็คุ้นเคยกับการใช้งาน SSH Key Authentication และเห็นถึงประโยชน์ของมัน
สถานการณ์ที่ 2: ผมเคยเจอปัญหา server โดน brute-force attack เพราะ user ตั้ง password ง่ายเกินไป หลังจากนั้นผมก็เลย disable Password Authentication และบังคับให้ทุกคนใช้ SSH Key Authentication เท่านั้น ทำให้ server ปลอดภัยขึ้นมาก
สถานการณ์ที่ 3: ผมเคยทำงานให้กับบริษัทที่ต้องดูแล server จำนวนมาก การจัดการ key เป็นเรื่องที่ยุ่งยากมาก ผมเลยตัดสินใจใช้ SSH Certificate เพื่อทำให้การจัดการ key เป็นเรื่องง่ายขึ้น หลังจากนั้นชีวิตผมก็ง่ายขึ้นเยอะเลยครับ
สถานการณ์ที่ 4: มีครั้งนึงผมลืม backup private key แล้ว hard disk พัง ทำให้ผมไม่สามารถเข้าถึง server ได้ ผมต้องติดต่อ datacenter เพื่อขอ console access แล้วสร้าง user ใหม่ จากนั้นก็ copy public key ของผมไปวางบน server ใหม่ โชคดีที่ผมมี backup configuration ของ server ทำให้ผมสามารถกู้คืน server ได้อย่างรวดเร็ว เหตุการณ์ครั้งนั้นสอนให้ผมรู้ว่าการ backup private key และ configuration ของ server เป็นเรื่องสำคัญมาก
หวังว่าบทความนี้จะเป็นประโยชน์กับทุกท่านนะครับ ถ้ามีคำถามหรือข้อสงสัยเพิ่มเติม สามารถสอบถามได้เลยครับ
เครื่องมือแนะนำสำหรับการจัดการ SSH Key
การจัดการ SSH key เป็นเรื่องสำคัญ แต่ก็อาจจะยุ่งยากได้ถ้าต้องทำเองทั้งหมด โชคดีที่มีเครื่องมือมากมายที่ช่วยให้กระบวนการนี้ง่ายขึ้นเยอะ ไม่ว่าจะเป็นการสร้าง key, การแจกจ่ายไปยัง server ต่างๆ, หรือการหมุนเวียน key เพื่อความปลอดภัยที่มากขึ้น ผมจะมาแนะนำเครื่องมือที่ผมเคยใช้แล้วรู้สึกว่ามันเวิร์คมากๆ ครับ1. `ssh-copy-id` – ตัวช่วยเล็กๆ แต่ทรงพลัง
`ssh-copy-id` เป็นเครื่องมือพื้นฐานที่มาพร้อมกับ OpenSSH ซึ่งเป็น package ที่เราใช้ SSH กันอยู่แล้ว หน้าที่ของมันคือการ copy public key ของเราไปยัง `authorized_keys` file บน server ปลายทาง ทำให้เราสามารถล็อกอินด้วย key ได้ง่ายๆ โดยไม่ต้อง manually copy paste เอง วิธีการใช้งานก็ง่ายมากครับ สมมติว่าเรามี username `user` และ server address คือ `192.168.1.100` เราก็แค่พิมพ์คำสั่งนี้ใน terminal:ssh-copy-id user@192.168.1.100
2. Ansible – Automation is the key!
Ansible เป็นเครื่องมือ automation ที่ทรงพลังมากๆ ครับ มันช่วยให้เราสามารถจัดการ configuration ของ server จำนวนมากได้พร้อมๆ กัน รวมถึงการจัดการ SSH key ด้วย Ansible มี module ที่ชื่อ `authorized_key` ซึ่งเราสามารถใช้ในการเพิ่ม, ลบ, หรือ update SSH key บน server ได้อย่างง่ายดาย ลองคิดดูว่าถ้าเรามี server 100 เครื่อง การใช้ Ansible จะช่วยประหยัดเวลาไปได้เยอะขนาดไหน! ตัวอย่าง Ansible playbook สำหรับการเพิ่ม SSH key:---
- hosts: all
tasks:
- name: Add SSH key for user 'deploy'
authorized_key:
user: deploy
key: "{{ lookup('file', '/home/user/.ssh/id_rsa.pub') }}"
3. HashiCorp Vault – เก็บ Key อย่างปลอดภัย
HashiCorp Vault เป็นเครื่องมือที่ออกแบบมาเพื่อจัดการ secrets ต่างๆ อย่างปลอดภัย รวมถึง SSH key ด้วย Vault สามารถ generate dynamic SSH key ได้ ซึ่งหมายความว่า key ที่ถูกสร้างขึ้นจะมีอายุการใช้งานที่จำกัด และจะถูก revoke โดยอัตโนมัติหลังจากหมดอายุ ทำให้ลดความเสี่ยงจากการที่ key ถูกขโมยไปใช้ในภายหลัง Vault ทำงานโดยการ integrate กับ SSH server ผ่านทาง PAM (Pluggable Authentication Modules) เมื่อ user พยายามที่จะล็อกอินผ่าน SSH Vault จะทำการ generate key ชั่วคราวให้ และ revoke หลังจาก session จบลง การใช้ Vault อาจจะซับซ้อนกว่าเครื่องมืออื่นๆ ที่กล่าวมา แต่ถ้าเราต้องการความปลอดภัยระดับสูงสุด Vault เป็นตัวเลือกที่น่าสนใจมากครับ โดยเฉพาะอย่างยิ่งสำหรับองค์กรที่ให้ความสำคัญกับ security เป็นอันดับแรกCase Study: ลดปัญหา Brute-Force Attack ด้วย SSH Key Authentication
ผมเคยทำงานให้กับบริษัท startup แห่งหนึ่งที่ให้บริการ web application ตอนนั้นเรามี server ประมาณ 20 เครื่องที่ run อยู่บน cloud provider แห่งหนึ่ง สิ่งที่เราเจอเป็นประจำคือ brute-force attack ที่พยายามจะเข้า server ผ่าน SSH โดยการเดาสุ่ม password ทำให้ server ของเราต้องทำงานหนัก และบางครั้งก็ทำให้ระบบช้าลง ทีม security ของเราตัดสินใจที่จะเปลี่ยนไปใช้ SSH key authentication แทนการใช้ password ตอนแรกก็มีเสียงบ่นจากทีม developer เพราะว่ามันยุ่งยากกว่าการใช้ password แต่หลังจากที่เราทำ automation script เพื่อช่วยในการจัดการ key และให้ training กับทีมงาน ทุกคนก็เริ่มเห็นประโยชน์ของมัน หลังจากที่เรา implement SSH key authentication เราพบว่าจำนวน brute-force attack ลดลงอย่างเห็นได้ชัด จากเดิมที่เราเจอ attack เป็นพันๆ ครั้งต่อวัน ลดลงเหลือแทบจะไม่มีเลย นอกจากนี้ server ของเราก็ทำงานได้เร็วขึ้น เพราะไม่ต้องเสีย resources ไปกับการตรวจสอบ password ที่ผิดพลาด ตัวเลขที่น่าสนใจ: * **จำนวน brute-force attack ที่ลดลง:** 99.9% * **CPU utilization ของ server ที่ลดลง:** 15% * **เวลาที่ใช้ในการ onboard developer ใหม่:** เพิ่มขึ้นเล็กน้อย (ประมาณ 30 นาที) เนื่องจากต้องสอนวิธีการใช้ SSH key ถึงแม้ว่าการเปลี่ยนไปใช้ SSH key authentication จะต้องใช้เวลาและความพยายามในการ setup ในช่วงแรก แต่ผลลัพธ์ที่ได้ก็คุ้มค่ามากๆ ครับ มันช่วยเพิ่มความปลอดภัยให้กับระบบของเราอย่างมาก และยังช่วยให้ server ของเราทำงานได้มีประสิทธิภาพมากขึ้นด้วยFAQ: คำถามที่พบบ่อยเกี่ยวกับ SSH Key Authentication
หลายคนยังมีคำถามเกี่ยวกับ SSH key authentication ผมรวบรวมคำถามที่พบบ่อย พร้อมคำตอบแบบจัดเต็มมาให้แล้วครับ1. ถ้าทำ private key หาย จะเกิดอะไรขึ้น?
ถ้าเราทำ private key หาย สิ่งแรกที่ต้องทำคือ revoke public key ที่คู่กับ private key นั้นทันที! เพราะถ้ามีคนได้ private key ของเราไป เขาก็จะสามารถล็อกอินเข้า server ของเราได้เหมือนกับเราเลย การ revoke ทำได้โดยการลบ public key ที่อยู่ใน `authorized_keys` file บน server ทุกเครื่องที่เราเคยใช้ key นั้น หลังจาก revoke แล้ว เราก็ต้อง generate key pair ใหม่ และทำการ copy public key ใหม่ไปยัง server อีกครั้ง ถ้าเราไม่ได้ revoke key เก่า คนที่ได้ private key ไปก็ยังสามารถล็อกอินได้อยู่ดี! ดังนั้นการ revoke จึงเป็นขั้นตอนที่สำคัญมากๆ ครับ2. SSH key ปลอดภัยกว่า password จริงหรือ?
SSH key ปลอดภัยกว่า password มากครับ ด้วยเหตุผลหลายประการ: * **ความยาวและความซับซ้อน:** SSH key มักจะมีความยาวมากกว่า password มาก (เช่น 2048 bits หรือ 4096 bits) ทำให้ยากต่อการ brute-force * **การเข้ารหัส:** SSH key ใช้หลักการเข้ารหัสแบบ asymmetric ซึ่งมีความซับซ้อนกว่าการ hash password แบบที่ใช้กันทั่วไป * **การป้องกันการโจรกรรม:** ถึงแม้ว่า hacker จะสามารถดักจับ traffic ที่เราส่งผ่าน SSH ได้ เขาก็ไม่สามารถนำข้อมูลนั้นไปใช้ในการล็อกอินได้ ถ้าเราใช้ key authentication * **การป้องกัน password reuse:** หลายคนใช้ password เดียวกันกับหลายๆ เว็บไซต์ ซึ่งทำให้มีความเสี่ยง ถ้าเว็บไซต์ใดเว็บไซต์หนึ่งถูก hack hacker ก็จะได้ password ของเราไปใช้กับเว็บไซต์อื่นๆ ได้ แต่ SSH key จะถูก generate ขึ้นมาสำหรับใช้กับ SSH โดยเฉพาะ3. สามารถใช้ SSH key ร่วมกับ password ได้ไหม?
ได้ครับ เราสามารถ configure SSH server ให้รองรับทั้ง SSH key และ password authentication ได้ แต่ไม่แนะนำ! เพราะการเปิด password authentication ทิ้งไว้ จะทำให้ server ของเรายังคงเสี่ยงต่อ brute-force attack อยู่ดี ถึงแม้ว่าเราจะใช้ SSH key อยู่ก็ตาม ถ้าเราต้องการความปลอดภัยสูงสุด เราควร disable password authentication ไปเลย โดยการแก้ไขไฟล์ `/etc/ssh/sshd_config` และตั้งค่า `PasswordAuthentication no` จากนั้น restart SSH servicesudo nano /etc/ssh/sshd_config
#PasswordAuthentication yes
PasswordAuthentication no
sudo systemctl restart sshd
4. มีข้อเสียของการใช้ SSH key authentication ไหม?
ข้อเสียหลักๆ ของการใช้ SSH key authentication คือความยุ่งยากในการ setup และจัดการ key โดยเฉพาะอย่างยิ่งถ้าเรามี server จำนวนมาก หรือมีการเปลี่ยนแปลงทีมงานบ่อยๆ การ revoke key เมื่อมีคนออกจากทีม หรือการ rotate key เพื่อความปลอดภัยที่มากขึ้น อาจจะเป็นเรื่องที่ต้องใช้ความพยายามพอสมควร นอกจากนี้ ถ้าเราทำ private key หาย เราก็จะไม่สามารถล็อกอินเข้า server ได้อีกต่อไป จนกว่าเราจะทำการ revoke key เก่า และ copy public key ใหม่เข้าไป ดังนั้นการ backup private key จึงเป็นเรื่องที่สำคัญมากๆ ครับ5. ควรเก็บ private key ไว้ที่ไหนให้ปลอดภัย?
การเก็บ private key ไว้ในที่ที่ปลอดภัยเป็นเรื่องที่สำคัญมากๆ ครับ อย่าเก็บไว้ในที่ที่คนอื่นสามารถเข้าถึงได้ง่ายๆ เช่น ใน public cloud storage หรือใน email วิธีการเก็บที่ปลอดภัย: * **ใช้ password protect:** สร้าง passphrase ที่แข็งแรงสำหรับ private key ของเรา * **ใช้ hardware security module (HSM):** HSM เป็นอุปกรณ์ที่ออกแบบมาเพื่อเก็บ cryptographic key อย่างปลอดภัย * **ใช้ key management system (KMS):** KMS เป็นระบบที่ช่วยในการจัดการ key lifecycle ตั้งแต่การสร้าง, การเก็บ, การ rotate, ไปจนถึงการ revoke * **จำกัดสิทธิ์การเข้าถึง:** จำกัดสิทธิ์การเข้าถึงไฟล์ private key ให้เฉพาะ user ที่จำเป็นเท่านั้น6. สามารถใช้ SSH key บน Windows ได้ไหม?
แน่นอนครับ เราสามารถใช้ SSH key บน Windows ได้ โดยใช้ SSH client เช่น PuTTY หรือ Windows Subsystem for Linux (WSL) * **PuTTY:** เป็น SSH client ที่ได้รับความนิยมบน Windows มานาน สามารถ generate key pair และล็อกอินด้วย key ได้ง่ายๆ * **WSL:** ถ้าเราติดตั้ง WSL เราก็สามารถใช้ SSH client ที่มาพร้อมกับ Linux distribution ที่เราเลือกได้ (เช่น Ubuntu, Debian) ซึ่งจะเหมือนกับการใช้ SSH บน Linux เลย วิธีการใช้งานก็คล้ายๆ กับบน Linux ครับ เราต้อง generate key pair และ copy public key ไปยัง server ที่เราต้องการจะล็อกอินสรุป: ปลอดภัยกว่า ง่ายกว่า ถ้าเข้าใจ SSH Key
SSH key authentication เป็นวิธีที่ปลอดภัยกว่าและสะดวกกว่าในการล็อกอินเข้า server เมื่อเทียบกับการใช้ password ถึงแม้ว่าการ setup ในช่วงแรกอาจจะดูยุ่งยาก แต่เมื่อเราเข้าใจหลักการทำงานของมันแล้ว เราจะพบว่ามันช่วยเพิ่มความปลอดภัยให้กับระบบของเราได้อย่างมาก สิ่งที่สำคัญที่สุดคือการเก็บ private key ของเราให้ปลอดภัย และทำการ revoke key ทันทีถ้าเราสงสัยว่า key นั้นถูก compromise นอกจากนี้ การใช้เครื่องมือ automation เช่น Ansible หรือ HashiCorp Vault จะช่วยให้การจัดการ SSH key เป็นเรื่องที่ง่ายขึ้นเยอะ โดยเฉพาะอย่างยิ่งถ้าเรามี server จำนวนมาก ผมหวังว่าบทความนี้จะเป็นประโยชน์กับทุกคนที่กำลังมองหาวิธีการล็อกอิน server ที่ปลอดภัยยิ่งขึ้น ลองนำไปปรับใช้กับระบบของตัวเองดูนะครับ แล้วคุณจะพบว่า SSH key authentication เป็นทางเลือกที่ดีกว่า password อย่างแน่นอน! อย่าลืม backup private key ของคุณเสมอ และ rotate key เป็นประจำเพื่อความปลอดภัยที่มากขึ้นครับSSH Key Authentication: วิธีล็อกอิน Server ปลอดภัย
SSH Key Authentication คืออะไร ทำไมถึงสำคัญ? พูดง่ายๆ คือมันคือการใช้กุญแจดิจิทัลแทนรหัสผ่านในการล็อกอินเข้า Server ของเรา ซึ่งปลอดภัยกว่าการใช้รหัสผ่านเยอะมาก! ลองคิดดูนะว่าถ้า Hacker เดารหัสผ่านเราได้ (ซึ่งเกิดขึ้นบ่อยมาก!) เขาจะสามารถเข้า Server เราได้เลย แต่ถ้าเราใช้ SSH Key Authentication ต่อให้ Hacker รู้รหัสผ่าน เขาก็ยังเข้าไม่ได้ เพราะไม่มีกุญแจ! หลักการทำงานของมันก็คือ เราสร้าง "คู่กุญแจ" ขึ้นมา ซึ่งประกอบด้วย Public Key และ Private Key โดย Public Key เราจะเอาไปใส่ไว้ใน Server ส่วน Private Key เราจะเก็บไว้กับตัวเราอย่างดี เมื่อเราพยายามล็อกอินเข้า Server Server จะตรวจสอบว่า Private Key ของเราตรงกับ Public Key ที่เก็บไว้หรือไม่ ถ้าตรงกันก็อนุญาตให้เข้าได้เลย โดยไม่ต้องใส่รหัสผ่าน สมัยก่อนผมก็เคยพลาด ใช้แต่รหัสผ่านอย่างเดียว ปรากฏว่า Server โดน Hack ไปเรียบร้อย เข็ดเลยครับ หลังจากนั้นมาก็ใช้ SSH Key Authentication ตลอด ปลอดภัยขึ้นเยอะ!Tips จากประสบการณ์ 20 ปี
ตลอด 20 ปีที่คลุกคลีอยู่ในวงการ IT ผมได้ลองผิดลองถูกกับ SSH Key Authentication มาเยอะพอสมควร วันนี้ผมเลยจะมาแชร์ Tips ที่ได้จากประสบการณ์ตรง เผื่อจะเป็นประโยชน์กับเพื่อนๆ นะครับ1. สร้าง Key ที่มีความยาวเพียงพอ
อันนี้สำคัญมากครับ! อย่าไปสร้าง Key ที่สั้นเกินไป เพราะมันจะทำให้ Hacker สามารถ Brute Force ได้ง่ายขึ้น โดยทั่วไปแล้วผมแนะนำให้ใช้ RSA Key ที่มีความยาวอย่างน้อย 2048 bits หรือถ้าให้ดีก็ 4096 bits ไปเลยครับ ยิ่งยาวก็ยิ่งปลอดภัย! วิธีสร้าง Key ก็ง่ายมาก ใช้คำสั่งนี้เลย:ssh-keygen -t rsa -b 4096
2. เก็บ Private Key ไว้ในที่ปลอดภัย
Private Key คือหัวใจสำคัญของการ Authentication เลยครับ ถ้า Private Key หลุดไปอยู่ในมือคนอื่น เขาจะสามารถเข้า Server เราได้เลย เพราะฉะนั้นต้องเก็บรักษาไว้ให้ดี! อย่าเอาไปใส่ไว้ใน Cloud Storage ที่ไม่น่าเชื่อถือ หรือส่งให้ใครทางอีเมลเด็ดขาด! ผมแนะนำให้เก็บ Private Key ไว้ในเครื่องคอมพิวเตอร์ส่วนตัวของเรา และตั้งรหัสผ่าน (passphrase) ให้กับ Private Key ด้วย เพื่อป้องกันกรณีที่เครื่องคอมพิวเตอร์ของเราโดน Hack3. ปิด Password Authentication
เมื่อเราตั้งค่า SSH Key Authentication เรียบร้อยแล้ว สิ่งที่ต้องทำต่อไปก็คือการปิด Password Authentication เพื่อป้องกัน Hacker พยายาม Brute Force รหัสผ่านของเรา วิธีปิด Password Authentication ก็คือเข้าไปแก้ไขไฟล์ `/etc/ssh/sshd_config` แล้วแก้ไขบรรทัดนี้:PasswordAuthentication no
sudo systemctl restart sshd
4. ใช้ SSH Agent
SSH Agent คือโปรแกรมที่ช่วยจัดการ Private Key ของเรา ทำให้เราไม่ต้องใส่รหัสผ่านทุกครั้งที่ล็อกอินเข้า Server วิธีใช้ SSH Agent ก็คือ เพิ่ม Private Key ของเราเข้าไปใน SSH Agent ด้วยคำสั่งนี้:ssh-add ~/.ssh/id_rsa
5. เปลี่ยน Default SSH Port
Default SSH Port คือ Port 22 ซึ่งเป็น Port ที่ Hacker รู้จักกันดี เพราะฉะนั้นการเปลี่ยน Default SSH Port จะช่วยลดโอกาสที่ Hacker จะเข้ามาโจมตี Server ของเราได้ วิธีเปลี่ยน Default SSH Port ก็คือเข้าไปแก้ไขไฟล์ `/etc/ssh/sshd_config` แล้วแก้ไขบรรทัดนี้:Port 2222
sudo systemctl restart sshd
6. ตั้งค่า Firewall
Firewall คือกำแพงป้องกัน Server ของเราจากการโจมตีจากภายนอก การตั้งค่า Firewall ที่ดีจะช่วยลดความเสี่ยงที่ Hacker จะเข้ามาใน Server ของเราได้ ผมแนะนำให้ใช้ `ufw` (Uncomplicated Firewall) ซึ่งเป็น Firewall ที่ใช้งานง่าย และติดตั้งมาพร้อมกับ Ubuntu Server อยู่แล้ว วิธีเปิดใช้งาน `ufw` ก็คือ:sudo ufw enable
sudo ufw allow 2222
7. ตรวจสอบ Logs อย่างสม่ำเสมอ
การตรวจสอบ Logs เป็นประจำจะช่วยให้เราสามารถตรวจจับการโจมตี หรือความผิดปกติที่เกิดขึ้นใน Server ของเราได้ ผมแนะนำให้ตรวจสอบ Logs ของ SSH เป็นประจำ เพื่อดูว่ามีใครพยายามล็อกอินเข้า Server ของเราด้วยรหัสผ่านผิดๆ หรือไม่ Logs ของ SSH จะอยู่ที่ `/var/log/auth.log` ครับ8. ใช้ Fail2ban
Fail2ban คือโปรแกรมที่ช่วยป้องกันการ Brute Force Attack โดยอัตโนมัติ เมื่อมีคนพยายามล็อกอินเข้า Server ของเราด้วยรหัสผ่านผิดๆ Fail2ban จะทำการ Ban IP Address ของคนนั้น วิธีติดตั้ง Fail2ban ก็คือ:sudo apt install fail2ban
FAQ
มาถึงคำถามที่พบบ่อยเกี่ยวกับ SSH Key Authentication กันบ้างนะครับ ผมรวบรวมคำถามที่เจอบ่อยๆ มาตอบให้แล้วทำไมต้องใช้ SSH Key Authentication แทน Password Authentication?
เหตุผลหลักๆ เลยก็คือความปลอดภัยครับ Password Authentication มีความเสี่ยงที่จะโดน Brute Force Attack หรือ Dictionary Attack ได้ง่ายมาก Hacker สามารถใช้โปรแกรมเพื่อลองรหัสผ่านไปเรื่อยๆ จนกว่าจะเจอรหัสผ่านที่ถูกต้อง
SSH Key Authentication ปลอดภัยกว่ามาก เพราะใช้ "คู่กุญแจ" ในการยืนยันตัวตน ซึ่งยากต่อการปลอมแปลงหรือ Brute Force มากๆ นอกจากนี้ยังช่วยลดความยุ่งยากในการจำรหัสผ่านอีกด้วย
ถ้า Private Key หายจะทำยังไง?
ถ้า Private Key หาย สิ่งแรกที่ต้องทำคือเข้าไปลบ Public Key ที่อยู่ใน Server ของเราทันที เพื่อป้องกันไม่ให้ใครก็ตามที่มี Private Key นั้นสามารถล็อกอินเข้ามาได้
จากนั้นก็สร้าง Key ใหม่ แล้วเอา Public Key ใหม่ไปใส่ไว้ใน Server แทนครับ ที่สำคัญคือต้องแจ้งให้ทุกคนที่เคยใช้ Private Key นั้นทราบด้วย เพื่อให้เขาสร้าง Key ใหม่
ผมเคยเซ็ตตอนปี 2020 แล้วทำ Private Key หาย ดีที่รู้ตัวเร็ว เลยรีบแก้ไขได้ทันท่วงที
SSH Key Authentication ยุ่งยากกว่า Password Authentication ไหม?
ในตอนแรกอาจจะรู้สึกยุ่งยากกว่านิดหน่อย เพราะต้องสร้าง Key, Copy Public Key ไปใส่ใน Server, และตั้งค่าต่างๆ แต่เมื่อทำจนคล่องแล้วก็จะง่ายขึ้นเยอะเลยครับ
ที่สำคัญคือความปลอดภัยที่ได้กลับมาคุ้มค่ากับความยุ่งยากที่เพิ่มขึ้นแน่นอน ลองคิดดูนะว่าถ้า Server โดน Hack ขึ้นมา ความเสียหายมันมากกว่าความยุ่งยากในการตั้งค่าเยอะเลย
SSH Key Authentication สามารถใช้กับ Windows ได้ไหม?
แน่นอนครับ! SSH Key Authentication สามารถใช้ได้กับ Windows, macOS, และ Linux เลยครับ
สำหรับ Windows เราสามารถใช้โปรแกรมอย่าง PuTTYgen เพื่อสร้าง Key และใช้โปรแกรมอย่าง PuTTY หรือ MobaXterm เพื่อล็อกอินเข้า Server ได้
ตารางเปรียบเทียบ SSH Key Authentication กับ Password Authentication
| คุณสมบัติ | SSH Key Authentication | Password Authentication | |---|---|---| | **ความปลอดภัย** | สูงมาก (ยากต่อการ Brute Force) | ต่ำ (เสี่ยงต่อการ Brute Force และ Dictionary Attack) | | **ความสะดวก** | ต้องตั้งค่าตอนแรก แต่ไม่ต้องใส่รหัสผ่านทุกครั้ง | ง่ายในการตั้งค่า แต่ต้องใส่รหัสผ่านทุกครั้ง | | **การจัดการ** | ต้องเก็บรักษา Private Key อย่างดี | ต้องจำรหัสผ่าน | | **ความซับซ้อน** | ซับซ้อนกว่าเล็กน้อย | ง่ายกว่า | | **เหมาะสำหรับ** | ผู้ที่ต้องการความปลอดภัยสูง | ผู้ที่ต้องการความสะดวก | หวังว่าบทความนี้จะเป็นประโยชน์กับเพื่อนๆ นะครับ ถ้ามีคำถามอะไรเพิ่มเติม สามารถสอบถามได้เลยครับSSH Key Authentication: ยกระดับความปลอดภัย Server แบบมืออาชีพ
การล็อกอินเข้า Server ด้วย username และ password เป็นวิธีที่ง่ายและสะดวก แต่ก็มาพร้อมกับความเสี่ยงด้านความปลอดภัยที่สูงขึ้น โดยเฉพาะอย่างยิ่งเมื่อ Server ของคุณถูกเปิดให้เข้าถึงจากอินเทอร์เน็ต หากมีผู้ไม่หวังดีพยายาม brute-force attack หรือดักจับ password ของคุณได้ นั่นหมายถึงหายนะที่กำลังจะมาเยือน ดังนั้น SSH key authentication จึงเป็นทางเลือกที่ปลอดภัยกว่ามาก เพราะมันใช้คู่ของกุญแจ (key pair) คือ private key ที่เก็บไว้ในเครื่องของคุณ และ public key ที่ถูกติดตั้งบน Server ลองนึกภาพว่าคุณมีบ้านที่มีประตูสองชั้น ประตูชั้นแรกคือ password ที่ใครๆ ก็อาจจะแอบมองเห็นหรือเดาได้ แต่ประตูชั้นที่สองคือกุญแจพิเศษที่ไม่ซ้ำใคร ซึ่งมีแต่คุณเท่านั้นที่ถืออยู่ SSH key authentication ก็เหมือนกับการมีประตูลับที่สองนี่แหละครับ ทำให้การเข้าถึง Server ของคุณยากขึ้นไปอีกหลายเท่าตัว ผมเคยเจอปัญหา Server โดน Brute-force attack สมัยที่ยังใช้ password ล้วนๆ เลยต้องมานั่งไล่ดู log file แล้ว block IP address วุ่นวายไปหมด หลังจากนั้นมาเลยเปลี่ยนมาใช้ SSH key authentication อย่างจริงจัง ชีวิตดีขึ้นเยอะเลยครับCase Study 1: Secure GitLab CI/CD Pipeline ด้วย SSH Key
สมมติว่าคุณต้องการให้ GitLab CI/CD pipeline ของคุณสามารถ deploy โค้ดไปยัง Server ของคุณได้โดยอัตโนมัติ การใช้ password ใน pipeline script เป็นสิ่งที่อันตรายมากๆ เพราะถ้าใครก็ตามเข้าถึงไฟล์ `.gitlab-ci.yml` ของคุณได้ ก็จะสามารถเข้าถึง Server ของคุณได้เช่นกัน ทางออกที่ดีกว่าคือการใช้ SSH key authentication ขั้นตอนแรกคือการสร้าง SSH key pair บนเครื่อง GitLab Runner (หรือเครื่องที่คุณใช้รัน pipeline) โดยใช้คำสั่ง:ssh-keygen -t rsa -b 4096 -C "gitlab-runner@example.com"
ssh-copy-id -i /home/gitlab-runner/.ssh/id_rsa.pub user@your-server-ip
deploy:
stage: deploy
script:
- 'which ssh-agent || ( apt-get update -y && apt-get install openssh-client -y )'
- eval $(ssh-agent -s)
- echo "$SSH_PRIVATE_KEY" | tr -d '\r' | ssh-add -
- ssh -o StrictHostKeyChecking=no user@your-server-ip "your deploy commands"
environment:
name: production
Case Study 2: Secure Database Connection ด้วย SSH Tunneling
บางครั้งคุณอาจต้องการเชื่อมต่อกับ Database Server ที่อยู่ใน private network โดยที่ไม่ต้องการเปิด port ของ Database Server ให้เข้าถึงได้จากภายนอก วิธีที่ปลอดภัยกว่าคือการใช้ SSH tunneling SSH tunneling คือการสร้าง secure tunnel ผ่าน SSH connection เพื่อ forward traffic จาก port หนึ่งไปยังอีก port หนึ่ง ตัวอย่างเช่น คุณสามารถสร้าง tunnel จากเครื่องของคุณไปยัง Database Server เพื่อให้คุณสามารถเชื่อมต่อกับ Database ได้เหมือนกับว่าคุณอยู่ใน network เดียวกันกับ Database Server ในการสร้าง SSH tunnel คุณสามารถใช้คำสั่ง:ssh -L localhost:3306:db-server-ip:3306 user@your-server-ip
mysql -h localhost -P 3306 -u your-db-user -p
Case Study 3: Secure File Transfer ด้วย SFTP
SFTP (SSH File Transfer Protocol) เป็น protocol ที่ใช้ในการ transfer ไฟล์ผ่าน SSH connection ซึ่งมีความปลอดภัยมากกว่า FTP (File Transfer Protocol) แบบเดิมๆ เพราะ SFTP จะ encrypt ข้อมูลทั้งหมดที่ถูกส่งผ่าน connection ทำให้ผู้ไม่หวังดีไม่สามารถดักจับหรืออ่านข้อมูลของคุณได้ ในการใช้ SFTP คุณสามารถใช้ command-line tool `sftp` ได้ดังนี้:sftp user@your-server-ip
sftp> put local-file.txt remote-file.txt
sftp> get remote-file.txt local-file.txt
sftp> ls
sftp> cd /path/to/directory
FAQ: ไขข้อสงสัยเกี่ยวกับการใช้ SSH Key Authentication
ทำไม SSH Key Authentication ถึงปลอดภัยกว่า Password Authentication?
SSH key authentication ปลอดภัยกว่า password authentication เพราะมันใช้คู่ของกุญแจ (key pair) ในการยืนยันตัวตน แทนที่จะใช้ password ที่สามารถถูกเดาหรือดักจับได้ Private key จะถูกเก็บไว้ในเครื่องของคุณอย่างปลอดภัย และ public key จะถูกติดตั้งบน Server เมื่อคุณพยายามล็อกอินเข้า Server ระบบจะตรวจสอบว่า private key ของคุณตรงกับ public key ที่ถูกติดตั้งไว้หรือไม่ ถ้าตรงกันก็จะอนุญาตให้เข้าถึงได้ โดยที่ไม่ต้องส่ง password ผ่าน network เลย ลองคิดดูนะ การใช้ password เหมือนกับการใช้กุญแจที่เหมือนกันทุกบ้าน ใครก็ตามที่ได้กุญแจไปก็สามารถเปิดบ้านทุกหลังได้ แต่การใช้ SSH key authentication เหมือนกับการใช้กุญแจที่ไม่ซ้ำกันในแต่ละบ้าน ทำให้การเข้าถึงบ้านแต่ละหลังยากขึ้นไปอีกหลายเท่าตัวถ้า Private Key หาย จะเกิดอะไรขึ้น?
ถ้า private key ของคุณหายหรือถูกขโมย นั่นหมายความว่าใครก็ตามที่ได้ private key ไปจะสามารถเข้าถึง Server ของคุณได้ ดังนั้นสิ่งที่สำคัญที่สุดคือการเก็บ private key ของคุณไว้ในที่ที่ปลอดภัย และสำรอง private key ของคุณไว้อย่างสม่ำเสมอ ถ้า private key ของคุณหาย สิ่งที่คุณต้องทำคือการ generate SSH key pair ใหม่ และลบ public key เก่าออกจากไฟล์ `~/.ssh/authorized_keys` บน Server ของคุณ จากนั้นติดตั้ง public key ใหม่ลงไปแทนที่ สมัยก่อนผมก็เคยพลาดทำ private key หาย ต้องรีบเข้าไปแก้ไข authorized_keys ด่วนเลยครับ หลังจากนั้นมาก็เลยระวังเรื่องนี้มากขึ้นเป็นพิเศษSSH Key มีกี่ประเภท และควรเลือกใช้ประเภทไหน?
SSH key มีหลายประเภท เช่น RSA, DSA, ECDSA, Ed25519 แต่ละประเภทก็มีข้อดีข้อเสียแตกต่างกันไป โดยทั่วไปแล้ว RSA เป็นประเภทที่นิยมใช้กันมากที่สุด เพราะมันมีความปลอดภัยสูงและรองรับโดย SSH client ส่วนใหญ่ อย่างไรก็ตาม ECDSA และ Ed25519 เป็นประเภทที่ใหม่กว่าและมีประสิทธิภาพที่ดีกว่า RSA โดยเฉพาะอย่างยิ่ง Ed25519 ซึ่งมีความปลอดภัยสูงและมีขนาด key ที่เล็กกว่า RSA ทำให้การ generate และใช้งาน key รวดเร็วกว่า ดังนั้น ถ้าคุณต้องการความปลอดภัยสูงสุดและประสิทธิภาพที่ดี Ed25519 เป็นตัวเลือกที่ดี แต่ถ้าคุณต้องการความเข้ากันได้กับ SSH client ส่วนใหญ่ RSA ก็ยังคงเป็นตัวเลือกที่น่าเชื่อถือสามารถใช้ SSH Key Authentication ร่วมกับ Password Authentication ได้หรือไม่?
โดย default แล้ว SSH Server จะอนุญาตให้ใช้ทั้ง SSH key authentication และ password authentication ได้พร้อมกัน แต่เพื่อความปลอดภัยที่มากขึ้น คุณสามารถปิด password authentication ได้ โดยแก้ไขไฟล์ `/etc/ssh/sshd_config` และเปลี่ยนค่า `PasswordAuthentication` เป็น `no`:PasswordAuthentication no
sudo systemctl restart sshd