วิธีการรักษาความปลอดภัยรหัสผ่านฐานข้อมูลใน PHP?

เมื่อแอปพลิเคชั่น PHP ทำการเชื่อมต่อฐานข้อมูลแน่นอนว่าโดยทั่วไปจะต้องผ่านการเข้าสู่ระบบและรหัสผ่าน หากฉันใช้การเข้าสู่ระบบที่ได้รับอนุญาตขั้นต่ำเพียงครั้งเดียวสำหรับแอปพลิเคชันของฉัน PHP จำเป็นต้องรู้ว่าการเข้าสู่ระบบและรหัสผ่านนั้นอยู่ที่ไหนสักแห่ง วิธีที่ดีที่สุดในการรักษาความปลอดภัยรหัสผ่านนั้นคืออะไร? ดูเหมือนว่าเพียงแค่เขียนในโค้ด PHP นั้นไม่ใช่ความคิดที่ดี

หลายคนเข้าใจผิดว่าเป็นคำถามเกี่ยวกับวิธีการจัดเก็บรหัสผ่านในฐานข้อมูล ว่าเป็นสิ่งที่ผิด. มันเกี่ยวกับวิธีการจัดเก็บรหัสผ่านที่ช่วยให้คุณไปยังฐานข้อมูล

วิธีแก้ไขปัญหาปกติคือย้ายรหัสผ่านออกจากซอร์สโค้ดไปยังไฟล์กำหนดค่า จากนั้นปล่อยให้การดูแลระบบและการรักษาความปลอดภัยไฟล์การกำหนดค่านั้นขึ้นอยู่กับผู้ดูแลระบบของคุณ ด้วยวิธีนี้นักพัฒนาไม่จำเป็นต้องรู้อะไรเกี่ยวกับรหัสผ่านการใช้งานจริงและไม่มีการบันทึกรหัสผ่านในการควบคุมแหล่งที่มาของคุณ

หากคุณกำลังโฮสต์บนเซิร์ฟเวอร์ของบุคคลอื่นและไม่สามารถเข้าถึงภายนอก webroot ของคุณคุณสามารถใส่รหัสผ่านและ / หรือการเชื่อมต่อฐานข้อมูลในไฟล์จากนั้นล็อคไฟล์โดยใช้. htaccess:

<files mypasswdfile>
order allow,deny
deny from all
</files>

วิธีที่ปลอดภัยที่สุดคือการไม่มีข้อมูลที่ระบุในโค้ด PHP ของคุณเลย

หากคุณใช้ Apache ซึ่งหมายถึงการตั้งค่ารายละเอียดการเชื่อมต่อในไฟล์ httpd.conf หรือไฟล์โฮสต์เสมือน ถ้าคุณทำเช่นนั้นคุณสามารถโทร mysql_connect () โดยไม่มีพารามิเตอร์ซึ่งหมายความว่า PHP จะไม่ส่งข้อมูลของคุณ

นี่คือวิธีที่คุณระบุค่าเหล่านี้ในไฟล์เหล่านั้น:

php_value mysql.default.user      myusername
php_value mysql.default.password  mypassword
php_value mysql.default.host      server

จากนั้นคุณเปิดการเชื่อมต่อ mysql ของคุณเช่นนี้:

<?php
$db = mysqli_connect();

หรือเช่นนี้

<?php
$db = mysqli_connect(ini_get("mysql.default.user"),
                     ini_get("mysql.default.password"),
                     ini_get("mysql.default.host"));

เก็บไว้ในไฟล์ภายนอกเว็บรูท

สำหรับระบบที่มีความปลอดภัยสูงเราจะเข้ารหัสรหัสผ่านฐานข้อมูลในไฟล์กำหนดค่า (ซึ่งผู้ดูแลระบบได้รับความปลอดภัยนั้นเอง) เมื่อเริ่มต้นแอปพลิเคชัน / เซิร์ฟเวอร์แอปพลิเคชันจะแจ้งผู้ดูแลระบบให้ขอคีย์ถอดรหัส รหัสผ่านฐานข้อมูลจะถูกอ่านจากไฟล์ปรับแต่งถอดรหัสและเก็บไว้ในหน่วยความจำสำหรับใช้ในอนาคต ยังไม่ปลอดภัย 100% เนื่องจากถูกเก็บไว้ในหน่วยความจำที่ถอดรหัส แต่คุณต้องเรียกมันว่า 'ปลอดภัยเพียงพอ' ในบางจุด!

วิธีนี้เป็นวิธีทั่วไปซึ่งมีประโยชน์สำหรับแอปพลิเคชันทั้งแบบเปิดและปิด

1. สร้างผู้ใช้ระบบปฏิบัติการสำหรับแอปพลิเคชันของคุณ ดูhttp://en.wikipedia.org/wiki/Principle_of_least_privilege
2. สร้างตัวแปรสภาพแวดล้อมระบบปฏิบัติการ (ไม่ใช่เซสชัน) สำหรับผู้ใช้นั้นด้วยรหัสผ่าน
3. เรียกใช้แอปพลิเคชันในฐานะผู้ใช้รายนั้น

ข้อดี:

1. คุณจะไม่ตรวจสอบรหัสผ่านของคุณในการควบคุมแหล่งที่มาโดยไม่ได้ตั้งใจเพราะคุณทำไม่ได้
2. คุณจะไม่พลาดการอนุญาตไฟล์โดยไม่ตั้งใจ คุณอาจจะได้ แต่มันจะไม่ส่งผลกระทบต่อเรื่องนี้
3. สามารถอ่านได้โดย root หรือผู้ใช้รายนั้นเท่านั้น รูทสามารถอ่านไฟล์และคีย์เข้ารหัสทั้งหมดของคุณได้
4. หากคุณใช้การเข้ารหัสคุณจะจัดเก็บคีย์อย่างปลอดภัยได้อย่างไร
5. ใช้งานได้กับแพลตฟอร์ม x
6. ต้องแน่ใจว่าไม่ส่ง envvar ไปยังกระบวนการลูกที่ไม่น่าเชื่อถือ

วิธีนี้แนะนำโดย Heroku ผู้ประสบความสำเร็จมาก

หากเป็นไปได้ที่จะสร้างการเชื่อมต่อฐานข้อมูลในไฟล์เดียวกันกับที่จัดเก็บข้อมูลรับรอง อินไลน์หนังสือรับรองในคำสั่งเชื่อมต่อ

mysql_connect("localhost", "me", "mypass");

มิฉะนั้นจะเป็นการดีที่สุดที่จะยกเลิกการตั้งค่าข้อมูลรับรองหลังจากคำสั่งเชื่อมต่อเนื่องจากข้อมูลรับรองที่ไม่ได้อยู่ในหน่วยความจำจึงไม่สามารถอ่านจากหน่วยความจำได้ )

include("/outside-webroot/db_settings.php");  
mysql_connect("localhost", $db_user, $db_pass);  
unset ($db_user, $db_pass);  

ตัวเลือกของคุณมี จำกัด ตามที่คุณบอกว่าคุณต้องการรหัสผ่านเพื่อเข้าถึงฐานข้อมูล วิธีการทั่วไปอย่างหนึ่งคือการจัดเก็บชื่อผู้ใช้และรหัสผ่านในไฟล์การกำหนดค่าแยกต่างหากแทนที่จะเป็นสคริปต์หลัก จากนั้นตรวจสอบให้แน่ใจว่าได้จัดเก็บที่อยู่นอกแผนผังเว็บหลัก นั่นคือหากมีปัญหาการกำหนดค่าเว็บที่ทำให้ไฟล์ php ของคุณถูกแสดงเป็นข้อความแทนที่จะถูกดำเนินการคุณไม่ได้เปิดเผยรหัสผ่าน

นอกเหนือจากที่คุณอยู่ในบรรทัดที่ถูกต้องด้วยการเข้าถึงน้อยที่สุดสำหรับบัญชีที่ใช้ เพิ่มไปที่

• อย่าใช้ชื่อผู้ใช้ / รหัสผ่านร่วมกันเพื่อสิ่งอื่นใด
• กำหนดค่าเซิร์ฟเวอร์ฐานข้อมูลเพื่อยอมรับการเชื่อมต่อจากเว็บโฮสต์สำหรับผู้ใช้นั้น (localhost ดียิ่งขึ้นถ้าฐานข้อมูลอยู่บนเครื่องเดียวกัน) วิธีนั้นแม้ว่าข้อมูลประจำตัวจะถูกเปิดเผยพวกเขาจะไม่ใช้กับใครนอกจากพวกเขาจะมีการเข้าถึง เครื่อง
• ทำให้รหัสผ่านสับสน (แม้ ROT13 จะทำ) มันจะไม่ป้องกันมากนักหากบางคนสามารถเข้าถึงไฟล์ได้ แต่อย่างน้อยมันก็จะป้องกันการดูแบบไม่เป็นทางการ

จางไป

หากคุณใช้ PostgreSQL ระบบจะค้นหา~/.pgpassรหัสผ่านโดยอัตโนมัติ ดูคู่มือสำหรับข้อมูลเพิ่มเติม

ก่อนหน้านี้เราจัดเก็บฐานข้อมูลผู้ใช้ / รหัสผ่านในไฟล์กำหนดค่า แต่มีตั้งแต่โหมดหวาดระแวงกด - ใช้นโยบายการป้องกันในความลึกป้องกันในเชิงลึก

หากแอปพลิเคชันของคุณถูกบุกรุกผู้ใช้จะสามารถอ่านไฟล์การกำหนดค่าของคุณได้ดังนั้นจึงมีโอกาสที่แครกเกอร์จะอ่านข้อมูลนี้ ไฟล์การกำหนดค่าสามารถรับการตรวจสอบในการควบคุมเวอร์ชันหรือคัดลอกรอบเซิร์ฟเวอร์

เราได้เปลี่ยนไปใช้การจัดเก็บตัวแปรผู้ใช้ / ส่งผ่านในสภาพแวดล้อมที่กำหนดไว้ใน Apache VirtualHost การกำหนดค่านี้สามารถอ่านได้โดยรูทเท่านั้นหวังว่าผู้ใช้ Apache ของคุณจะไม่ทำงานเหมือนรูท

ข้อเสียคือตอนนี้รหัสผ่านอยู่ในตัวแปร Global PHP

เพื่อลดความเสี่ยงนี้เรามีข้อควรระวังดังต่อไปนี้:

• รหัสผ่านถูกเข้ารหัส เราขยายคลาส PDO เพื่อรวมตรรกะสำหรับการถอดรหัสรหัสผ่าน หากมีคนอ่านรหัสที่เราสร้างการเชื่อมต่อจะไม่ชัดเจนว่าการเชื่อมต่อนั้นถูกสร้างขึ้นด้วยรหัสผ่านที่เข้ารหัสและไม่ใช่รหัสผ่านนั้นเอง
• รหัสผ่านที่เข้ารหัสถูกย้ายจากตัวแปรส่วนกลางไปเป็นตัวแปรส่วนตัวแอปพลิเคชันทำสิ่งนี้ทันทีเพื่อลดหน้าต่างที่มีค่าในพื้นที่ส่วนกลาง
• phpinfo()ถูกปิดใช้งาน. PHPInfo เป็นเป้าหมายที่ง่ายในการรับภาพรวมของทุกสิ่งรวมถึงตัวแปรสภาพแวดล้อม

ใส่รหัสผ่านฐานข้อมูลลงในไฟล์ทำให้เป็นแบบอ่านอย่างเดียวสำหรับผู้ใช้ที่ให้บริการไฟล์

ถ้าคุณไม่มีวิธีอนุญาตให้กระบวนการเซิร์ฟเวอร์ php เข้าถึงฐานข้อมูลได้เพียงนี้คุณก็สามารถทำได้

หากคุณกำลังพูดถึงรหัสผ่านฐานข้อมูลซึ่งต่างจากรหัสผ่านที่มาจากเบราว์เซอร์ดูเหมือนว่าวิธีปฏิบัติแบบมาตรฐานจะต้องใส่รหัสผ่านฐานข้อมูลลงในไฟล์กำหนดค่า PHP บนเซิร์ฟเวอร์

คุณเพียงแค่ต้องแน่ใจว่าไฟล์ php ที่มีรหัสผ่านนั้นมีสิทธิ์ที่เหมาะสม เช่นควรอ่านได้โดยเว็บเซิร์ฟเวอร์และบัญชีผู้ใช้ของคุณเท่านั้น

เพียงแค่วางมันลงในไฟล์กำหนดค่าบางแห่งเป็นวิธีที่มันมักจะทำ เพียงให้แน่ใจว่าคุณ:

1. ไม่อนุญาตให้เข้าถึงฐานข้อมูลจากเซิร์ฟเวอร์ใด ๆ ที่อยู่นอกเครือข่ายของคุณ
2. ระวังอย่าให้แสดงรหัสผ่านแก่ผู้ใช้โดยไม่ตั้งใจ (ในข้อความแสดงข้อผิดพลาดหรือผ่านไฟล์ PHP โดยไม่ตั้งใจซึ่งทำหน้าที่เป็น HTML และอื่น ๆ )

เราแก้ไขมันด้วยวิธีนี้:

1. ใช้ memcache บนเซิร์ฟเวอร์โดยเปิดการเชื่อมต่อจากเซิร์ฟเวอร์รหัสผ่านอื่น ๆ
2. บันทึกเพื่อ memcache รหัสผ่าน (หรือแม้แต่ไฟล์เข้ารหัส password.php ทั้งหมด) รวมทั้งปุ่มถอดรหัส
3. เว็บไซต์เรียกใช้คีย์ memcache ที่เก็บรหัสผ่านไฟล์รหัสผ่านและถอดรหัสในหน่วยความจำรหัสผ่านทั้งหมด
4. เซิร์ฟเวอร์รหัสผ่านจะส่งไฟล์รหัสผ่านที่เข้ารหัสใหม่ทุก ๆ 5 นาที
5. หากคุณใช้รหัสผ่านที่เข้ารหัสไว้. php ในโครงการของคุณคุณทำการตรวจสอบเพื่อตรวจสอบว่าไฟล์นี้ถูกสัมผัสจากภายนอก - หรือดูแล้ว เมื่อสิ่งนี้เกิดขึ้นคุณสามารถล้างหน่วยความจำโดยอัตโนมัติรวมถึงปิดเซิร์ฟเวอร์เพื่อการเข้าถึง

เคล็ดลับเพิ่มเติมคือการใช้ไฟล์กำหนดค่า PHP แยกต่างหากที่มีลักษณะดังนี้:

<?php exit() ?>

[...]

Plain text data including password

สิ่งนี้ไม่ได้ป้องกันคุณจากการตั้งค่ากฎการเข้าถึงอย่างถูกต้อง แต่ในกรณีที่เว็บไซต์ของคุณถูกแฮ็กคำว่า "ต้องการ" หรือ "รวม" จะออกจากสคริปต์ที่บรรทัดแรกดังนั้นจึงเป็นการยากที่จะได้รับข้อมูล

อย่างไรก็ตามอย่าปล่อยให้ไฟล์การกำหนดค่าในไดเรกทอรีที่สามารถเข้าถึงได้ผ่านเว็บ คุณควรมีโฟลเดอร์ "เว็บ" ที่มีรหัสตัวควบคุม, css, รูปภาพและ js ของคุณ นั่นคือทั้งหมดที่ มีอะไรอีกบ้างในโฟลเดอร์ออฟไลน์

วิธีที่ดีที่สุดคือไม่เก็บรหัสผ่านเลย!
ตัวอย่างเช่นหากคุณใช้ระบบ Windows และเชื่อมต่อกับ SQL Server คุณสามารถใช้ Integrated Authentication เพื่อเชื่อมต่อกับฐานข้อมูลโดยไม่ต้องใช้รหัสผ่านโดยใช้ข้อมูลประจำตัวของกระบวนการปัจจุบัน

หากคุณจำเป็นต้องเชื่อมต่อกับรหัสผ่านก่อนอื่นให้เข้ารหัสโดยใช้การเข้ารหัสที่รัดกุม (เช่นการใช้ AES-256 จากนั้นปกป้องคีย์การเข้ารหัสหรือใช้การเข้ารหัสแบบไม่สมมาตรและให้ระบบปฏิบัติการป้องกันใบรับรอง) จากนั้นเก็บไว้ใน ไฟล์การกำหนดค่า (นอกไดเรกทอรีเว็บ) ที่มีACL ที่คาดเดายาก