เราดูหลักการทำงานกับคุกกี้ใน PHP วัตถุประสงค์ของเซสชันเกือบจะเหมือนกัน - บันทึกข้อมูลบางส่วนหลังจากสคริปต์เสร็จสิ้นเพื่อใช้ในภายหลัง อย่างไรก็ตามทั้งสองวิธีนี้มีความแตกต่างกันอย่างมีนัยสำคัญ คุกกี้จะถูกจัดเก็บไว้ในฝั่งไคลเอ็นต์ ดังนั้นผู้ใช้สามารถอ่านและแก้ไขได้อย่างง่ายดาย สมมติว่ามีแบบฟอร์มการอนุญาตบนเว็บไซต์ของเรา เข้าสู่ระบบในฐานะผู้ดูแลระบบ บัญชีผู้ใช้จะได้รับสิทธิพิเศษเพิ่มเติมบนเว็บไซต์ เช่น การเข้าถึงแผงผู้ดูแลระบบ เพื่อป้องกันไม่ให้ผู้ใช้ต้องป้อนรหัสผ่านอีกครั้งหลังจากการเปลี่ยนแปลงแต่ละครั้ง จำเป็นต้องจำข้อเท็จจริงนั้นไว้ ผู้ใช้รายนี้ได้รับอนุญาตด้วย สิทธิ์ในการบริหาร- การใช้คุกกี้ ปัญหาได้รับการแก้ไขดังนี้: หลังจากการอนุญาตสำเร็จ คุกกี้บางตัวจะถูกตั้งค่าให้กับผู้ใช้ ผู้ดูแลระบบ=1- เมื่อท่องหน้าเว็บไซต์ เราจะตรวจสอบว่าผู้ใช้มีคุกกี้นี้หรือไม่ หากใช่ แสดงว่าผู้ใช้นั้นเป็นผู้ดูแลระบบ จากมุมมองด้านความปลอดภัย วิธีแก้ปัญหาดังกล่าวถือว่าผิดโดยพื้นฐาน เนื่องจากผู้เยี่ยมชมสามารถเพิ่มคุกกี้ลงในเบราว์เซอร์ของเขาได้อย่างอิสระ ผู้ดูแลระบบ=1และเป็นผู้ดูแลไซต์ของคุณโดยอัตโนมัติ การใช้เซสชัน ตัวเลขดังกล่าวจะไม่ทำงาน เนื่องจากพารามิเตอร์เซสชันถูกเก็บไว้ที่ฝั่งเว็บเซิร์ฟเวอร์
มาดูกันว่าเซสชันทำงานอย่างไรใน PHP หากต้องการเริ่มต้นใหม่หรือดำเนินการสร้างต่อก่อนหน้านี้ คุณต้องเรียกใช้ฟังก์ชัน PHP เซสชั่น_เริ่มต้น(). ฟังก์ชั่นนี้จะต้องถูกเรียกก่อนที่จะแสดงเนื้อหาในโค้ด พารามิเตอร์เซสชันอยู่ในนั้น อาร์เรย์ระดับโลก $_เซสชั่น- ลองดูตัวอย่าง:
session_start(); ถ้า ( ! isset ($_SESSION [ "ทดสอบ" ] ) ) ( echo" “เรารักษาความหมาย...
- $_SESSION [ "test" ] = "สวัสดีชาวโลก" ; เซสชั่น_เริ่มต้น()) echo $_SESSION [ "ทดสอบ" ] ; เซสชั่น_เริ่มต้น()เมื่อสคริปต์ถูกเรียกใช้งานเป็นครั้งแรก เซสชันใหม่จะถูกสร้างขึ้นโดยใช้ฟังก์ชัน
- จะเป็นไปตามเงื่อนไข เนื่องจากไม่มีการทดสอบตัวแปรเซสชัน และระบบจะสร้างตัวแปรเซสชันนี้ ในการดำเนินการครั้งต่อๆ ไป ฟังก์ชัน จะกลับมาดำเนินการเซสชันที่สร้างไว้ก่อนหน้านี้ต่อ เงื่อนไขจะไม่ได้รับการตอบสนอง แต่จะแสดงเฉพาะค่าของตัวแปรทดสอบเท่านั้น- ในการพิจารณาว่าเซสชันใดเป็นของลูกค้ารายใด เมื่อสร้างเซสชัน จะมีการตั้งค่าคุกกี้ประเภทต่อไปนี้ให้กับไคลเอ็นต์:
PHPSSID=
นี่คือสิ่งที่เรียกว่า รหัสเซสชัน- นอกจากนี้ยังมีวิธีการส่งรหัสเซสชันในพารามิเตอร์ GET แต่ วิธีนี้ฉันคิดว่ามันล้าสมัยเกินไป ชื่อพารามิเตอร์สามารถเปลี่ยนแปลงได้ในการกำหนดค่า ไฟล์ PHP php.ini:
Session.name = PHPSESSID
ตามค่าเริ่มต้น เซสชันจะถูกทำลายเมื่อไคลเอนต์ปิดเบราว์เซอร์ แต่คุณยังสามารถตั้งค่าอายุการใช้งานเซสชันเฉพาะใน php.ini ได้ (เวลาระบุเป็นวินาที):
เซสชัน.cookie_lifetime = 0
ในสคริปต์ เซสชันสามารถถูกบังคับให้ทำลายได้โดยใช้ฟังก์ชัน เซสชั่น_ทำลาย().
และสุดท้าย เรามาดูอีกตัวอย่างหนึ่งกัน สคริปต์ขนาดเล็กที่จำลองการอนุญาตผู้ใช้บนเว็บไซต์ ไม่มีรูปแบบสำหรับการเข้าสู่ระบบและรหัสผ่านมีเพียงสองปุ่ม "เข้าสู่ระบบ" และ "ออกจากระบบ"
//--สร้างเซสชันใหม่หรือดำเนินการเซสชันที่สร้างขึ้นต่อ session_start(); //--ขั้นตอนการเข้าและออก if ( isset ($_POST [ "do" ] ) ) ( if ( $_POST [ "do" ] == "login" ) ( $_SESSION [ "logined" ] = "yes" ; ส่วนหัว ( "location: " . $ _SERVER [ "PHP_SELF" ] ; exit () ; ) if ( $_POST [ "do" ] == "logout" ) ( session_destroy () ; ส่วนหัว ( "location: " . $_SERVER [ "PHP_SELF" ] ) ; () ; ) ) //--แบบฟอร์มการอนุญาต$login_form= <<" ; //--แสดงแบบฟอร์มทางออกเสียงสะท้อน $logout_form ; ) อื่น ๆ ( echo
" ; //--แสดงแบบฟอร์มทางออก"ยินดีต้อนรับแขก!
เสียงสะท้อน $login_form ; -เมื่อใช้เซสชัน PHP เซิร์ฟเวอร์จะระบุตัวคุณและอนุญาตให้คุณดำเนินการที่จำเป็น: การเปลี่ยนแปลงข้อมูลบนหน้าเว็บต่างๆ การเพิ่ม
ข้อมูลใหม่
ฯลฯ หลังจากเสร็จสิ้นการทำงานบนไซต์ คุณจะลบเซสชันปัจจุบันโดยคลิกที่ปุ่ม "ออกจากระบบ":
เซสชั่น PHP คืออะไร? เซสชัน PHP เป็นวิธีการจัดเก็บข้อมูลในตัวแปรเซสชันที่สามารถใช้เพื่อตรวจสอบความถูกต้องของหน้าเว็บหลายหน้า ต่างจากคุกกี้ตรงที่ข้อมูลเซสชั่นจะไม่ถูกจัดเก็บไว้ในคอมพิวเตอร์ของผู้ใช้ เซสชันจะสร้างไฟล์บนเซิร์ฟเวอร์ในไดเร็กทอรีชั่วคราวแทนข้อมูลนี้ซึ่งจัดเก็บไว้ตลอดเซสชันจะพร้อมใช้งานสำหรับหน้าเว็บทั้งหมดของทรัพยากร บนเซิร์ฟเวอร์ ตำแหน่งของไฟล์ชั่วคราวถูกกำหนดโดยพารามิเตอร์ session.save_path ใน
เมื่อสร้างเซสชัน PHP จะต้องดำเนินการสามขั้นตอนต่อไปนี้:
- เมื่อเซสชั่นถูกสร้างขึ้น PHP จะสร้างตัวระบุเฉพาะที่เป็นตัวแทน สตริงสุ่มจาก 32 เลขฐานสิบหก- รหัสอายุการใช้งานเซสชัน PHP มีลักษณะดังนี้: 9c8foj87c3jj973actop1re472e8774;
- เซิร์ฟเวอร์ส่งคุกกี้ที่เรียกว่า PHPSESSID ไปยังคอมพิวเตอร์ของผู้ใช้เพื่อจัดเก็บสตริงตัวระบุเซสชันที่ไม่ซ้ำกัน
- เซิร์ฟเวอร์สร้างไฟล์ในไดเร็กทอรีชั่วคราวที่ระบุซึ่งมีชื่อของตัวระบุเซสชันที่ไม่ซ้ำกันพร้อมคำนำหน้า เซสชั่น_g sess_9c8foj87c3jj973actop1re472e8774.
การตั้งค่าเหล่านี้ช่วยได้ สคริปต์ PHPแยกค่าตัวแปรเซสชันออกจากไฟล์ ในฝั่งไคลเอ็นต์ PHPSESSID มีตัวระบุเซสชัน โดยจะยืนยันชื่อของไฟล์ที่จะค้นหาในไดเร็กทอรีเฉพาะบนฝั่งเซิร์ฟเวอร์ ซึ่งสามารถแยกตัวแปรเซสชันและใช้สำหรับการตรวจสอบได้
ผู้ใช้สามารถสิ้นสุดเซสชันได้โดยคลิกปุ่มออกจากระบบ ซึ่งเรียกใช้ฟังก์ชัน session_destroy() เมื่อผู้ใช้ปิดเบราว์เซอร์ เซสชัน PHP จะถูกปิดโดยอัตโนมัติ มิฉะนั้นเซิร์ฟเวอร์จะยุติเซสชันหลังจากระยะเวลาที่กำหนด
ไวยากรณ์เซสชันใน PHP
เมื่อ PHP อนุญาตผ่านเซสชัน PHP จะถูกสร้างขึ้นโดยใช้ฟังก์ชัน session_start() และลบออกโดยใช้ฟังก์ชัน session_destroy() ทั่วโลก ตัวแปร PHPหรือที่เรียกว่า $_SESSION ใช้เพื่อตั้งค่าตัวแปรเซสชัน คุณสามารถรีเซ็ตค่าทั้งหมดที่ตั้งไว้สำหรับตัวแปรเซสชันได้โดยใช้ฟังก์ชัน session_unset()
การดำเนินการเซสชัน
เราจะดูการดำเนินการต่อไปนี้โดยใช้เซสชัน PHP รวมถึงตัวอย่างการดำเนินการเหล่านี้
- การเริ่มต้นเซสชัน PHP และการตั้งค่าตัวแปรเซสชัน:เซสชัน PHP ใหม่เริ่มต้นโดยใช้ฟังก์ชัน session_start() เมื่อสร้างเซสชันแล้ว ตัวแปรเซสชันสามารถตั้งค่าได้โดยใช้ $_SESSION เราได้กำหนดค่าให้กับตัวแปร” รหัสผู้ใช้” — “php_user.php" และ " รหัสผ่าน” — “บทช่วยสอน”:
ผลลัพธ์: การรันโค้ด PHP ข้างต้นบนเซิร์ฟเวอร์จะสร้างข้อความต่อไปนี้:
- รับค่าตัวแปรเซสชัน PHP: สามารถรับค่าของตัวแปรที่เราตั้งไว้ได้ PHP ล่าสุดเซสชันการอนุญาต เมื่อเราเปิดเซสชั่น PHP ที่จุดเริ่มต้นของแต่ละหน้า ( เซสชั่น_เริ่มต้น()) จะต้องระบุรหัสด้านล่าง เราดึงและแสดงค่าเหล่านี้โดยใช้ตัวแปรโกลบอล $_SESSION:
"; echo "รหัสผ่าน - " . $_SESSION["รหัสผ่าน"] . ""; ?>
ผลลัพธ์: เมื่อเรารันโค้ด PHP ข้างต้นบนเซิร์ฟเวอร์ เราจะได้รับข้อความต่อไปนี้ ค่าของตัวแปรเซสชันที่เราตั้งค่าไว้ก่อนหน้านี้หลังจากสร้างเซสชัน PHP จะปรากฏขึ้น
- การอัพเดตค่าตัวแปรเซสชัน PHP: ในระหว่างเซสชัน คุณสามารถอัปเดตค่าของตัวแปรได้ ก่อนอื่นเราต้องเปิดเซสชั่น PHP ที่จุดเริ่มต้นของแต่ละหน้า ( เซสชั่น_เริ่มต้น()- ในโค้ดด้านล่างนี้เราอัพเดตค่าของตัวแปรต่างๆ “ รหัสผู้ใช้” — “new_php_user" และ " รหัสผ่าน” — “การศึกษา”.
คุณสามารถพิมพ์อาร์เรย์ของตัวแปรเซสชันและค่าของมันได้โดยใช้ฟังก์ชัน print_r($ _SESSION) ดังที่แสดงด้านล่าง:
"; print_r($_SESSION); ?>
ผลลัพธ์: เมื่อเรารันโค้ด PHP ข้างต้นบนเซิร์ฟเวอร์ เราจะได้รับข้อความต่อไปนี้ โดยจะมีอาร์เรย์ของตัวแปรเซสชันพร้อมค่าใหม่:
- การลบเซสชัน PHP และรีเซ็ตค่าตัวแปรเซสชันทั้งหมด: คุณสามารถรีเซ็ตเซสชัน PHP ได้โดยใช้ฟังก์ชัน session_unset() และลบเซสชันปัจจุบันโดยใช้ฟังก์ชัน session_destroy():
ลบเซสชัน PHP และตัวแปรเซสชันทั้งหมดสำเร็จแล้ว!
"; ?>
ผลลัพธ์: เมื่อเรารันโค้ด PHP ข้างต้นบนเว็บเซิร์ฟเวอร์ มันจะส่งผลให้มีข้อความต่อไปนี้:
บทสรุป
ในบทความนี้เราพูดถึง ฟังก์ชั่นต่างๆสำหรับการทำงานกับเซสชัน PHP และไวยากรณ์ ข้อมูลเซสชันต่างจากคุกกี้ตรงที่จัดเก็บไว้ในฝั่งเซิร์ฟเวอร์ สิ่งนี้ทำให้เซสชัน PHP มีความน่าเชื่อถือมากขึ้น
สวัสดีชุมชนที่รัก
ก่อนอื่นฉันอยากจะขอบคุณมากสำหรับ ทรัพยากรที่เป็นประโยชน์- ฉันได้พบหลายครั้งที่นี่หลายครั้ง ความคิดที่น่าสนใจและคำแนะนำการปฏิบัติ
วัตถุประสงค์ของบทความนี้คือเพื่อเน้นถึงข้อผิดพลาดของการใช้เซสชันใน PHP แน่นอนว่ามีเอกสารเกี่ยวกับ PHP และตัวอย่างมากมาย และบทความนี้ไม่ได้แกล้งทำเป็น คู่มือฉบับสมบูรณ์- ได้รับการออกแบบมาเพื่อเปิดเผยความแตกต่างบางประการของการทำงานกับเซสชันและปกป้องนักพัฒนาจากการเสียเวลาโดยไม่จำเป็น
ตัวอย่างที่พบบ่อยที่สุดของการใช้เซสชันคือการให้สิทธิ์ผู้ใช้ เริ่มจากกันให้มากที่สุด การใช้งานขั้นพื้นฐานเพื่อที่จะพัฒนาอย่างต่อเนื่องเมื่อมีงานใหม่เกิดขึ้น
(เพื่อประหยัดพื้นที่และเวลา เราจะจำกัดตัวอย่างของเราไว้เฉพาะฟังก์ชันการทำงานกับเซสชันเท่านั้น แทนที่จะสร้างแบบเต็มรูปแบบ แอปพลิเคชันทดสอบด้วยลำดับชั้นที่สวยงาม การจัดการข้อผิดพลาดที่ครอบคลุม และสิ่งดีๆ อื่นๆ)
ฟังก์ชั่น startSession() ( // หากเซสชันได้เริ่มต้นแล้ว ให้หยุดดำเนินการและส่งคืน TRUE // (พารามิเตอร์ session.auto_start ในไฟล์การตั้งค่า php.ini จะต้องปิดการใช้งาน - ค่าเริ่มต้น) ถ้า (session_id()) คืนค่าจริง ; else return session_start(); // หมายเหตุ: ก่อนเวอร์ชัน 5.3.0 ฟังก์ชัน session_start() จะส่งคืน TRUE แม้ว่าจะมีข้อผิดพลาดเกิดขึ้น // หากคุณใช้เวอร์ชันเก่ากว่า 5.3.0 ให้ตรวจสอบเพิ่มเติมสำหรับ session_id () // หลังจากเรียกใช้ฟังก์ชัน session_start() destroySession() ( if (session_id()) ( // ถ้ามี เซสชันที่ใช้งานอยู่, ลบ คุกกี้เซสชั่น, setcookie(ชื่อเซสชัน(), session_id(), เวลา()-60*60*24);
// และทำลายเซสชัน session_unset(); session_destroy(); -บันทึก: มันส่อไปว่าความรู้พื้นฐาน
ผู้อ่านทราบเกี่ยวกับเซสชัน PHP ดังนั้นเราจะไม่กล่าวถึงหลักการทำงานของฟังก์ชัน session_start() และ session_destroy() ที่นี่ งานเค้าโครงของแบบฟอร์มเข้าสู่ระบบและการตรวจสอบสิทธิ์ผู้ใช้ไม่เกี่ยวข้องกับหัวข้อของบทความดังนั้นเราจะละเว้นสิ่งเหล่านี้ด้วย ฉันขอเตือนคุณว่าเพื่อระบุผู้ใช้ในคำขอครั้งต่อไปแต่ละครั้ง ในขณะที่เข้าสู่ระบบสำเร็จ เราจำเป็นต้องจัดเก็บตัวระบุผู้ใช้ในตัวแปรเซสชัน (เช่น ชื่อรหัสผู้ใช้) ซึ่งจะสามารถใช้ได้ในคำขอต่อๆ ไปทั้งหมดภายใน ชีวิตของเซสชั่น นอกจากนี้ยังจำเป็นต้องใช้การประมวลผลผลลัพธ์ของฟังก์ชัน startSession() ของเราด้วย หากฟังก์ชันส่งคืน FALSE ให้แสดงแบบฟอร์มการเข้าสู่ระบบในเบราว์เซอร์ หากฟังก์ชันส่งคืน TRUE และตัวแปรเซสชันที่มีตัวระบุ ผู้ใช้ที่ได้รับอนุญาต(ในกรณีของเรา - รหัสผู้ใช้) มีอยู่ - แสดงหน้าของผู้ใช้ที่ได้รับอนุญาต (สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการจัดการข้อผิดพลาด โปรดดูส่วนเพิ่มเติมลงวันที่ 2013-06-07 ในส่วนของตัวแปรเซสชัน)
จนถึงทุกอย่างชัดเจน คำถามเริ่มต้นเมื่อคุณต้องการใช้การควบคุมการขาดงาน
กิจกรรมของผู้ใช้ (หมดเวลาเซสชัน) ทำให้ผู้ใช้หลายรายสามารถทำงานพร้อมกันในเบราว์เซอร์เดียว และยังป้องกันเซสชันจากการใช้งานโดยไม่ได้รับอนุญาต เรื่องนี้จะมีการหารือด้านล่างการตรวจสอบการไม่มีกิจกรรมของผู้ใช้โดยใช้เครื่องมือ PHP ในตัวฟังก์ชัน startSession() ( // การหมดเวลาการไม่ใช้งานของผู้ใช้ (เป็นวินาที) $sessionLifetime = 300; if (session_id()) return true; // ตั้งค่าอายุการใช้งานคุกกี้ ini_set("session.cookie_lifetime", $sessionLifetime); // หากไม่มีการใช้งาน หมดเวลา ผู้ใช้ระบุ, ตั้งค่าอายุการใช้งานเซสชันบนเซิร์ฟเวอร์ // หมายเหตุ: สำหรับเซิร์ฟเวอร์ที่ใช้งานจริง ขอแนะนำให้ตั้งค่าพารามิเตอร์เหล่านี้ล่วงหน้าในไฟล์ php.ini if ($sessionLifetime) ini_set("session.gc_maxlifetime", $sessionLifetime);
if (session_start()) ( setcookie(session_name(), session_id(), time()+$sessionLifetime); return true; ) else ส่งคืน false; - คำชี้แจงเล็กน้อย ดังที่คุณทราบ PHP จะกำหนดว่าเซสชันใดจะต้องเปิดใช้งานโดยชื่อคุกกี้ที่เบราว์เซอร์ส่งในส่วนหัวของคำขอ เบราว์เซอร์จะได้รับคุกกี้นี้จากเซิร์ฟเวอร์โดยที่ฟังก์ชัน session_start() วางไว้ หากคุกกี้ของเบราว์เซอร์หมดอายุ จะไม่ถูกส่งไปในคำขอ ซึ่งหมายความว่า PHP จะไม่สามารถระบุได้ว่าจะเริ่มเซสชันใด และจะถือว่าสิ่งนี้เป็นการสร้างเซสชันใหม่ พารามิเตอร์การตั้งค่า PHP session.gc_maxlifetime ซึ่งตั้งค่าเท่ากับการหมดเวลาการไม่ใช้งานของผู้ใช้ จะกำหนดอายุการใช้งานของเซสชัน PHP และควบคุมโดยเซิร์ฟเวอร์ การควบคุมอายุการใช้งานเซสชันทำงานดังนี้ (ในที่นี้เราจะพิจารณาตัวอย่างพื้นที่จัดเก็บเซสชันในที่นี้)ไฟล์ชั่วคราว
เป็นตัวเลือกเริ่มต้นและเป็นค่าเริ่มต้นที่สุดใน PHP)
// และทำลายเซสชัน session_unset();ด้วยความแตกต่างระหว่างเวลาปัจจุบันและเวลาแก้ไขล่าสุดของไฟล์เซสชัน จึงสามารถระบุได้ว่าเซสชันนั้นแอ็คทีฟหรืออายุการใช้งานหมดอายุแล้ว (กลไกในการลบไฟล์เซสชันเก่าจะกล่าวถึงรายละเอียดเพิ่มเติมในหัวข้อถัดไป) ควรสังเกตไว้ที่นี่ว่าพารามิเตอร์ session.gc_maxlifetime ใช้กับเซสชันทั้งหมดภายในเซิร์ฟเวอร์เดียว (แม่นยำยิ่งขึ้นภายในเซิร์ฟเวอร์หลักเดียว- ในทางปฏิบัติ หมายความว่าหากหลายไซต์ทำงานบนเซิร์ฟเวอร์ และแต่ละไซต์มีการหมดเวลาการไม่ใช้งานของผู้ใช้ของตัวเอง การตั้งค่าพารามิเตอร์นี้บนไซต์ใดไซต์หนึ่งก็จะนำไปสู่การตั้งค่าสำหรับไซต์อื่นเช่นกัน เช่นเดียวกับโฮสติ้งที่ใช้ร่วมกัน เพื่อหลีกเลี่ยงสถานการณ์นี้ ไดเร็กทอรีเซสชันที่แยกกันจะถูกใช้สำหรับแต่ละไซต์ภายในเซิร์ฟเวอร์เดียวกัน การตั้งค่าพาธไปยังไดเร็กทอรีเซสชันทำได้โดยใช้พารามิเตอร์ session.save_path ในไฟล์การตั้งค่า php.ini หรือโดยการเรียกใช้ฟังก์ชัน ini_set() หลังจากนี้ เซสชันของแต่ละไซต์จะถูกจัดเก็บไว้ในไดเร็กทอรีแยกกัน และพารามิเตอร์ session.gc_maxlifetime ที่ตั้งค่าไว้ในไซต์ใดไซต์หนึ่งจะใช้ได้กับเซสชันของไซต์นั้นเท่านั้น เราจะไม่พิจารณากรณีนี้โดยละเอียด โดยเฉพาะอย่างยิ่งเนื่องจากเรามีตัวเลือกที่ยืดหยุ่นมากขึ้นในการตรวจสอบการไม่มีกิจกรรมของผู้ใช้
การควบคุมการไม่ใช้งานของผู้ใช้โดยใช้ตัวแปรเซสชัน
ดูเหมือนว่า รุ่นก่อนหน้าเพื่อความเรียบง่าย (เพียงสองสาม บรรทัดเพิ่มเติม code) ให้ทุกสิ่งที่เราต้องการ แต่จะเกิดอะไรขึ้นถ้าไม่ใช่ทุกคำขอที่สามารถถือเป็นผลลัพธ์ของกิจกรรมของผู้ใช้ได้? ตัวอย่างเช่น เพจมีตัวจับเวลาที่จะส่งคำขอ AJAX เป็นระยะๆ เพื่อรับการอัปเดตจากเซิร์ฟเวอร์ คำขอดังกล่าวไม่ถือเป็นกิจกรรมของผู้ใช้ ดังนั้น ต่ออายุอัตโนมัติอายุเซสชันไม่ถูกต้อง ในกรณีนี้- แต่เรารู้ว่า PHP จะอัปเดตเวลาแก้ไขของไฟล์เซสชันโดยอัตโนมัติทุกครั้งที่เรียกใช้ฟังก์ชัน session_start() ซึ่งหมายความว่าคำขอใดๆ จะนำไปสู่การขยายอายุการใช้งานของเซสชัน และการหมดเวลาของการไม่ใช้งานของผู้ใช้จะไม่เกิดขึ้น นอกจากนี้ หมายเหตุสุดท้ายจากส่วนก่อนหน้าเกี่ยวกับความซับซ้อนของพารามิเตอร์ session.gc_maxlifetime อาจดูสับสนเกินไปและยากต่อการนำไปใช้สำหรับบางคนเพื่อแก้ปัญหานี้เราจะยกเลิกการใช้บิวท์อิน กลไก PHPและแนะนำตัวแปรเซสชันใหม่หลายตัวที่จะช่วยให้เราควบคุมเวลาที่ผู้ใช้ไม่มีกิจกรรมได้ด้วยตัวเอง
ฟังก์ชั่น startSession($isUserActivity=true) ( $sessionLifetime = 300; if (session_id()) return true; // ตั้งค่าอายุการใช้งานคุกกี้ก่อนปิดเบราว์เซอร์ (เราจะควบคุมทุกอย่างบนฝั่งเซิร์ฟเวอร์) ini_set("session. cookie_lifetime", 0) ; if (! session_start()) กลับ false; $t = time(); กิจกรรมสุดท้ายผู้ใช้ // (time คำขอครั้งสุดท้ายเมื่อตัวแปรเซสชันล่าสุดได้รับการอัปเดต) ถ้า (isset($_SESSION["lastactivity"]) && $t-$_SESSION["lastactivity"] >= $sessionLifetime) ( // หากเวลาผ่านไปนับตั้งแต่กิจกรรมล่าสุดของผู้ใช้ / / มากกว่าการหมดเวลาของการไม่ใช้งาน ซึ่งหมายความว่าเซสชั่นหมดอายุแล้ว และเซสชั่นจะต้องถูกยกเลิก destroySession(); อย่างอื่น ( // หากยังไม่เกิดการหมดเวลา // และหากคำขอเกิดขึ้นเนื่องจากกิจกรรมของผู้ใช้ , // อัปเดตตัวแปร Lastactivity ด้วยค่าปัจจุบัน เวลา // จึงขยายเวลาเซสชันออกไปอีกหนึ่งวินาที sessionLifetime ถ้า ($isUserActivity) $_SESSION["lastactivity"] = $t ) ) คืนค่าจริง; -
มาสรุปกัน ในคำขอแต่ละรายการ เราจะตรวจสอบเพื่อดูว่าถึงระยะหมดเวลาแล้วหรือไม่นับตั้งแต่กิจกรรมล่าสุดของผู้ใช้ก่อนหน้านี้ ช่วงเวลาปัจจุบันและหากถึงแล้ว เราจะทำลายเซสชันและขัดจังหวะการทำงานของฟังก์ชัน โดยส่งคืน FALSE หากไม่ถึงระยะหมดเวลา และส่งพารามิเตอร์ $isUserActivity ไปยังฟังก์ชันด้วย จริง- อัปเดตเวลากิจกรรมล่าสุดของผู้ใช้ สิ่งที่เราต้องทำคือกำหนดในสคริปต์การเรียกว่าคำขอนั้นเป็นผลมาจากกิจกรรมของผู้ใช้หรือไม่ และหากไม่เป็นเช่นนั้น ให้เรียกใช้ฟังก์ชัน startSession โดยตั้งค่า $isUserActivity เป็น FALSE
อัปเดตเมื่อ 2013-06-07กำลังประมวลผลผลลัพธ์ของฟังก์ชัน sessionStart()
ความคิดเห็นชี้ให้เห็นว่าการส่งคืน FALSE ไม่ได้ให้ความเข้าใจที่สมบูรณ์เกี่ยวกับสาเหตุของข้อผิดพลาด และนี่เป็นเรื่องที่ยุติธรรมอย่างยิ่ง ฉันไม่ได้เผยแพร่รายละเอียดการจัดการข้อผิดพลาดที่นี่ (ความยาวของบทความค่อนข้างใหญ่อยู่แล้ว) เนื่องจากไม่เกี่ยวข้องโดยตรงกับหัวข้อของบทความ แต่จากความคิดเห็นฉันจะชี้แจง
อย่างที่คุณเห็น ฟังก์ชัน sessionStart สามารถคืนค่า FALSE ได้ในสองกรณี หรือไม่สามารถเริ่มเซสชั่นได้เนื่องจากมีบางอย่าง ข้อผิดพลาดภายในเซิร์ฟเวอร์ (เช่น การตั้งค่าไม่ถูกต้องเซสชันใน php.ini) หรืออายุการใช้งานเซสชันหมดอายุแล้ว ในกรณีแรก เราต้องเปลี่ยนเส้นทางผู้ใช้ไปยังหน้าเว็บที่มีข้อผิดพลาดระบุว่ามีปัญหาบนเซิร์ฟเวอร์และแบบฟอร์มสำหรับติดต่อฝ่ายสนับสนุน ในกรณีที่สอง เราต้องโอนผู้ใช้ไปยังแบบฟอร์มเข้าสู่ระบบและแสดงข้อความที่เกี่ยวข้องโดยระบุว่าเซสชันหมดอายุแล้ว ในการดำเนินการนี้ เราจำเป็นต้องป้อนรหัสข้อผิดพลาดและส่งคืนรหัสที่เกี่ยวข้องแทน FALSE และในวิธีการเรียก ให้ตรวจสอบและดำเนินการตามนั้น
ในตอนนี้ แม้ว่าเซสชันบนเซิร์ฟเวอร์จะยังคงอยู่ เซสชันนั้นจะถูกทำลายในครั้งแรกที่มีการเข้าถึง หากการหมดเวลาการไม่ใช้งานของผู้ใช้หมดอายุลง และสิ่งนี้จะเกิดขึ้นโดยไม่คำนึงถึงอายุเซสชันที่ตั้งไว้ การตั้งค่าส่วนกลาง PHP.
// และทำลายเซสชัน session_unset();จะเกิดอะไรขึ้นหากเบราว์เซอร์ถูกปิดและคุกกี้ชื่อเซสชันถูกทำลายโดยอัตโนมัติ คำขอไปยังเซิร์ฟเวอร์ในครั้งถัดไปที่เปิดเบราว์เซอร์จะไม่มีคุกกี้เซสชัน และเซิร์ฟเวอร์จะไม่สามารถเปิดเซสชันและตรวจสอบการหมดเวลาของการไม่ใช้งานของผู้ใช้ได้ สำหรับเรา สิ่งนี้เทียบเท่ากับการสร้างเซสชันใหม่ และไม่ส่งผลกระทบต่อฟังก์ชันการทำงานหรือความปลอดภัยแต่อย่างใด แต่มีคำถามที่ยุติธรรมเกิดขึ้น - ใครจะเป็นผู้ทำลายเซสชันเก่า หากจนถึงขณะนี้เราได้ทำลายมันหลังจากหมดเวลาหมดเวลาแล้ว? หรือตอนนี้มันจะค้างอยู่ในไดเร็กทอรีเซสชันตลอดไป? ในการล้างเซสชันเก่าใน PHP มีกลไกที่เรียกว่า เก็บขยะ- โดยจะทำงานในเวลาที่มีการร้องขอครั้งถัดไปไปยังเซิร์ฟเวอร์ และล้างเซสชันเก่าทั้งหมดตามวันที่ การเปลี่ยนแปลงครั้งล่าสุดไฟล์เซสชัน แต่กลไกการรวบรวมขยะไม่ได้เริ่มต้นด้วยทุกคำขอที่ส่งไปยังเซิร์ฟเวอร์ ความถี่ (หรือความน่าจะเป็น) ของการเปิดตัวถูกกำหนดโดยพารามิเตอร์การตั้งค่าสองตัว session.gc_probability และ session.gc_divisor ผลลัพธ์ของการหารพารามิเตอร์แรกด้วยวินาทีคือความน่าจะเป็นที่จะเปิดตัวกลไกการรวบรวมขยะ ดังนั้น เพื่อให้กลไกการทำความสะอาดเซสชันเปิดใช้งานพร้อมกับคำขอแต่ละครั้งไปยังเซิร์ฟเวอร์ พารามิเตอร์เหล่านี้จะต้องตั้งค่าเป็นค่าเท่ากัน เช่น "1" วิธีการนี้รับประกันไดเร็กทอรีเซสชันที่สะอาด แต่เห็นได้ชัดว่าแพงเกินไปสำหรับเซิร์ฟเวอร์ ดังนั้น ในระบบที่ใช้งานจริง ค่าเริ่มต้นของ session.gc_divisor จะถูกตั้งค่าเป็น 1000 ซึ่งหมายความว่ากลไกการรวบรวมขยะจะทำงานด้วยความน่าจะเป็น 1/1000 หากคุณทดลองใช้การตั้งค่าเหล่านี้ในไฟล์ php.ini คุณอาจสังเกตเห็นว่าในกรณีที่อธิบายไว้ข้างต้น เมื่อเบราว์เซอร์ปิดและล้างคุกกี้ทั้งหมด ก็ยังมีเซสชันเก่าเหลืออยู่ในไดเร็กทอรีเซสชันอยู่ระยะหนึ่ง แต่เรื่องนี้ไม่ควรทำให้คุณกังวลเพราะ... ตามที่ระบุไว้แล้ว สิ่งนี้ไม่ส่งผลกระทบต่อความปลอดภัยของกลไกของเรา แต่อย่างใด
อัปเดตเมื่อ 2013-06-07ป้องกันไม่ให้สคริปต์ค้างเนื่องจากการล็อกไฟล์เซสชัน
ความคิดเห็นดังกล่าวทำให้เกิดปัญหาการเรียกใช้สคริปต์พร้อมกันค้างเนื่องจากไฟล์เซสชันถูกบล็อก (ตัวเลือกที่โดดเด่นที่สุดคือการสำรวจความคิดเห็นแบบยาว)
ก่อนอื่น ฉันทราบว่าปัญหานี้ไม่ได้ขึ้นอยู่กับโหลดของเซิร์ฟเวอร์หรือจำนวนผู้ใช้โดยตรง แน่นอนกว่า คำขอเพิ่มเติมยิ่งสคริปต์ทำงานช้าลงเท่าไร แต่นี่เป็นการพึ่งพาทางอ้อม ปัญหาจะปรากฏขึ้นภายในเซสชันเดียวเท่านั้น เมื่อเซิร์ฟเวอร์ได้รับคำขอหลายรายการในนามของผู้ใช้รายเดียว (ตัวอย่างเช่น หนึ่งในนั้นคือการสำรวจความคิดเห็นแบบยาว และส่วนที่เหลือเป็นคำขอปกติ) แต่ละคำขอพยายามเข้าถึงไฟล์เซสชันเดียวกัน และหากคำขอก่อนหน้านี้ไม่ได้ปลดล็อคไฟล์ คำขอถัดไปก็จะค้าง
เพื่อให้การล็อกไฟล์เซสชันเหลือน้อยที่สุด ขอแนะนำอย่างยิ่งให้ปิดเซสชันโดยการเรียกใช้ฟังก์ชัน session_write_close() ทันทีหลังจากการดำเนินการทั้งหมดกับตัวแปรเซสชันเสร็จสิ้น ในทางปฏิบัติ หมายความว่าคุณไม่ควรเก็บทุกอย่างไว้ในตัวแปรเซสชันและเข้าถึงตัวแปรเหล่านั้นตลอดการทำงานของสคริปต์ และหากคุณต้องการจัดเก็บข้อมูลการทำงานบางส่วนไว้ในตัวแปรเซสชัน ให้อ่านทันทีเมื่อเซสชันเริ่มต้น บันทึกลงในตัวแปรท้องถิ่นเพื่อใช้ในภายหลังและปิดเซสชัน (หมายถึงการปิดเซสชันโดยใช้ฟังก์ชัน session_write_close และไม่ทำลายโดยใช้ session_destroy ).
ในตัวอย่างของเรา หมายความว่าทันทีหลังจากเปิดเซสชัน ตรวจสอบอายุการใช้งานและการมีอยู่ของผู้ใช้ที่ได้รับอนุญาต เราต้องอ่านและบันทึกเพิ่มเติมทั้งหมด จำเป็นโดยแอปพลิเคชันตัวแปรเซสชัน (ถ้ามี) จากนั้นปิดเซสชันโดยใช้การเรียกไปที่ session_write_close() และดำเนินการสคริปต์ต่อไป ไม่ว่าจะเป็นการสำรวจความคิดเห็นแบบยาวหรือคำขอปกติ
การปกป้องเซสชันจากการใช้งานโดยไม่ได้รับอนุญาต
ลองจินตนาการถึงสถานการณ์ ผู้ใช้รายหนึ่งของคุณได้รับโทรจันที่ปล้นคุกกี้ของเบราว์เซอร์ (ซึ่งเซสชันของเราถูกจัดเก็บไว้) และส่งไปยังอีเมลที่ระบุ ผู้โจมตีได้รับคุกกี้และใช้เพื่อปลอมแปลงคำขอในนามของผู้ใช้ที่ได้รับอนุญาตของเรา เซิร์ฟเวอร์ยอมรับและประมวลผลคำขอนี้สำเร็จเสมือนว่ามาจากผู้ใช้ที่ได้รับอนุญาต หากไม่ปฏิบัติ ตรวจสอบเพิ่มเติมที่อยู่ IP การโจมตีดังกล่าวจะนำไปสู่การแฮ็คบัญชีผู้ใช้ได้สำเร็จพร้อมกับผลที่ตามมาทั้งหมดทำไมสิ่งนี้ถึงเป็นไปได้? แน่นอนว่าเนื่องจากชื่อและตัวระบุเซสชันจะเหมือนกันตลอดอายุการใช้งานของเซสชัน และหากคุณได้รับข้อมูลนี้ คุณก็สามารถส่งคำขอในนามของผู้ใช้รายอื่นได้อย่างง่ายดาย (แน่นอน ภายในอายุการใช้งานของเซสชันนี้) นี่อาจไม่ใช่การโจมตีประเภทที่พบบ่อยที่สุด แต่ในทางทฤษฎีดูเหมือนว่าจะเป็นไปได้ โดยเฉพาะอย่างยิ่งเมื่อพิจารณาว่าโทรจันดังกล่าวไม่ต้องการสิทธิ์ของผู้ดูแลระบบในการปล้นคุกกี้เบราว์เซอร์ของผู้ใช้ด้วยซ้ำ
คุณจะป้องกันตัวเองจากการโจมตีประเภทนี้ได้อย่างไร? เห็นได้ชัดว่าเป็นการจำกัดอายุการใช้งานของตัวระบุเซสชันและเปลี่ยนตัวระบุเป็นระยะภายในเซสชันเดียวกัน นอกจากนี้เรายังสามารถเปลี่ยนชื่อของเซสชันได้ด้วยการลบเซสชันเก่าออกทั้งหมดและสร้างเซสชันใหม่ โดยคัดลอกตัวแปรเซสชันทั้งหมดจากเซสชันเก่าลงไป แต่สิ่งนี้ไม่ส่งผลกระทบต่อแก่นแท้ของแนวทาง ดังนั้นเพื่อความเรียบง่าย เราจะจำกัดตัวเองอยู่เพียงตัวระบุเซสชันเท่านั้น
เห็นได้ชัดว่ายิ่งอายุการใช้งาน ID เซสชันสั้นลง ผู้โจมตีจะต้องรับและใช้คุกกี้เพื่อปลอมคำขอของผู้ใช้ก็จะยิ่งมีเวลาน้อยลงเท่านั้น ตามหลักการแล้ว ควรใช้ตัวระบุใหม่สำหรับแต่ละคำขอ ซึ่งจะลดความเป็นไปได้ในการใช้เซสชันของบุคคลอื่น แต่เราจะพิจารณากรณีทั่วไปเมื่อมีการกำหนดเวลาการสร้างตัวระบุเซสชันตามอำเภอใจ
(เราจะละเว้นส่วนของรหัสที่ได้พูดคุยไปแล้ว)
ฟังก์ชั่น startSession($isUserActivity=true) ( // Session identifier allowance $idLifetime = 60; ... if ($idLifetime) ( // หากกำหนดอายุการใช้งานของ session identifier // ตรวจสอบเวลาที่ผ่านไปนับตั้งแต่เซสชันถูกตั้งค่าไว้ สร้างหรือการสร้างใหม่ครั้งล่าสุด // (เวลาของคำขอล่าสุดเมื่อเวลาเริ่มต้นของตัวแปรเซสชันได้รับการอัปเดต) if (isset($_SESSION["starttime"])) ( if ($t-$_SESSION["starttime"] >= $ idLifetime) ( // เวลา ตัวระบุเซสชันหมดอายุแล้ว // สร้างตัวระบุใหม่ session_regenerate_id(true); $_SESSION["starttime"] = $t) ) else ( // เรามาถึงที่นี่หากเซสชันเพิ่งถูกสร้างขึ้น // ตั้งเวลาการสร้างตัวระบุเซสชันเป็น เวลาปัจจุบัน$_SESSION["เวลาเริ่มต้น"] = $t;
ดังนั้น เมื่อสร้างเซสชันใหม่ (ซึ่งเกิดขึ้นเมื่อผู้ใช้เข้าสู่ระบบสำเร็จ) เราจะตั้งเวลาเริ่มต้นของตัวแปรเซสชัน ซึ่งจะจัดเก็บเวลาของตัวระบุเซสชันรุ่นสุดท้ายให้เราเป็นค่าเท่ากับเวลาเซิร์ฟเวอร์ปัจจุบัน ต่อไป ในแต่ละคำขอ เราจะตรวจสอบว่าเวลาผ่านไปเพียงพอแล้ว (idLifetime) นับตั้งแต่ตัวระบุรุ่นสุดท้ายหรือไม่ และหากเป็นเช่นนั้น เราจะสร้างตัวระบุใหม่ ดังนั้น หากในช่วงอายุการใช้งานที่กำหนดของตัวระบุ ผู้โจมตีที่ได้รับคุกกี้ของผู้ใช้ที่ได้รับอนุญาตไม่มีเวลาใช้งาน เซิร์ฟเวอร์จะถือว่าคำขอปลอมนั้นไม่ได้รับอนุญาต และผู้โจมตีจะถูกนำไปเข้าสู่ระบบ หน้าหนังสือ.
// และทำลายเซสชัน session_unset();รหัสเซสชันใหม่จะถูกใส่ลงในคุกกี้ของเบราว์เซอร์เมื่อมีการเรียกใช้ฟังก์ชัน session_regenerate_id() ซึ่งจะส่งคุกกี้ใหม่ ซึ่งคล้ายกับฟังก์ชัน session_start() ดังนั้นเราจึงไม่จำเป็นต้องอัปเดตคุกกี้ด้วยตนเอง
หากเราต้องการทำให้เซสชันของเราปลอดภัยที่สุดเท่าที่จะเป็นไปได้ ก็เพียงพอแล้วที่จะตั้งค่าอายุการใช้งานของตัวระบุเป็นหนึ่งรายการ หรือแม้แต่ลบฟังก์ชัน session_regenerate_id() ออกจากวงเล็บและลบการตรวจสอบทั้งหมดออก ซึ่งจะนำไปสู่การสร้างตัวระบุใหม่ในแต่ละ ขอ. (ฉันไม่ได้ทดสอบผลกระทบของแนวทางนี้ต่อประสิทธิภาพการทำงาน และฉันบอกได้แค่ว่าฟังก์ชัน session_regenerate_id(true) ดำเนินการเพียง 4 อย่างเท่านั้น ได้แก่ การสร้างตัวระบุใหม่ การสร้างส่วนหัวด้วยคุกกี้เซสชัน การลบอันเก่า และสร้าง ไฟล์เซสชันใหม่)
การพูดนอกเรื่องโคลงสั้น ๆ:หากโทรจันฉลาดมากจนไม่ส่งคุกกี้ไปยังผู้โจมตี แต่จัดการส่งคำขอปลอมที่เตรียมไว้ล่วงหน้าทันทีที่ได้รับคุกกี้ วิธีการที่อธิบายไว้ข้างต้นมักจะไม่สามารถป้องกันได้ การโจมตี เนื่องจากระหว่างเวลาที่โทรจันได้รับคุกกี้และการส่งคำขอปลอม แทบจะไม่มีความแตกต่างเลย และมีความเป็นไปได้สูงที่ในขณะนี้ ตัวระบุเซสชันจะไม่ถูกสร้างขึ้นใหม่
ความเป็นไปได้ในการทำงานพร้อมกันในเบราว์เซอร์เดียวในนามของผู้ใช้หลายคน
งานสุดท้ายที่ฉันต้องการพิจารณาคือความสามารถสำหรับผู้ใช้หลายคนในการทำงานพร้อมกันในเบราว์เซอร์เดียว คุณลักษณะนี้มีประโยชน์อย่างยิ่งในระหว่างขั้นตอนการทดสอบเมื่อคุณต้องการจำลอง ทำงานพร้อมกันผู้ใช้ และขอแนะนำให้ทำเช่นนี้ในเบราว์เซอร์ที่คุณชื่นชอบ แทนที่จะใช้คลังแสงที่มีอยู่ทั้งหมดหรือเปิดเบราว์เซอร์หลายอินสแตนซ์ในโหมดไม่ระบุตัวตนในตัวอย่างก่อนหน้านี้ เราไม่ได้ระบุชื่อเซสชันอย่างชัดเจน ดังนั้นจึงใช้ชื่อ PHP เริ่มต้น (PHPSESSID) ซึ่งหมายความว่าเซสชันทั้งหมดที่เราสร้างจนถึงขณะนี้ได้ส่งคุกกี้ไปยังเบราว์เซอร์ภายใต้ชื่อ PHPSESSID แน่นอนว่าหากชื่อคุกกี้เหมือนกันเสมอ ก็ไม่มีทางที่จะจัดระเบียบสองเซสชันที่มีชื่อเดียวกันภายในเบราว์เซอร์เดียวกันได้ แต่ถ้าเราใช้ชื่อเซสชันของเราเองสำหรับผู้ใช้แต่ละคน ปัญหาก็จะได้รับการแก้ไข มาทำกันเถอะ
ฟังก์ชั่น startSession($isUserActivity=true, $prefix=null) ( ... if (session_id()) return true; // หากคำนำหน้าผู้ใช้ถูกส่งผ่านในพารามิเตอร์ // ตั้งชื่อเซสชันที่ไม่ซ้ำกันซึ่งมีสิ่งนี้ คำนำหน้า // หรือตั้งชื่อทั่วไปสำหรับผู้ใช้ทั้งหมด (เช่น MYPROJECT) session_name("MYPROJECT".($prefix ? "_".$prefix: "")); ถ้า (! session_start()) กลับเท็จ;
ตอนนี้สิ่งที่เหลืออยู่คือต้องแน่ใจว่าสคริปต์การโทรส่งคำนำหน้าเฉพาะสำหรับผู้ใช้แต่ละรายไปยังฟังก์ชัน startSession() ซึ่งสามารถทำได้ เช่น โดยการส่งคำนำหน้าในพารามิเตอร์ GET/POST ของแต่ละคำขอหรือผ่านคุกกี้เพิ่มเติม
บทสรุป
โดยสรุป ฉันจะให้โค้ดสุดท้ายที่สมบูรณ์ของฟังก์ชันของเราสำหรับการทำงานกับเซสชัน PHP รวมถึงงานทั้งหมดที่กล่าวถึงข้างต้นฟังก์ชัน startSession($isUserActivity=true, $prefix=null) ( $sessionLifetime = 300; $idLifetime = 60; if (session_id()) return true; session_name("MYPROJECT".($prefix ? "_".$prefix: "")); ini_set("session.cookie_lifetime", 0); if (! session_start()) กลับเท็จ; $t = time(); if ($sessionLifetime) ( if (isset($_SESSION["lastactivity"] ) && $t-$_SESSION["lastactivity"] >= $sessionLifetime) ( destroySession(); return false; ) else ( if ($isUserActivity) $_SESSION["lastactivity"] = $t; ) ) if ($idLifetime ) ( if (isset($_SESSION["starttime"])) ( if ($t-$_SESSION["starttime"] >= $idLifetime) ( session_regenerate_id(true); $_SESSION["starttime"] = $t; ) ) else ( $_SESSION["starttime"] = $t; ) ) คืนค่าจริง; ฟังก์ชัน destroySession() ( if (session_id()) ( session_unset(); setcookie(session_name(), session_id(), time() - 60*60*24); session_destroy();
ฉันหวังว่าบทความนี้จะช่วยประหยัดเวลาสำหรับผู้ที่ไม่เคยเจาะลึกเกี่ยวกับกลไกเซสชันมากเกินไป และให้ข้อมูลเชิงลึกที่เพียงพอเกี่ยวกับกลไกนี้สำหรับผู้ที่เพิ่งเริ่มทำความคุ้นเคยกับ PHP
จากจุดเริ่มต้นทุกคนยอมรับ PHP อย่างมาก แต่ทันทีที่โครงการขนาดใหญ่พอสมควรเริ่มถูกสร้างขึ้นในภาษานี้ นักพัฒนาก็ต้องเผชิญกับ ปัญหาใหม่- PHP ขาดแนวคิดเรื่องตัวแปรโกลบอล! นั่นคือมีการดำเนินการสคริปต์บางตัวส่งเพจที่สร้างขึ้นไปยังไคลเอนต์และทรัพยากรทั้งหมดที่ใช้โดยสคริปต์นี้ถูกทำลาย ฉันจะพยายามอธิบาย: สมมติว่าไซต์หนึ่งมีสองหน้า คือ index.php และ dothings.php แหล่งที่มาของหน้าเหล่านี้มีลักษณะดังนี้:
ดัชนี.php dothings.phpหากเราเรียกใช้สคริปต์ทั้งสองนี้ ในหน้าแรกเราจะเห็นข้อความว่า "ฉันได้รับมอบหมายให้ทำดัชนี.php" และหน้าที่สองจะว่างเปล่า
นักพัฒนาเว็บไซต์เริ่มใช้คุกกี้เพื่อจัดเก็บตัวแปรส่วนกลางทางฝั่งไคลเอ็นต์โดยไม่ต้องคิดทบทวน กระบวนการมีลักษณะดังนี้: ผู้ใช้มาที่หน้าหลักของเว็บไซต์ ดำเนินการบางอย่าง และข้อมูลทั้งหมดที่เกี่ยวข้องกับผู้ใช้รายนี้ ซึ่งอาจจำเป็นในหน้าอื่น ๆ ของเว็บไซต์ จะถูกเก็บไว้ในเบราว์เซอร์ของเขาในรูปแบบ ของคุกกี้ วิธีนี้มีข้อเสียที่ค่อนข้างร้ายแรงเนื่องจากนักพัฒนาหลายคนหันหลังให้กับ PHP ในคราวเดียว ตัวอย่างเช่น เราต้องอนุญาตให้ผู้ใช้อนุญาตให้เขาเข้าถึงส่วนส่วนตัว (หรือส่วนตัว) ของไซต์ได้ คุณจะต้องส่งคุกกี้ให้กับผู้ใช้ซึ่งจะทำหน้าที่เป็นตัวระบุในภายหลังบนเว็บไซต์ วิธีการนี้จะยุ่งยากและไม่สะดวกทันทีที่ไซต์เริ่มรวบรวมข้อมูลเกี่ยวกับพฤติกรรมของผู้ใช้มากขึ้นเรื่อย ๆ เนื่องจากแนะนำให้เข้ารหัสข้อมูลทั้งหมดที่ส่งถึงผู้ใช้เพื่อไม่ให้เกิดการปลอมแปลง เมื่อเร็วๆ นี้ ด้วยการปลอมแปลงคุกกี้ ทำให้สามารถ "แคร็ก" แชทได้มากกว่าหนึ่งแชท และบางครั้งก็อาจแอบเข้าไปในอีเมลของคนอื่นด้วย นอกจากนี้ ยังมีคนแปลกหน้าในโลกที่เบราว์เซอร์ไม่รองรับคุกกี้
ฉันจะไม่พูดถึงประเด็นทางเทคโนโลยีของกลไกเซสชัน แต่จะอธิบายวิธีทำงานอย่างถูกต้องกับเซสชันใน PHP เท่านั้น
วิธีการทำงานกับเซสชั่น?
หากคุณทดสอบตัวอย่างจากบทความ (หรือสคริปต์ของคุณ) บนโฮสติ้งเชิงพาณิชย์ใดๆ ก็ไม่น่าจะมีปัญหาในการทำงานกับเซสชัน หากคุณตั้งค่าเซิร์ฟเวอร์ด้วยตนเอง (ไม่ว่าจะเป็นเซิร์ฟเวอร์จริงหรือโปรแกรมจำลอง) ข้อผิดพลาดในลักษณะนี้อาจปรากฏขึ้น:
"คำเตือน: open(/var/state/php/sess_6f71d1dbb52fa88481e752af7f384db0, O_RDWR) ล้มเหลว: ไม่มีไฟล์หรือไดเรกทอรีดังกล่าว (2)"
นี่หมายความว่า PHP ของคุณได้รับการกำหนดค่าไม่ถูกต้อง คุณสามารถแก้ไขปัญหานี้ได้โดยการระบุเส้นทางที่ถูกต้อง (ไปยังไดเร็กทอรีที่มีอยู่) เพื่อบันทึกเซสชันในไฟล์ php.ini และรีสตาร์ทเซิร์ฟเวอร์
สคริปต์ใด ๆ ที่จะใช้ตัวแปร (ข้อมูล) จากเซสชันจะต้องมีบรรทัดต่อไปนี้:
Session_start();
คำสั่งนี้จะบอกเซิร์ฟเวอร์ว่าเพจที่กำหนดต้องการตัวแปรทั้งหมดที่เกี่ยวข้องกับผู้ใช้ที่กำหนด (เบราว์เซอร์) เซิร์ฟเวอร์รับตัวแปรเหล่านี้จากไฟล์และทำให้พร้อมใช้งาน เป็นสิ่งสำคัญมากที่จะต้องเปิดเซสชันก่อนที่จะส่งข้อมูลใด ๆ ไปยังผู้ใช้ ในทางปฏิบัติ หมายความว่าขอแนะนำให้เรียกใช้ฟังก์ชัน session_start() ที่จุดเริ่มต้นของหน้า เช่น:
Session_start(); -
... หากต้องการตั้งค่าไดเร็กทอรีที่จะบันทึกไฟล์เซสชัน ให้ใช้ฟังก์ชัน session_save_path(): session_save_path($_SERVER["DOCUMENT_ROOT"]."/session"); session_start();หลังจากเซสชันเริ่มต้น คุณสามารถตั้งค่าตัวแปรส่วนกลางได้
ดัชนี.php เมื่อกำหนดค่าใดๆ ให้กับฟิลด์ใดๆ ของอาร์เรย์ $_SESSION ตัวแปรที่มีชื่อเดียวกันจะถูกลงทะเบียนเป็นตัวแปรเซสชันโดยอัตโนมัติdothings.php
อาร์เรย์นี้มีอยู่ในทุกหน้าโดยใช้เซสชัน ตัวอย่างเช่น ลองดูที่โปรแกรม:
ทุกอย่างเรียบร้อยดี โหลดเซสชันแล้ว!มาดูกันว่ามีอะไรบ้าง:
เมื่อเรียกใช้ไฟล์เหล่านี้ตามลำดับ สคริปต์แรก "index.php" จะให้ผลลัพธ์ดังต่อไปนี้:ทุกอย่างเรียบร้อยดี โหลดเซสชันแล้ว! มาดูกันว่ามีอะไรบ้าง:
และ “dothings.php” ตัวที่สองคือ: ฉันถูกขอให้ทำดัชนี.phpขณะนี้ตัวแปร $a พร้อมใช้งานบนทุกหน้าของไซต์ที่ระบุซึ่งเปิดใช้เซสชันแล้ว
- อื่นคุณสมบัติที่มีประโยชน์
- และเทคนิคการทำงานแบบเซสชัน:ไม่ได้ตั้งค่า($_SESSION["a"])
- - เซสชัน "ลืม" ค่าของตัวแปรเซสชันที่ระบุเซสชั่น_ทำลาย()
- - เซสชันถูกทำลาย (เช่น หากผู้ใช้ออกจากระบบโดยคลิกปุ่ม "ออกจากระบบ") session_set_cookie_params (อายุการใช้งาน int [, เส้นทางสตริง [, โดเมนสตริง]])
- การใช้ฟังก์ชันนี้คุณสามารถกำหนดระยะเวลาที่เซสชันจะ "คงอยู่" ได้โดยการตั้งค่า unix_timestamp ซึ่งจะกำหนดเวลาที่ "สิ้นสุด" ของเซสชัน ตามค่าเริ่มต้น เซสชันจะ "ถ่ายทอดสด" จนกว่าไคลเอ็นต์จะปิดหน้าต่างเบราว์เซอร์
session_write_close() - บันทึกตัวแปรเซสชั่นและปิดมันนี่เป็นสิ่งจำเป็นในการเปิดไซต์ในหน้าต่างใหม่หากเพจใช้เวลานานในการประมวลผลและบล็อกไฟล์เซสชันสำหรับเบราว์เซอร์ของคุณ
ตัวอย่าง
คำถามเกี่ยวกับการอนุญาตผู้ใช้โดยใช้เซสชัน PHP จะถูกถามอย่างต่อเนื่องในการประชุมการเขียนโปรแกรมเว็บ กลไกในการอนุญาตผู้ใช้ในระบบโดยใช้เซสชันค่อนข้างดีจากมุมมองด้านความปลอดภัย (ดูหัวข้อ)
ตัวอย่างของเราก็จะประกอบด้วย สามไฟล์: index.php, authorize.php และ secretplace.php ไฟล์ index.php มีแบบฟอร์มที่ผู้ใช้จะป้อนชื่อผู้ใช้และรหัสผ่านของเขา แบบฟอร์มนี้จะส่งข้อมูลไปยังไฟล์ authorize.php ซึ่งหากการอนุญาตสำเร็จ จะอนุญาตให้ผู้ใช้เข้าถึงไฟล์ Secretplace.php มิฉะนั้นจะแสดงข้อความแสดงข้อผิดพลาด
ตัวอย่าง: ดัชนี.php
authorize.php หน้า... header("ตำแหน่ง: secretplace.php"); ออก;
) ) // หากมีบางอย่างผิดปกติผู้ใช้จะได้รับ // ข้อความแสดงข้อผิดพลาด -คุณป้อนรหัสผ่านผิด!
ความปลอดภัย
Secretplace.php สวัสดี,,คุณอยู่ในเพจลับ!!! -
- ดังนั้นเราจึงสามารถส่งตัวระบุจากหน้าหนึ่ง (สคริปต์ PHP) ไปยังอีกหน้าหนึ่งได้ (จนกว่าจะมีการโทรครั้งถัดไปจากไซต์ของเรา) ซึ่งหมายความว่าเราสามารถแยกแยะระหว่างผู้เยี่ยมชมไซต์ทั้งหมดได้ เนื่องจากตัวระบุเซสชันเป็นอย่างมาก
- จำนวนมาก (128 บิต) แทบไม่มีโอกาสเลยที่จะพบมันด้วยกำลังดุร้าย ดังนั้นผู้โจมตีจึงเหลือตัวเลือกดังต่อไปนี้:มีโทรจันในคอมพิวเตอร์ของผู้ใช้ที่ขโมยหมายเลขเซสชัน
- ผู้โจมตีสกัดกั้นการรับส่งข้อมูลระหว่างคอมพิวเตอร์ของผู้ใช้และเซิร์ฟเวอร์ แน่นอนว่ามีการป้องกัน (เข้ารหัส)
โปรโตคอล SSL
แต่ไม่ใช่ทุกคนที่ใช้มัน
- เพื่อนบ้านเข้าหาคอมพิวเตอร์ของผู้ใช้ของเราและขโมยหมายเลขเซสชัน
- สถานการณ์ดังกล่าวซึ่งโดยทั่วไปแล้วขึ้นอยู่กับความจริงที่ว่ามีคนขโมยบางสิ่งบางอย่างจากคนอื่นนั้นไม่อยู่ในความสามารถของโปรแกรมเมอร์ ผู้ดูแลระบบและผู้ใช้เองควรดูแลเรื่องนี้
อย่างไรก็ตาม PHP มักจะถูก "หลอก" ได้บ่อยครั้ง ลองดูจุดแฮ็กที่เป็นไปได้ในโปรแกรมการอนุญาตผู้ใช้: ไฟล์ authorize.php เป็นความพยายามในการเดารหัสผ่านโดยใช้สคริปต์ของบุคคลที่สาม"
ไฟล์ Secretplace.php เป็นความพยายามที่จะหลอกลวงโปรแกรมโดยการป้อนค่าของตัวแปร $logged_user ในแถบที่อยู่ของเบราว์เซอร์ เช่น:
"http://www.yoursite.ru/secretplace.php?เราจะไม่เขียนโค้ดจำนวนมากเพื่อบล็อกที่อยู่ IP ฯลฯ แต่เพียงตรวจสอบว่าคำขอมาจากที่ใด หรือค่อนข้างชัดเจนว่าคำขอนั้นมาจากหน้าใด หากเป็นหน้าใด ๆ จากไซต์ของเรา ทุกอย่างเรียบร้อยดี แต่ใน กรณีอื่น ๆ ทั้งหมดเราจะไม่ให้คุณเข้า มาปรับไฟล์ authorize.php กัน:
authorize.php V2 หน้า... header("ตำแหน่ง: secretplace.php"); ออก;ออก;
- จะกำจัด “รู” หมายเลข 2 ได้อย่างไร?สมมติว่าคุณมีเว็บไซต์ที่ทุกคนสามารถลงทะเบียนเพื่อโพสต์ในฟอรัมได้ โดยปกติแล้ว ผู้ใช้บางคนในฟอรัม (ผู้ดูแลระบบ ผู้ดูแล) มีโอกาสมากกว่าคนอื่นๆ เช่น พวกเขาสามารถลบข้อความจากผู้ใช้รายอื่นได้ คุณจัดเก็บระดับการเข้าถึงของผู้ใช้ในเซสชันในตัวแปร $user_status โดยที่ $user_status = 10 สอดคล้องกันการเข้าถึงแบบเต็ม ไปยังระบบ ผู้โจมตีที่เข้ามายังไซต์เพียงแค่ต้องลงทะเบียนด้วยวิธีปกติ จากนั้นจึงเพิ่มแถบที่อยู่ของเบราว์เซอร์ลงในแถบที่อยู่!
?user_status=10 - ดังนั้นฉันจึงเริ่มในฟอรัมของคุณผู้ดูแลระบบใหม่ โดยหลักการแล้ว ตัวแปรสคริปต์ใดๆ ก็ตามสามารถตั้งค่าได้แถบที่อยู่ เพียงเพิ่มหลังที่อยู่แบบเต็ม
ไปที่สคริปต์ เครื่องหมายคำถาม -และชื่อของตัวแปรพร้อมค่าของมัน มาแก้ไขโค้ดของเราเพื่อหลีกเลี่ยงสิ่งนี้:Secretplace.php V2
ตัวแปรไม่ได้ตั้งค่า($_SESSION["logged_user"]); // เปิดเซสชั่น session_start();/* คุณไม่สามารถไปที่หน้านี้ได้... หากชื่อผู้ใช้ไม่ได้ลงทะเบียน เราจะเปลี่ยนเส้นทางเขาไปที่หน้า index.php เพื่อเข้าสู่ระบบและรหัสผ่าน... ที่นี่คุณสามารถทำอะไรได้มากมายจริงๆ ตัวอย่างเช่น จำ IP ของผู้ใช้ และหลังจากพยายามเข้าถึงไฟล์ครั้งที่สามแล้ว ให้บล็อกมัน */ if(!isset($_SESSION["logged_user"]))( header("Location: index.php"); exit; ) ?>คุณอยู่ในเพจลับ!
- การใช้ฟังก์ชันนี้คุณสามารถกำหนดระยะเวลาที่เซสชันจะ "คงอยู่" ได้โดยการตั้งค่า unix_timestamp ซึ่งจะกำหนดเวลาที่ "สิ้นสุด" ของเซสชัน ตามค่าเริ่มต้น เซสชันจะ "ถ่ายทอดสด" จนกว่าไคลเอ็นต์จะปิดหน้าต่างเบราว์เซอร์
ผลลัพธ์กลไกเซสชันเป็นคุณสมบัติที่ค่อนข้างเรียบร้อย ?>ภาษาพีพีพี - เซสชันมีความเรียบง่ายและยืดหยุ่นในการใช้งานมาก อย่างไรก็ตาม มีความเป็นไปได้ที่บันทึกไว้เพียงเล็กน้อยเท่านั้น
เซสชัน PHP
// ตัวอย่างการทำงานกับเซสชัน session_start(); // หากคุณเพิ่งเยี่ยมชมไซต์ ให้รีเซ็ตตัวนับ ถ้า (!isset($_SESSION["count"])) $_SESSION["count"] = 0; //เพิ่มตัวนับในเซสชัน $_SESSION["นับ"] = $_SESSION["นับ"] + 1; -
เคาน์เตอร์
เวลาปิดเบราว์เซอร์ของคุณเพื่อรีเซ็ตตัวนับ
" target="_blank"> เปิดหน้าต่างเบราว์เซอร์ลูก
// ตัวอย่างง่ายๆ ของการใช้เซสชันโดยไม่มีคุกกี้ session_name("ทดสอบ"); session_start(); $_SESSION["นับ"] = @$_SESSION["นับ"] + 1; -
เคาน์เตอร์
คุณได้เปิดหน้านี้ในเซสชันเบราว์เซอร์ปัจจุบันของคุณเวลาปิดเบราว์เซอร์ของคุณเพื่อรีเซ็ตตัวนับนี้
?">คลิกที่นี่เพื่อรีเฟรชหน้า!
เซสชันช่วยให้คุณสร้างการเชื่อมต่อระหว่างผู้เยี่ยมชมและไซต์โดยใช้ รหัสเซสชัน.
ตัวแปรเซสชันและค่าของมันจะถูกเก็บไว้บนเซิร์ฟเวอร์เท่านั้น เฉพาะตัวระบุเซสชัน (สร้างแบบสุ่ม) เท่านั้นที่ถูกจัดเก็บไว้ในคอมพิวเตอร์ของผู้ใช้และเซิร์ฟเวอร์ ซึ่งช่วยให้เราสามารถสร้างการเชื่อมต่อระหว่างผู้ใช้และเซิร์ฟเวอร์ได้
รหัสเซสชันที่จัดเก็บไว้ในคอมพิวเตอร์ของผู้ใช้คือคุกกี้
คุกกี้ถูกจัดเก็บไว้ในเบราว์เซอร์ของผู้ใช้ และไฟล์ที่เกี่ยวข้องจะถูกสร้างขึ้นบนเซิร์ฟเวอร์ด้วย
สร้างเซสชัน
วิธีที่ง่ายที่สุดในการเปิดเซสชันคือการใช้ฟังก์ชัน session_start:
// เริ่มต้นเซสชัน session_start();
ฟังก์ชันนี้จะตรวจสอบว่ามีรหัสเซสชันอยู่หรือไม่ และหากไม่มี ก็จะสร้างขึ้นใหม่ หากมี ID เซสชันปัจจุบันอยู่แล้ว ตัวแปรเซสชันที่ลงทะเบียนไว้จะถูกโหลด
โครงสร้างนี้ (ต้องเรียกหนึ่งครั้งสำหรับแต่ละหน้า) จะต้องถูกเรียก ก่อนที่จะได้ข้อสรุปใดๆ(กฎนี้ยังใช้ได้กับ setcookie()) รวมถึงการเว้นวรรคด้วย
เมื่อมีการสร้างเซสชัน คุกกี้ต่อไปนี้จะถูกส่งไปยังเบราว์เซอร์:
PHP
echo "ชื่อเซสชัน: ".session_name() " รหัสเซสชัน: ".session_id(); // ชื่อเซสชัน: PHPSESSID รหัสเซสชัน: mceu820l02id3ds0vcvtgnht04สร้างตัวแปรเซสชัน
ตัวแปรเซสชันถูกสร้างขึ้นโดยการเพิ่มค่าให้กับอาร์เรย์ superglobal $_SESSION:
$_SESSION["นิค"] = $_POST["ชื่อ"];
การทำลายตัวแปรเซสชันและตัวเซสชันเอง
1. คุณสามารถลบตัวแปรเซสชันได้ดังนี้:
ยกเลิกการตั้งค่า($_SESSION["นิค"]);
วิธีนี้จะช่วยป้องกันการนำข้อมูลไปใช้ซ้ำ
แต่จะเป็นการดีกว่าถ้าล้างอาร์เรย์ $_SESSION (ลบตัวแปรเซสชันทั้งหมด):
//ล้างอาร์เรย์ $_SESSION $_SESSION = array();
2. คุณต้องทำสิ่งต่อไปนี้ด้วย:
ตั้งค่าคุกกี้เซสชันไม่ถูกต้อง:
ถ้า (isset($_COOKIE)) ( // session_name() - รับชื่อของเซสชันปัจจุบัน setcookie(session_name(), "", time()-86400, "/"); )
ชื่อเซสชันหมายถึงรหัสเซสชันในคุกกี้และ URL
3. ทำลาย (สิ้นสุด) เซสชัน
Session_destroy();
บัฟเฟอร์เอาต์พุต
หากคุณมีเอาต์พุตอยู่แล้ว คุณสามารถใช้ฟังก์ชัน ob_start() ได้ ฟังก์ชันนี้บัฟเฟอร์เอาต์พุต ตอนนี้เอาต์พุตจะไม่ถูกส่งไปยังเบราว์เซอร์ เว้นแต่คุณจะบังคับโดยใช้ฟังก์ชัน ob_end_flush()
"; unset($_SESSION["nick"]); if (isset($_COOKIE)) ( setcookie(session_name(), "", time()-86400, "/"); // เนื้อหาเซสชัน - สตริงว่าง ) // setcookie จะทำงานโดยไม่มีข้อผิดพลาด เนื่องจากเราเพิ่ง ob_end_flush(); // ส่งเอาต์พุตไปยังเบราว์เซอร์ session_destroy();
ในทางกลับกัน ไม่จำเป็นต้องใช้ฟังก์ชัน ob_end_flush() เสมอไป เนื่องจากตัวแปล PHP จะล้างบัฟเฟอร์โดยอัตโนมัติเมื่อสคริปต์ทำงาน
การสร้าง ID เซสชันใหม่
เพื่อความปลอดภัย แต่ละครั้งที่คุณเข้าสู่ระบบ คุณต้องสร้าง ID เซสชันใหม่ ข้อมูลในตัวแปรเซสชันจะถูกเก็บรักษาไว้ เฉพาะตัวระบุเซสชันเท่านั้นที่เปลี่ยนแปลง- อย่าลืมว่าข้อมูลเซสชันจะถูกเก็บไว้บนเว็บเซิร์ฟเวอร์เป็นข้อความในไฟล์ที่เกี่ยวข้อง หากต้องการสร้าง id ใหม่ ให้เรียก session_regenerate_id() และรีเฟรชหน้าปัจจุบันหรือเปลี่ยนเส้นทางผู้ใช้ไปยังหน้าอื่น
กลไกเซสชัน
ลดอายุการใช้งานเซสชัน
ตามค่าเริ่มต้น อายุการใช้งานเซสชันคือ 0 ซึ่งหมายความว่าเมื่อผู้ใช้ปิดหน้าต่างเบราว์เซอร์ เซสชันจะถูกทำลาย บางครั้งจำเป็นต้องยุติเซสชันของผู้ใช้เนื่องจากไม่มีการใช้งานในส่วนของเขา สิ่งนี้สามารถนำไปใช้ได้ด้วยวิธีต่อไปนี้ (ลองดูตัวอย่างการอนุญาต): เราสร้างตัวแปรและจัดเก็บเวลาการอนุญาตของผู้ใช้ไว้ ถ้าเราพยายามรีเฟรชเพจ เราจะเปรียบเทียบเวลาที่ไม่มีการใช้งาน และ หากเกิน เราจะออกจากระบบผู้ใช้และเปลี่ยนเส้นทางผู้ใช้ไปยังหน้าการอนุญาต
$_SESSION["start"] = เวลา(); // การประทับเวลาการให้สิทธิ์ผู้ใช้ $now = time(); // เวลาปัจจุบัน $time_limit = 1,000; // เวลาสูงสุดที่อนุญาตเมื่อผู้ใช้ไม่ใช้งานในหน่วยวินาที if ($ตอนนี้ > $_SESSION["start"] + $time_limit) ( echo "เวลาของคุณหมดอายุแล้ว"; //...... // และลบเซสชันและคุกกี้ของมัน) else ( $_SESSION["start " ] = time(); ) // ถ้าสั่งให้อัพเดต
จะทำให้เซสชั่นตลอดชีวิตเป็นนิรันดร์ได้อย่างไร?
เพื่อให้ไคลเอนต์ยังคงเข้าสู่ระบบอยู่เสมอ ไม่จำเป็นต้องตั้งค่าอายุการใช้งานของเซสชันให้เป็นนิรันดร์ เซสชันคือเซสชัน: เริ่มต้นเมื่อลูกค้ามาถึงและสิ้นสุดเมื่อลูกค้าออก
เมื่อไคลเอนต์กลับมาอีกครั้ง คุณต้องเริ่มเซสชันใหม่ แต่โหลดข้อมูลเกี่ยวกับไคลเอนต์ลงในนั้น โดยขึ้นอยู่กับคุกกี้เฉพาะของไคลเอนต์ ซึ่งได้รับการติดตั้งอย่างถาวรให้เขาเมื่อเขาเลือกกล่องกาเครื่องหมาย เช่น “จดจำฉันไว้” ".
การทำงานกับเซสชันเมื่อปิดใช้งานคุกกี้
หากตั้งค่า session.use_trans_sid เป็น 1 เมื่อปิดใช้งานคุกกี้ PHP จะส่ง PHPSESSID โดยใช้วิธี GET ในบรรทัดคำขอ
