โปรแกรมสร้างเลขสุ่ม – รวดเร็ว ฟรี และสุ่มอย่างแท้จริง

เครื่องกำเนิดตัวเลขสุ่มคืออะไร?

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

วลี "ตัวสร้างเลขสุ่ม" ครอบคลุมสองสิ่งที่แตกต่างกันโดยพื้นฐานซึ่งมักทำให้เกิดความสับสน: ตัวสร้างเลขสุ่มเทียม (PRNGs) ซึ่งใช้อัลกอริทึมแบบกำหนดได้เพื่อสร้างลำดับที่ดูเหมือนสุ่มเท่านั้น และ ตัวสร้างเลขสุ่มแท้ (TRNGs) ซึ่งดึงเอาเอนโทรปีทางกายภาพที่แท้จริงจากจักรวาลมาใช้ ประเภทที่สามคือ ตัวสร้างเลขสุ่มเทียมที่ปลอดภัยทางด้านการเข้ารหัส (CSPRNGs) ซึ่งอยู่ระหว่างสองประเภทนี้ — มีการทำงานแบบกำหนดได้ แต่ได้รับการออกแบบมาเพื่อให้การโจมตีที่ทำได้ด้วยคอมพิวเตอร์ไม่สามารถแยกแยะผลลัพธ์ของมันออกจากความสุ่มที่แท้จริงได้

เหตุใดเครื่องกำเนิดเลขสุ่มจึงมีความสำคัญ

ตัวสร้างเลขสุ่ม (RNG) เป็นโครงสร้างพื้นฐานที่สำคัญยิ่งในวิทยาศาสตร์ ความปลอดภัย และซอฟต์แวร์ในชีวิตประจำวัน หากปราศจากความสุ่มที่เชื่อถือได้ การเข้ารหัสสมัยใหม่ก็จะล้มเหลว: ทุกเซสชัน TLS ทุกข้อความที่เข้ารหัส ทุกลายเซ็นดิจิทัล ล้วนขึ้นอยู่กับกุญแจลับที่ต้องคาดเดาไม่ได้ คาสิโน ลอตเตอรี่ และเกมออนไลน์ต่างพึ่งพา RNG เพื่อความยุติธรรม การจำลองทางวิทยาศาสตร์ ตั้งแต่การจำลองสภาพภูมิอากาศไปจนถึงการค้นพบยา ล้วนใช้การสุ่มตัวอย่างเพื่อประมาณค่าคำตอบที่ไม่สามารถหาคำตอบได้ด้วยวิธีวิเคราะห์ การสุ่มตัวอย่างทางสถิติ การทดสอบ A/B การสร้างโลกในเกมแบบขั้นตอน และแม้แต่การเริ่มต้นน้ำหนักของโครงข่ายประสาทเทียม ล้วนต้องการเลขสุ่มคุณภาพสูง

ผลที่ตามมาจากการสุ่มที่ไม่ดีนั้นรุนแรงและมีการบันทึกไว้เป็นอย่างดี ในปี 2012 นักวิจัยค้นพบว่ากุญแจสาธารณะ RSA หลายล้านชุดบนอินเทอร์เน็ตมีตัวประกอบเฉพาะร่วมกัน เนื่องจากอุปกรณ์ที่สร้างกุญแจเหล่านั้นมีเอนโทรปีไม่เพียงพอในระหว่างการบูต ผู้โจมตีที่สามารถแยกตัวประกอบของจำนวนเฉพาะร่วมกันได้จะสามารถกู้คืนกุญแจส่วนตัวและถอดรหัสการสื่อสารทั้งหมดได้ ในปี 2010 เครื่องเล่นเกม Sony PlayStation 3 ถูกเจาะระบบเนื่องจากการใช้งาน ECDSA ของเครื่องนั้นใช้ค่า nonce "สุ่ม" เดียวกันซ้ำสำหรับทุกการลงลายมือชื่อ ซึ่งค่าที่ซ้ำกันเพียงค่าเดียวก็เพียงพอที่จะดึงกุญแจส่วนตัวออกมาได้โดยใช้พีชคณิต นี่ไม่ใช่กรณีพิเศษ แต่เป็นผลลัพธ์ที่คาดการณ์ได้จากการมองว่าการสุ่มเป็นปัญหาที่แก้ไขได้แล้ว

โดเมนการใช้งานหลัก

• การเข้ารหัสและการรักษาความปลอดภัย: การสร้างคีย์ เวกเตอร์เริ่มต้น ค่าสุ่ม (nonces) เกลือ (salts) โทเค็นเซสชัน และหมายเลขประจำใบรับรอง
• การจำลองและการสร้างแบบจำลอง: วิธีมอนเตคาร์โล, สมการเชิงอนุพันธ์เชิงสุ่ม, การจำลองฟิสิกส์อนุภาค, แบบจำลองทางระบาดวิทยา
• การเล่นเกมและการพนัน: การสับไพ่ การทอยลูกเต๋า ผลลัพธ์จากเครื่องสล็อต การสร้างด่านแบบสุ่ม ตารางการแจกไอเทม
• สถิติและการวิจัย: การสุ่มตัวอย่างแบบสุ่ม, การทดลองแบบสุ่มที่มีกลุ่มควบคุม, การบูตสแตรป, การแบ่งข้อมูลแบบครอสส์วาลิเดชัน
• ระบบกระจายศูนย์: การเลือกผู้นำ การกระจายโหลดพร้อมความผันผวน การหน่วงเวลาแบบทวีคูณพร้อมความล่าช้าแบบสุ่ม
• การเรียนรู้ของเครื่อง: การกำหนดค่าเริ่มต้นของน้ำหนัก, มาสก์ดรอปเอาต์, การเพิ่มข้อมูล, การไล่ระดับความชันแบบสุ่ม

วิธีการทำงานของเครื่องกำเนิดเลขสุ่มเทียม

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

เครื่องกำเนิดเชิงเส้นแบบคอนกรุเอทีฟ

ตระกูล PRNG ที่เก่าแก่และง่ายที่สุดใช้ความสัมพันธ์เวียนเกิด X _n+1 = (aX _n + c) mod m โดยที่ a, c และ m เป็นค่าคงที่ที่เลือกมาอย่างระมัดระวัง ฟังก์ชัน rand() ในไลบรารีมาตรฐานของภาษา C ในหลายๆ การใช้งานเป็นตัวสร้างตัวเลขสุ่มเชิงเส้น (LCG) LCG นั้นรวดเร็วและง่ายต่อการใช้งาน แต่มีจุดอ่อนร้ายแรงหลายประการ ได้แก่ บิตลำดับต่ำจะวนซ้ำด้วยช่วงเวลาสั้นๆ ช่วงเวลาของลำดับทั้งหมดมีค่าสูงสุดเพียง m และสถานะภายในสามารถกู้คืนได้ง่ายจากเอาต์พุตเพียงไม่กี่ตัว จึงเหมาะสำหรับการจำลองและการเล่นเกมอย่างง่ายที่ไม่มีข้อกำหนดด้านความปลอดภัย และไม่เหมาะสมอย่างยิ่งสำหรับสิ่งใดๆ ที่เกี่ยวข้องกับการเข้ารหัสลับ

เมอร์เซนน์ ทวิสเตอร์

Mersenne Twister (MT19937) ซึ่งเผยแพร่โดย Matsumoto และ Nishimura ในปี 1998 กลายเป็นตัวสร้างเลขสุ่มเทียม (PRNG) มาตรฐานใน Python, Ruby, R, PHP และภาษาอื่นๆ อีกมากมาย มันมีคาบการวนซ้ำ ^{2¹⁹⁹³⁷⁻¹} (ใหญ่มาก) ผ่านการทดสอบทางสถิติเกือบทั้งหมด และทำงานได้อย่างรวดเร็ว สถานะภายในของมันคือจำนวนเต็ม 32 บิตจำนวน 624 ตัว จุดอ่อนที่สำคัญคือ หากผู้โจมตีสังเกตผลลัพธ์ที่ต่อเนื่องกัน 624 ครั้ง พวกเขาสามารถสร้างสถานะภายในทั้งหมดขึ้นมาใหม่และทำนายผลลัพธ์ในอนาคตได้ทั้งหมด ดังนั้น Mersenne Twister จึงไม่เหมาะสมอย่างยิ่งสำหรับแอปพลิเคชันที่อ่อนไหวต่อความปลอดภัย แม้ว่าจะถูกนำไปใช้ในทางที่ผิดอย่างแพร่หลายในบทบาทนั้นก็ตาม

เครื่องกำเนิดตัวเลขสุ่มสมัยใหม่: Xoshiro, PCG และ SFC

ตัวสร้างเลขสุ่มเทียม (PRNG) ที่ไม่ใช้การเข้ารหัสซึ่งเป็นที่ยอมรับในปัจจุบัน ได้แก่ ตระกูล PCG (Permuted Congruential Generators), xoshiro256** และ SFC64 ตัวสร้างเหล่านี้มีขนาดเล็กกว่า เร็วกว่า และมีประสิทธิภาพทางสถิติเหนือกว่า Mersenne Twister โดยเฉพาะอย่างยิ่ง PCG มีประสิทธิภาพที่ยอดเยี่ยมบนชุดทดสอบ TestU01 BigCrush ซึ่งเป็นชุดทดสอบทางสถิติมาตรฐานที่เข้มงวดที่สุดสำหรับ PRNG ด้วยเหตุผลนี้ NumPy จึงเปลี่ยนตัวสร้างเริ่มต้นจาก Mersenne Twister เป็น PCG64 ในเวอร์ชัน 1.17

วิธีการทำงานของ PRNG ที่ปลอดภัยทางด้านการเข้ารหัส

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

ระบบปฏิบัติการสมัยใหม่มี CSPRNGs เป็นบริการหลัก Linux มี /dev/urandom และ syscall getrandom() ซึ่งทั้งสองอย่างดึงข้อมูลจากพูลเอนโทรปีของเคอร์เนลที่สร้างขึ้นจากเหตุการณ์ฮาร์ดแวร์ Windows มี BCryptGenRandom() macOS และ iOS ใช้ arc4random_buf() ซึ่งตั้งแต่ macOS 10.12 เป็นต้นมาได้รับการสนับสนุนโดย ChaCha20 โครงสร้างพื้นฐานที่ใช้ใน CSPRNGs ที่ใช้งานจริง ได้แก่ Hash_DRBG , HMAC_DRBG และ CTR_DRBG (ทั้งหมดได้รับการกำหนดมาตรฐานใน NIST SP 800-90A) รวมถึง ตัวสร้างที่ใช้ ChaCha20 ซึ่งใช้โดย BSD และ Linux รุ่นใหม่

วิธีการทำงานของเครื่องกำเนิดเลขสุ่มแท้จริง

TRNG (Triple Number Generator) ดึงเอาความสุ่มออกมาจากกระบวนการทางกายภาพที่ไม่สามารถคาดเดาได้อย่างแท้จริง ไม่ว่าจะเป็นเพราะเป็นกระบวนการทางกลศาสตร์ควอนตัมโดยพื้นฐาน หรือเพราะเกี่ยวข้องกับระบบคลาสสิกที่อลวนซึ่งไวต่อเงื่อนไขเริ่มต้นที่ไม่สามารถวัดได้

แหล่งกำเนิดเอนโทรปีทางกายภาพทั่วไป

• สัญญาณรบกวนจากความร้อน (สัญญาณรบกวนจอห์นสัน-ไนควิสต์): การเคลื่อนที่แบบสุ่มของอิเล็กตรอนในตัวต้านทานทำให้เกิดความผันผวนของแรงดันไฟฟ้า ซึ่งสามารถสุ่มตัวอย่างและแปลงเป็นสัญญาณดิจิทัลได้
• สัญญาณรบกวนแบบสุ่ม (Shot noise): การมาถึงแบบไม่ต่อเนื่องและสุ่มของโฟตอนหรืออิเล็กตรอนที่ตัวตรวจจับ ทำให้เกิดสัญญาณสุ่มที่สามารถวัดได้
• การสลายตัวของสารกัมมันตรังสี: จังหวะเวลาของการสลายตัวจากแหล่งกำเนิดกัมมันตรังสีนั้นเป็นแบบสุ่มเชิงควอนตัมอย่างแท้จริง RANDOM.ORG ใช้สัญญาณรบกวนคลื่นวิทยุในชั้นบรรยากาศ ซึ่งก็คาดเดาไม่ได้เช่นกัน
• แหล่งกำเนิดแสงควอนตัม: เวลาที่โฟตอนมาถึง ความผันผวนของสุญญากาศที่วัดได้ด้วยการตรวจจับแบบโฮโมไดน์ และตัวเลือกเส้นทางของตัวแยกแสง ล้วนเป็นแหล่งที่มาของความสุ่มแบบควอนตัมที่ได้รับการรับรอง
• เอนโทรปีของฮาร์ดแวร์บนอุปกรณ์สำหรับผู้บริโภค: ซีพียูสมัยใหม่มีคำสั่งสร้างเลขสุ่ม (RNG) เฉพาะทางฮาร์ดแวร์ RDRAND ของ Intel ใช้แหล่งกำเนิดสัญญาณรบกวนความร้อนบนชิปที่ปรับสภาพผ่าน AES-CBC-MAC ส่วนของ AMD ก็ทำงานในลักษณะเดียวกัน TrustZone ของ ARM มีแหล่งกำเนิดเอนโทรปีของฮาร์ดแวร์ที่ระบบปฏิบัติการสามารถเข้าถึงได้
• กลุ่มเอนโทรปีของระบบปฏิบัติการ: ลินุกซ์รวบรวมเอนโทรปีจากจังหวะเวลาของการขัดจังหวะ ความหน่วงของการอ่าน/เขียนดิสก์ เวลาที่แพ็กเก็ตเครือข่ายมาถึง และคำสั่ง RNG ของฮาร์ดแวร์ โดยผสมผสานสิ่งเหล่านี้ผ่านโครงสร้างการเข้ารหัสเพื่อสร้างกลุ่มเอนโทรปีของเคอร์เนล

ปัญหาการปรับสภาพ

สัญญาณรบกวนทางกายภาพดิบมักไม่กระจายตัวอย่างสม่ำเสมอ แหล่งกำเนิดสัญญาณรบกวนจากความร้อนอาจสร้างค่า 0 มากกว่าค่า 1 เล็กน้อยเนื่องจากความไม่สมมาตรของวงจร ดังนั้น TRNG จึงมีขั้นตอน การปรับสภาพ — โดยทั่วไปคือฟังก์ชันแฮชเข้ารหัสลับหรือฟังก์ชันตัวแยก — ที่บีบอัดตัวอย่างดิบให้เป็นเอาต์พุตที่สั้นลงและสม่ำเสมออย่างเห็นได้ชัด อัตราส่วนของบิตดิบที่ใช้ไปต่อบิตเอาต์พุตที่ผลิตได้เรียกว่า อัตราเอนโทรปีขั้นต่ำ และ TRNG ที่ออกแบบมาอย่างดีจะกำหนดลักษณะอัตรานี้อย่างละเอียดถี่ถ้วน มาตรฐาน NIST SP 800-90B กำหนดข้อกำหนดการทดสอบและการตรวจสอบความถูกต้องสำหรับแหล่งกำเนิดเอนโทรปีที่ใช้ในระบบของรัฐบาลกลาง

การเปรียบเทียบ PRNG, CSPRNG และ TRNG

คุณสมบัติ	PRNG	ซีเอสพีอาร์เอ็นจี	TRNG
กำหนดได้แน่นอน	ใช่	ใช่ (หลังจากเพาะเชื้อแล้ว)	เลขที่
สามารถขยายพันธุ์ได้ตั้งแต่เมล็ด	ใช่	ใช่	เลขที่
ผ่านการทดสอบทางสถิติ	โดยปกติ	ใช่	ใช่ (หลังจากปรับสภาพแล้ว)
ปลอดภัยจากการคาดการณ์	เลขที่	ใช่	ใช่
ความเร็ว	เร็วมาก	เร็ว	ช้า (เนื่องจากข้อจำกัดด้านฮาร์ดแวร์)
ต้องใช้เอนโทรปีของฮาร์ดแวร์	ใช้สำหรับเพาะเมล็ดเท่านั้น	ใช้สำหรับเพาะเมล็ดเท่านั้น	เสมอ
ตัวอย่างการใช้งานทั่วไป	การจำลอง เกม การสุ่มตัวอย่าง	การสร้างกุญแจ โทเค็น การเข้ารหัสลับ	กุญแจที่มีความน่าเชื่อถือสูง, กฎระเบียบการพนัน, การวิจัย

นิยามทางสถิติของความสุ่ม

ความสุ่มไม่ใช่คุณสมบัติแบบไบนารี่ — มันมีอยู่บนสเปกตรัม และมาตรฐานที่เหมาะสมนั้นขึ้นอยู่กับการใช้งานโดยสิ้นเชิง ลำดับจะถือว่าสุ่มสำหรับวัตถุประสงค์ที่กำหนด หากไม่มีการทดสอบใดที่เกี่ยวข้องกับวัตถุประสงค์นั้นสามารถแยกแยะความแตกต่างระหว่างลำดับนั้นกับลำดับสุ่มในอุดมคติทางทฤษฎีได้ NIST เผยแพร่ชุดทดสอบทางสถิติ (SP 800-22) ซึ่งครอบคลุมการทดสอบสิบห้ารายการ รวมถึงการวิเคราะห์ความถี่ การทดสอบการทำงาน การวิเคราะห์สเปกตรัม และความซับซ้อนเชิงเส้น ชุดทดสอบ BigCrush ของไลบรารี TestU01 ซึ่งพัฒนาโดยมหาวิทยาลัยมอนทรีออล มีความต้องการสูงกว่า โดยใช้การทดสอบที่แตกต่างกัน 106 รายการ เครื่องกำเนิดข้อมูลที่ล้มเหลวในการทดสอบ BigCrush นั้นไม่เหมาะสมสำหรับงานจำลองที่จริงจัง ไม่ว่ามันจะทำงานได้เร็วแค่ไหนก็ตาม

ควรระบุให้ชัดเจนว่าความสุ่มไม่ได้หมายถึงอะไรบ้าง ลำดับเช่น 1, 2, 3, 4, 5 ไม่ถือว่าเป็นลำดับสุ่ม แม้ว่าแต่ละตัวเลขจะมีโอกาสเกิดขึ้นเท่าๆ กันก็ตาม — รูปแบบนั้นสามารถคาดเดาได้ ในทางกลับกัน ลำดับอาจดูเหมือนมีรูปแบบเฉพาะที่เกิดขึ้นโดยบังเอิญ (เช่น การได้หัวสามครั้งติดต่อกันจากเหรียญที่ยุติธรรม) โดยที่ไม่ได้หมายความว่าไม่เป็นลำดับสุ่ม ความสุ่มเป็นคุณสมบัติของกระบวนการสร้าง ไม่ใช่คุณสมบัติของลำดับผลลัพธ์ใดๆ ที่พิจารณาแยกต่างหาก

วิธีการทำงานของเครื่องกำเนิดเลขสุ่ม: กลไกหลักและกลยุทธ์เชิงปฏิบัติ

เครื่องกำเนิดเลขสุ่มแบ่งออกเป็นสองประเภทพื้นฐาน ได้แก่ เครื่องกำเนิดเลขสุ่มเทียม (PRNGs) ซึ่งใช้อัลกอริทึมแบบกำหนดได้โดยกำหนดค่าเริ่มต้น และเครื่องกำเนิดเลขสุ่มแท้ (TRNGs) ซึ่งได้มาจากเอนโทรปีของปรากฏการณ์ทางกายภาพ การเลือกประเภทที่เหมาะสม การกำหนดค่าเริ่มต้นอย่างถูกต้อง และการนำไปใช้กับกรณีการใช้งานเฉพาะของคุณจะเป็นตัวกำหนดว่าผลลัพธ์ของคุณมีความถูกต้องทางสถิติ ปลอดภัยทางด้านการเข้ารหัส หรือคาดเดาได้ง่ายจนเป็นอันตรายหรือไม่

กลยุทธ์ทีละขั้นตอนสำหรับการเลือกและการใช้ตัวสร้างเลขสุ่ม (RNG)

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

ขั้นตอนที่ 1: กำหนดข้อกำหนดด้านความสุ่มของคุณ

ก่อนที่จะใช้เครื่องมือหรือไลบรารีใดๆ ให้ถามตัวเองสามคำถามนี้:

• ความคาดเดาได้สำคัญหรือไม่? หากการที่ฝ่ายตรงข้ามเดาตัวเลขของคุณแล้วก่อให้เกิดอันตราย — ในด้านการเข้ารหัส การพนัน ลอตเตอรี่ หรือโทเค็นความปลอดภัย — คุณจำเป็นต้องใช้ความสุ่มระดับการเข้ารหัส หากคุณกำลังทำการจำลองทางฟิสิกส์หรือสุ่มลำดับเพลง ตัวสร้างตัวเลขสุ่มเทียมคุณภาพสูงก็เพียงพอแล้ว
• คุณต้องการตัวเลขกี่ตัว? ตัวสร้างตัวเลขสุ่มบางตัวมีคาบเวลาที่จำกัด ตัวสร้างตัวเลขสุ่ม Mersenne Twister ซึ่งใช้กันอย่างแพร่หลายในโมดูล random ของ Python และในหลายภาษา มีคาบเวลาเท่ากับ ^{2¹⁹⁹³⁷⁻¹} ซึ่งถือว่าใหญ่มากในเชิงดาราศาสตร์สำหรับวัตถุประสงค์ส่วนใหญ่ แต่ก็ยังเป็นค่าที่จำกัดและแน่นอน
• คุณต้องการความสามารถในการทำซ้ำได้หรือไม่? การทดลองทางวิทยาศาสตร์และการสร้างเกมแบบขั้นตอนมักต้องการลำดับที่เหมือนกันทุกประการในการสร้างซ้ำ ตัวสร้างตัวเลขสุ่มแบบมีค่าเริ่มต้น (Seeded PRNG) ช่วยให้คุณทำเช่นนั้นได้ แต่ตัวสร้างตัวเลขสุ่มแบบมีเงื่อนไข (TRNG) ทำไม่ได้

ขั้นตอนที่ 2: เลือกประเภทเครื่องกำเนิดไฟฟ้าที่เหมาะสม

กรณีศึกษา	เครื่องกำเนิดไฟฟ้าที่แนะนำ	ตัวอย่าง
กุญแจเข้ารหัส, รหัสผ่าน, โทเค็น	CSPRNG (ตัวสร้างเลขสุ่มที่มีความปลอดภัยทางด้านการเข้ารหัส)	โมดูล secrets (Python), crypto.randomBytes (Node.js), /dev/urandom (Linux)
การจำลอง, สถิติ, การเรียนรู้ของเครื่องจักร	PRNG คุณภาพสูง	เมอร์เซน ทวิสเตอร์, PCG64, xoshiro256**
ลอตเตอรี่, การจับรางวัลที่ตรวจสอบได้	TRNG หรือ RNG ฮาร์ดแวร์ที่ได้รับการรับรอง	RANDOM.ORG, โมดูลรักษาความปลอดภัยฮาร์ดแวร์ (HSM)
เกม การสร้างตามขั้นตอน	PRNG ที่มีเมล็ดพันธุ์	เมอร์เซนน์ ทวิสเตอร์, LCG ที่มีค่าคงที่ที่ดี
ระบบฝังตัวแบบเรียลไทม์	ตัวสร้างเลขสุ่มฮาร์ดแวร์บนชิป	Intel RDRAND, ARM TrueRNG

ขั้นตอนที่ 3: กำหนดค่าเริ่มต้นให้กับเครื่องกำเนิดข้อมูลอย่างถูกต้อง

ค่าเริ่มต้น (seed) คือจุดอ่อนสำคัญที่ทำให้ระบบสร้างตัวเลขสุ่มเทียม (PRNG) ส่วนใหญ่ล้มเหลว ค่าเริ่มต้นที่อ่อนแอหรือคาดเดาได้ง่ายจะทำให้ระบบรักษาความปลอดภัยของ PRNG พังทลายลง ไม่ว่าอัลกอริทึมจะซับซ้อนเพียงใดก็ตาม

• ใช้ seed ที่มีเอนโทรปีสูง พูล เอนโทรปีของระบบปฏิบัติการ ( /dev/urandom บน Unix, CryptGenRandom บน Windows) จะรวมเหตุการณ์จากฮาร์ดแวร์ — จังหวะการกดแป้นพิมพ์ การขัดจังหวะของดิสก์ การมาถึงของแพ็กเก็ตเครือข่าย — เพื่อสร้าง seed ที่แทบเป็นไปไม่ได้ที่จะคาดเดาได้
• ห้ามใช้เวลาเริ่มต้นจากนาฬิการะบบเพียงอย่างเดียวเด็ดขาด ผู้โจมตีที่รู้เวลาโดยประมาณที่โปรแกรมของคุณเริ่มต้น สามารถใช้การโจมตีแบบ Brute-force เพื่อหาค่าเริ่มต้นที่อิงตามเวลาได้ภายในไม่กี่วินาที ช่องโหว่นี้ถูกนำไปใช้ในการโจมตีเว็บไซต์โป๊กเกอร์ออนไลน์และระบบลอตเตอรี่ในโลกแห่งความเป็นจริงแล้ว
• ห้ามกำหนดค่า seed แบบตายตัวในโค้ดที่ใช้ในการผลิตเด็ดขาด ค่า seed ที่ตายตัวจะทำให้ได้ลำดับผลลัพธ์เหมือนเดิมทุกครั้งที่รัน ซึ่งมีประโยชน์สำหรับการทดสอบ แต่เป็นอันตรายอย่างยิ่งต่อความปลอดภัย
• ควรเติมค่าเอนโทรปีใหม่เป็นระยะในแอปพลิเคชันที่ทำงานต่อเนื่องเป็นเวลานาน หากแอปพลิเคชันของคุณทำงานเป็นเวลาหลายวันหรือหลายสัปดาห์ การเติมค่าเอนโทรปีใหม่เป็นระยะจะช่วยป้องกันไม่ให้ตัวสร้างค่าเอนโทรปีวนกลับไปสู่สถานะที่คาดเดาได้

ขั้นตอนที่ 4: นำเครื่องมือสร้างโค้ดไปใช้กับงานเฉพาะของคุณ

การสร้างเลขสุ่มแบบดิบๆ นั้นแทบจะไม่ใช่เป้าหมายสุดท้ายเสมอไป การนำไปใช้งานจริง เช่น การสุ่มตัวอย่าง การสับเปลี่ยน การกำหนดช่วงค่า ล้วนมีข้อผิดพลาดของตัวเอง

การสร้างตัวเลขในช่วงที่กำหนด

วิธีการแบบง่ายๆ ที่ใช้ตัวดำเนินการโมดูลัส ( rand() % N ) ทำให้เกิดอคติของโมดูลัส หากช่วงเอาต์พุตของตัวสร้างไม่สามารถหารลงตัวด้วย N ได้ ค่าบางค่าจะปรากฏบ่อยกว่าค่าอื่นๆ ตัวอย่างเช่น หากตัวสร้างของคุณสร้างค่าตั้งแต่ 0 ถึง 32767 และคุณต้องการตัวเลขตั้งแต่ 0 ถึง 99 ค่า 0–67 จะปรากฏบ่อยกว่าค่า 68–99 เล็กน้อย เนื่องจาก 32768 หารด้วย 100 ไม่ลงตัว

• ใช้การสุ่มตัวอย่างแบบปฏิเสธ (rejection sampling) ทิ้งค่าที่อยู่ในส่วนหางที่ไม่เอนเอียง แล้วสุ่มตัวอย่างใหม่ ไลบรารีมาตรฐานที่มีการใช้งานอย่างดีส่วนใหญ่จะทำเช่นนี้โดยอัตโนมัติ
• ใช้ฟังก์ชันช่วงในตัว ฟังก์ชัน random.randint(a, b) ของ Python, ThreadLocalRandom.nextInt(origin, bound) ของ Java และฟังก์ชันที่คล้ายกันจะจัดการค่าไบแอสภายในให้เอง
• สำหรับการใช้งานด้านการเข้ารหัส ให้ใช้โมดูล secrets ใน Python หรือโมดูลที่เทียบเท่า ซึ่งจะทำการเลือกช่วงที่ไม่ลำเอียงโดยค่าเริ่มต้น

การสลับลำดับรายการอย่างยุติธรรม

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

1. เริ่มต้นที่ดัชนีสุดท้าย i = n−1
2. เลือกดัชนีสุ่ม j โดยที่ 0 ≤ j ≤ i
3. สลับตำแหน่งองค์ประกอบที่ตำแหน่ง i และ j
4. ลดค่า i ลงทีละน้อยและทำซ้ำจนกว่า i จะเท่ากับ 0

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

การสุ่มตัวอย่างโดยไม่ใส่คืน

เมื่อคุณต้องการค่าที่ไม่ซ้ำกัน k ค่าจากประชากร n ค่า การสุ่มและกำจัดค่าซ้ำนั้นไม่มีประสิทธิภาพ ควรใช้การสุ่มตัวอย่างแบบ Reservoir Sampling สำหรับชุดข้อมูลขนาดใหญ่หรือแบบสตรีมมิ่ง หรือใช้ Fisher-Yates กับสำเนาของประชากรสำหรับชุดข้อมูลขนาดเล็ก random.sample(population, k) ของ Python ทำงานนี้ได้อย่างถูกต้องและมีประสิทธิภาพ

ขั้นตอนที่ 5: ทดสอบคุณภาพกระแสไฟฟ้าขาออกของเครื่องกำเนิดไฟฟ้าของคุณ

แม้แต่ตัวสร้างเลขสุ่ม (RNG) ที่ได้รับการออกแบบมาอย่างถูกต้องก็อาจล้มเหลวได้ในบางแอปพลิเคชัน หากคุณสมบัติทางสถิติไม่ตรงกับสิ่งที่แอปพลิเคชันต้องการ ชุดทดสอบมาตรฐานสามารถตรวจจับข้อบกพร่องส่วนใหญ่ได้

• TestU01 (BigCrush): ชุดทดสอบทางสถิติที่เข้มงวดที่สุดสำหรับ PRNG (ตัวสร้างตัวเลขสุ่มเทียม) มันใช้การทดสอบหลายร้อยรายการและสามารถตรวจจับความสัมพันธ์ที่ละเอียดอ่อนซึ่งการทดสอบแบบง่ายๆ ตรวจไม่พบ ตัวสร้างตัวเลขสุ่มรุ่นเก่าหลายตัว รวมถึง LCG บางรุ่น ไม่ผ่านการทดสอบ BigCrush
• Diehard / Dieharder: ชุดการทดสอบทางสถิติที่ใช้กันอย่างแพร่หลาย ซึ่งพัฒนาขึ้นครั้งแรกโดย George Marsaglia Dieharder คือเวอร์ชันที่ได้รับการปรับปรุงและขยายเพิ่มเติม
• NIST SP 800-22: ชุดทดสอบมาตรฐานสำหรับตัวสร้างเลขสุ่มทางคริปโตเคอร์เรนซี ซึ่งเป็นข้อกำหนดสำหรับการรับรอง FIPS โดยจะทดสอบความถี่ จำนวนรอบ คุณสมบัติทางสเปกตรัม และอื่นๆ
• PractRand: มีประสิทธิภาพดีเป็นพิเศษในการตรวจจับความผิดพลาดในเครื่องกำเนิดไฟฟ้าที่มีช่วงเวลาสั้นหรือมีการกระจายตัวไม่ดี

ข้อผิดพลาดทั่วไปที่ควรหลีกเลี่ยง

ความล้มเหลวของระบบสร้างตัวเลขสุ่ม (RNG) ในระบบการผลิตส่วนใหญ่เกิดจากข้อผิดพลาดที่เกิดขึ้นซ้ำๆ เพียงไม่กี่อย่าง การตรวจพบข้อผิดพลาดเหล่านี้ล่วงหน้าจะช่วยป้องกันช่องโหว่และความผิดพลาดทางสถิติส่วนใหญ่ในโลกแห่งความเป็นจริงได้

ข้อผิดพลาดที่ 1: การใช้ Math.random() หรือฟังก์ชันที่เทียบเท่าเพื่อความปลอดภัย

Math.random() ของ JavaScript, โมดูล random ของ Python (ไม่ใช่ secrets ), rand() ของ PHP และฟังก์ชันอเนกประสงค์อื่นๆ ที่คล้ายกันนั้น มีการระบุไว้อย่างชัดเจนว่าไม่เหมาะสมสำหรับการใช้งานทางด้านการเข้ารหัสลับ เนื่องจากฟังก์ชันเหล่านี้ให้ความสำคัญกับความเร็วมากกว่าความไม่แน่นอน ผู้โจมตีที่สังเกตค่าเอาต์พุตได้มากพอ สามารถสร้างสถานะภายในของ Mersenne Twister ขึ้นมาใหม่ได้ด้วยเอาต์พุต 32 บิตที่ต่อเนื่องกันเพียง 624 ค่า จากนั้นก็สามารถทำนายค่าในอนาคตทั้งหมดได้ การโจมตีแบบนี้ได้รับการสาธิตให้เห็นแล้วบนแพลตฟอร์มการพนันออนไลน์จริง

ข้อผิดพลาดที่ 2: การใช้ Seed เดียวกันซ้ำในหลายๆ เซสชัน

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

ข้อผิดพลาดที่ 3: สร้างบิตน้อยเกินไปสำหรับเอนโทรปีที่ต้องการ

รหัส PIN 6 หลักมีเอนโทรปีประมาณ 20 บิต UUID v4 มี 122 บิต กุญแจเข้ารหัสต้องมีอย่างน้อย 128 บิตสำหรับการเข้ารหัสแบบสมมาตร และ 256 บิตสำหรับการรักษาความปลอดภัยในระยะยาวเพื่อป้องกันฮาร์ดแวร์ในอนาคต การสร้างโทเค็นขนาดสั้นและสมมติว่าไม่สามารถเดาได้นั้นเป็นข้อบกพร่องเชิงโครงสร้าง ไม่ใช่รายละเอียดการใช้งาน

ข้อผิดพลาดที่ 4: การละเลยพฤติกรรมเฉพาะของแต่ละแพลตฟอร์ม

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

ข้อผิดพลาดที่ 5: การถือว่าผลลัพธ์ที่สับเปลี่ยนแล้วเป็นแบบสุ่มอย่างสม่ำเสมอโดยไม่ตรวจสอบ

หากตัวสร้างเลขสุ่ม (RNG) พื้นฐานมีคาบเวลาสั้นกว่าจำนวนการเรียงสับเปลี่ยนที่เป็นไปได้ของชุดข้อมูลของคุณ การเรียงสับเปลี่ยนทั้งหมดจะไม่สามารถเกิดขึ้นได้ ตัวอย่างเช่น สำรับไพ่มาตรฐาน 52 ใบ มีลำดับที่เป็นไปได้ 52! ≈ ^2,226 แบบ ตัวสร้างเลขสุ่มที่มีค่าเริ่มต้น 32 บิต สามารถสร้างลำดับที่แตกต่างกันได้มากที่สุด ^2³² ≈ 4 พันล้านลำดับ ซึ่งเป็นเพียงเศษเสี้ยวเล็กน้อยของการสับไพ่ที่เป็นไปได้ทั้งหมด สำหรับเกมไพ่ที่มีเดิมพันสูง นี่คือจุดอ่อนที่ชัดเจนและสามารถใช้ประโยชน์ได้

ข้อผิดพลาดที่ 6: การเข้าใจผิดว่าความเป็นอิสระคือความสม่ำเสมอ

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

กลยุทธ์เชิงปฏิบัติโดยใช้ภาษาโปรแกรม

ไพธอน

• ใช้ secrets.token_bytes(n) , secrets.token_hex(n) หรือ secrets.randbelow(n) สำหรับค่าที่มีความอ่อนไหวต่อความปลอดภัยใดๆ
• ใช้ random.SystemRandom() แทน random.Random() ได้โดยตรงเมื่อคุณต้องการอินเทอร์เฟซมาตรฐานที่อิงตามเอนโทรปีของระบบปฏิบัติการ
• สำหรับงานคำนวณเชิงตัวเลข ให้ใช้ numpy.random.default_rng() ซึ่งค่าเริ่มต้นจะเป็นตัวสร้างเลขสุ่ม PCG64 ซึ่งเป็นตัวสร้างเลขสุ่มคุณภาพสูงที่ทันสมัยและผ่านการทดสอบ BigCrush แล้ว

JavaScript / Node.js

• เพื่อความปลอดภัยทุกประการ ให้ใช้ crypto.randomBytes(n) หรือ crypto.getRandomValues() (Web Crypto API ในเบราว์เซอร์)
• ห้ามใช้ Math.random() สำหรับโทเค็น รหัสประจำตัว หรือสิ่งใดก็ตามที่ผู้ไม่หวังดีอาจพยายามคาดเดา

ชวา

• ใช้ java.security.SecureRandom สำหรับวัตถุประสงค์ด้านการเข้ารหัสลับ สร้างอินสแตนซ์เพียงครั้งเดียวและนำอินสแตนซ์นั้นกลับมาใช้ใหม่ได้ — การสร้างอินสแตนซ์นั้นมีค่าใช้จ่ายสูง
• ใช้ ThreadLocalRandom สำหรับแอปพลิเคชันที่ไม่เน้นความปลอดภัยและต้องการปริมาณงานสูงในสภาพแวดล้อมแบบมัลติเธรด
• ควรหลีกเลี่ยงการใช้ java.util.Random ในบริบทการทำงานพร้อมกัน เพราะมันใช้ seed ร่วมกัน ซึ่งอาจทำให้เกิดการชนกันภายใต้การแย่งชิงทรัพยากร

ซี / ซี++

• หลีกเลี่ยงการใช้ rand() จากไลบรารีมาตรฐานของภาษา C เพราะเป็นฟังก์ชันที่ขึ้นอยู่กับการใช้งานของแต่ละระบบ มักเป็น LCG ที่อ่อนแอ และไม่ปลอดภัยต่อการใช้งานแบบมัลติเธรด
• ใช้ std::mt19937 จาก <random> ที่กำหนดค่าเริ่มต้นด้วย std::random_device สำหรับการใช้งานทั่วไป
• สำหรับการใช้งานด้านการเข้ารหัส ให้เรียกใช้ฟังก์ชันพื้นฐานของระบบปฏิบัติการโดยตรง: getrandom() บน Linux, BCryptGenRandom บน Windows

เครื่องมือ ซอฟต์แวร์ และระบบอัตโนมัติสำหรับการสร้างเลขสุ่ม

เครื่องมือสร้างเลขสุ่มที่ใช้กันอย่างแพร่หลายมีตั้งแต่บริการบนเว็บเบราว์เซอร์ เช่น RANDOM.ORG (ซึ่งดึงเอนโทรปีจากเสียงรบกวนในบรรยากาศ) ไปจนถึงไลบรารีการเข้ารหัสที่สร้างขึ้นในภาษาโปรแกรมหลักทุกภาษา การเลือกเครื่องมือที่เหมาะสมขึ้นอยู่กับกรณีการใช้งานของคุณ: การจำลองทางสถิติต้องการความเร็วและคุณภาพทางสถิติ แอปพลิเคชันด้านความปลอดภัยต้องการความไม่แน่นอนในการเข้ารหัส และการทดลองทางกายภาพต้องการความสุ่มจากฮาร์ดแวร์อย่างแท้จริง

เครื่องมือสร้างตัวเลขสุ่มแบบใช้งานผ่านเว็บเบราว์เซอร์และออนไลน์

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

• RANDOM.ORG — ใช้สัญญาณรบกวนคลื่นวิทยุในชั้นบรรยากาศเป็นแหล่งกำเนิดเอนโทรปีที่แท้จริง มีตัวสร้างเลขจำนวนเต็ม ตัวสับเปลี่ยนลำดับ ตัวสร้างเลขเกาส์เซียน และ API แบบจำกัดโควต้าสำหรับการเข้าถึงแบบโปรแกรม
• ระบบสร้างเลขสุ่มในตัวของ Google — การค้นหา "เลขสุ่มระหว่าง 1 ถึง 100" ใน Google จะให้ผลลัพธ์ทันทีโดยใช้ตัวสร้างเลขสุ่มเทียม (PRNG) ที่สร้างขึ้นจากเอนโทรปีของระบบ
• เครื่องมือวงล้อเลือกหมายเลข — อินเทอร์เฟซวงล้อหมุนแบบเห็นภาพ ซึ่งใช้ JavaScript Math.random() อยู่เบื้องหลัง เหมาะสำหรับการเลือกหมายเลขในห้องเรียนหรือรูปแบบรายการเกมโชว์
• การสำรวจความคิดเห็นแบบไม่เป็นทางการและวงล้อชื่อ — ผสานรวมรายชื่อที่ป้อนเข้ามากับการสุ่มเลือกสำหรับการจัดทีม การจับรางวัล และการตัดสินใจของกลุ่ม

ข้อจำกัดที่สำคัญของเครื่องมือในเบราว์เซอร์ส่วนใหญ่คือ พวกมันอาศัยฟังก์ชัน Math.random() ของ JavaScript ซึ่งเป็นตัวสร้างเลขสุ่มเทียม (PRNG) และไม่มีความปลอดภัยทางด้านการเข้ารหัส สำหรับสิ่งใดก็ตามที่เกี่ยวข้องกับความปลอดภัย โทเค็น หรือการตัดสินใจทางการเงิน ควรใช้เครื่องมือหรือไลบรารีการเข้ารหัสเฉพาะทางแทน

ไลบรารีภาษาโปรแกรมและฟังก์ชันในตัว

ภาษาโปรแกรมหลักทุกภาษามีโมดูลสร้างตัวเลขสุ่ม (RNG) อย่างน้อยหนึ่งโมดูล ตารางด้านล่างสรุปตัวเลือกที่ใช้กันทั่วไปและระดับความปลอดภัย:

ภาษา	PRNG มาตรฐาน	ตัวสร้างเลขสุ่มทางคริปโต	หมายเหตุ
ไพธอน	สุ่ม (Mersenne Twister)	ความลับ, os.urandom()	ใช้รหัสลับสำหรับโทเค็น รหัสผ่าน และกุญแจ
โค้ด JavaScript	คณิตศาสตร์สุ่ม()	คริปโต.getRandomValues()	Web Crypto API สามารถใช้งานได้ในเบราว์เซอร์สมัยใหม่ทุกตัว
ชวา	java.util.สุ่ม	java.security.SecureRandom	SecureRandom จะบล็อกข้อมูลจนกว่าจะมีเอนโทรปีเพียงพอ
ซี / ซี++	rand() (ควรหลีกเลี่ยงในการใช้งานจริง)	คำสั่ง RDRAND บน /dev/urandom	ฟังก์ชัน rand() นั้นอ่อนแอ ควรใช้เอนโทรปีระดับระบบปฏิบัติการสำหรับงานที่ต้องการความแม่นยำสูงกว่า
ไป	คณิตศาสตร์/แรนด์	คริปโต/แรนด์	การเข้ารหัส/สุ่มจะอ่านค่าจาก CSPRNG ของระบบปฏิบัติการโดยตรง
ทับทิม	สุ่ม (ตาม MT)	เซฟแรนดอม	SecureRandom ห่อหุ้ม OpenSSL หรือ /dev/urandom
พีพี	rand(), mt_rand()	random_bytes(), random_int()	random_int() ใช้ CSPRNG เป็นตัวสร้างตัวเลขสุ่มเทียม (CSPRNG) ตั้งแต่ PHP 7 เป็นต้นมา

อุปกรณ์สร้างตัวเลขสุ่มแบบฮาร์ดแวร์

สำหรับแอปพลิเคชันที่ต้องการเอนโทรปีคุณภาพสูงสุด เช่น การสร้างคีย์สำหรับหน่วยงานออกใบรับรอง โมดูลรักษาความปลอดภัยฮาร์ดแวร์ (HSM) หรือเครื่องมือทางวิทยาศาสตร์ มีเครื่องกำเนิดเลขสุ่มฮาร์ดแวร์เฉพาะ (HRNG) ให้เลือกใช้:

• Intel RDRAND / RDSEED — คำสั่งระดับ CPU ที่ใช้สุ่มตัวอย่างสัญญาณรบกวนความร้อนจากวงจรภายในชิป มีให้ใช้งานในโปรเซสเซอร์ x86 รุ่นใหม่ส่วนใหญ่ตั้งแต่ Ivy Bridge (2012) เป็นต้นมา
• อุปกรณ์ สร้างเลขสุ่มแบบ USB โดยเฉพาะ — อุปกรณ์อย่างเช่น OneRNG หรือ TrueRNG จะเสียบเข้ากับพอร์ต USB และส่งค่าเอนโทรปีเข้าสู่พูลของระบบปฏิบัติการผ่านทาง /dev/random หรือ /dev/urandom บน Linux
• HSM (Hardware Security Modules) — อุปกรณ์ระดับองค์กรจากผู้จำหน่าย เช่น Thales, Entrust และ AWS CloudHSM ที่สร้างและจัดเก็บคีย์เข้ารหัสโดยใช้แหล่งเอนโทรปีฮาร์ดแวร์ที่ได้รับการรับรอง
• บริการ Quantum RNG — API บนคลาวด์จาก ID Quantique และ ANU (มหาวิทยาลัยแห่งชาติออสเตรเลีย) ให้บิตสุ่มที่ได้มาจากความผันผวนของสุญญากาศควอนตัม ซึ่งให้ผลลัพธ์ที่ไม่สามารถคาดเดาได้อย่างแน่นอน

ระบบอัตโนมัติและการบูรณาการเวิร์กโฟลว์

การสร้างเลขสุ่มโดยอัตโนมัติภายในเวิร์กโฟลว์ขนาดใหญ่ เช่น กระบวนการทดสอบ A/B การจำลองมอนเตคาร์โล การจับฉลากตามกำหนดเวลา หรือการสุ่มตัวอย่างการตรวจสอบ มักใช้แนวทางใดแนวทางหนึ่งจากสามแนวทางดังต่อไปนี้:

1. การผสานรวม API — RANDOM.ORG มี API แบบ JSON-RPC ที่ส่งคืนค่าจำนวนเต็มสุ่ม ลำดับ สตริง และ UUID ที่แท้จริง การร้องขอที่ผ่านการตรวจสอบสิทธิ์จะช่วยให้สามารถใช้โควต้าที่สูงขึ้นและค่าสุ่มที่มีลายเซ็นพร้อมใบรับรองความถูกต้องที่ตรวจสอบได้
2. การสร้างข้อมูลเริ่มต้นสำหรับไปป์ไลน์ CI/CD — เครื่องมือทดสอบทางสถิติ เช่น TestU01 หรือ Dieharder สามารถเรียกใช้โดยอัตโนมัติในไปป์ไลน์การรวมระบบอย่างต่อเนื่อง เพื่อตรวจสอบว่าการใช้งาน RNG แบบกำหนดเองใด ๆ ยังคงรักษาคุณภาพทางสถิติไว้ได้ตลอดการเปลี่ยนแปลงโค้ด
3. การกำหนดเวลาแบบเนทีฟของแพลตฟอร์ม — แพลตฟอร์มคลาวด์ (AWS Lambda, Google Cloud Functions, Azure Functions) สามารถเรียกใช้กระบวนการที่ใช้ RNG ตามกำหนดเวลาได้ ตัวอย่างเช่น เพื่อสุ่มเลือกรายการบันทึกสำหรับการตรวจสอบความปลอดภัย หรือเพื่อกำหนดกลุ่มตัวอย่างแบบสุ่มรายวันในการทดลองด้านพฤติกรรม

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

วิธีการวัดคุณภาพและความสำเร็จของเครื่องกำเนิดเลขสุ่ม

เครื่องกำเนิดเลขสุ่มที่ดีต้องผ่านการทดสอบทางสถิติในด้านความสม่ำเสมอ ความเป็นอิสระ และความคาดเดาไม่ได้ เกณฑ์มาตรฐานหลัก ได้แก่ ชุดทดสอบเชิงประจักษ์ การวิเคราะห์ช่วงเวลาตามทฤษฎี และสำหรับเครื่องกำเนิดเลขสุ่มที่ใช้ในการเข้ารหัสลับ คือ ความต้านทานต่อการโจมตีแบบสร้างสถานะขึ้นใหม่

ชุดทดสอบทางสถิติ

ไม่มีลำดับจำกัดใดที่สามารถพิสูจน์ได้ว่าสุ่มอย่างแท้จริง แต่สามารถทดสอบลำดับเหล่านั้นเพื่อหาความไม่สุ่มที่ตรวจจับได้ ชุดทดสอบที่น่าเชื่อถือที่สุด ได้แก่:

• NIST SP 800-22 — ชุดการทดสอบทางสถิติ 15 รายการที่เผยแพร่โดยสถาบันมาตรฐานและเทคโนโลยีแห่งชาติ (National Institute of Standards and Technology) ใช้ในการประเมินตัวสร้างเลขสุ่ม (RNG) ที่ส่งเพื่อขอการรับรองทางด้านการเข้ารหัส การทดสอบประกอบด้วยการทดสอบความถี่ การทดสอบลำดับ การทดสอบสเปกตรัม (DFT) และการทดสอบแบบอนุกรม
• TestU01 (BigCrush) — BigCrush พัฒนาขึ้นที่มหาวิทยาลัยมอนทรีออล เป็นชุดทดสอบทางสถิติที่ยากที่สุดที่เปิดให้ใช้งานได้ทั่วไป อัลกอริทึมอย่าง LCG และตัวสร้าง Wichmann-Hill รุ่นเก่าไม่ผ่านการทดสอบนี้ แต่ Xoshiro256** และ PCG ผ่านการทดสอบ
• Dieharder — โปรแกรมโอเพนซอร์สที่ต่อยอดจากแบตเตอรี่ Diehard ดั้งเดิมของ George Marsaglia ซึ่งทำการทดสอบมากกว่า 100 ครั้งกับตัวอย่างขนาดใหญ่ของเอาต์พุตจากเครื่องกำเนิดไฟฟ้า
• PractRand — ชุดทดสอบที่ทันสมัยซึ่งรองรับขนาดตัวอย่างขนาดใหญ่มาก (ผลลัพธ์ระดับเทราไบต์) และสามารถตรวจจับความลำเอียงเล็กน้อยที่มองไม่เห็นในการทดสอบกับตัวอย่างขนาดเล็กได้

ตัวชี้วัดคุณภาพที่สำคัญ

• ความยาวของคาบ — จำนวนค่าที่สร้างขึ้นก่อนที่ลำดับจะวนซ้ำ Mersenne Twister มีคาบเท่ากับ ^{2¹⁹⁹³⁷⁻¹} ซึ่งเพียงพอสำหรับการใช้งานที่ไม่เกี่ยวข้องกับการเข้ารหัสลับเกือบทั้งหมด
• การกระจายอย่างเท่าเทียม — พิจารณาว่าค่าต่างๆ กระจายอย่างสม่ำเสมอทั่วช่วงผลลัพธ์ในมิติเดียว สองมิติ และการฉายภาพในมิติที่สูงกว่าหรือไม่
• ความไวต่อค่าเริ่มต้น — การเปลี่ยนแปลงเล็กน้อยในค่าเริ่มต้นส่งผลให้ลำดับผลลัพธ์แตกต่างกันอย่างสิ้นเชิงหรือไม่ (สำคัญต่อความสามารถในการทำซ้ำของการจำลอง)
• อัตราการประมวลผล — ความเร็วในการแสดงผลในหน่วยเมกะไบต์ต่อวินาที หรือจำนวนนับพันล้านตัวเลขต่อวินาที ซึ่งมีความสำคัญสำหรับงานประมวลผลแบบมอนเตคาร์โลที่มีประสิทธิภาพสูง
• การรักษาความลับทั้งแบบไปข้างหน้าและย้อนกลับ — สำหรับ CSPRNGs นั้น จะตรวจสอบว่าผู้โจมตีที่สังเกตผลลัพธ์ ณ เวลา T สามารถสร้างผลลัพธ์ในอดีตหรืออนาคตขึ้นมาใหม่ได้หรือไม่ การทดสอบนี้ทำได้โดยการพยายามสร้างสถานะขึ้นใหม่จากบิตที่สังเกตได้

การวัดความสำเร็จในบริบทการประยุกต์ใช้

นอกเหนือจากคุณภาพทางเทคนิคแล้ว ตัวชี้วัดความสำเร็จยังขึ้นอยู่กับบริบทการใช้งานด้วย:

• การจับฉลากและการสุ่มรางวัล — หลักฐานการตรวจสอบ การตรวจสอบโดยบุคคลที่สาม และใบรับรองความสุ่มที่ลงนามแล้ว (มีให้บริการจาก RANDOM.ORG) แสดงให้เห็นถึงความยุติธรรมต่อผู้เข้าร่วม
• แอปพลิเคชันด้านการเข้ารหัสลับ — การปฏิบัติตามมาตรฐาน FIPS 140-3 หรือการรับรอง Common Criteria ยืนยันว่าแหล่งกำเนิดเอนโทรปีและ CSPRNG เป็นไปตามมาตรฐานของรัฐบาลและอุตสาหกรรม
• การจำลองทางวิทยาศาสตร์ — ความสามารถในการทำซ้ำ (ใช้ค่าเริ่มต้นเดียวกันจะได้ผลลัพธ์เหมือนกัน) และความสามารถในการผ่านการทดสอบ BigCrush หรือ PractRand ด้วยขนาดตัวอย่างที่ใช้ในการจำลอง
• การทดสอบ A/B — การตรวจสอบความสมดุลยืนยันว่ากลุ่มทดลองและกลุ่มควบคุมมีความเท่าเทียมกันทางสถิติในตัวแปรพื้นฐานก่อนการทดลอง ซึ่งเป็นการยืนยันว่าการสุ่มตัวอย่างนั้นปราศจากอคติ

คำถามที่พบบ่อย

อะไรคือความแตกต่างระหว่างเครื่องกำเนิดเลขสุ่มแท้กับเครื่องกำเนิดเลขสุ่มเทียม?

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

การใช้เมธอด Math.random() ใน JavaScript ปลอดภัยหรือไม่เมื่อพิจารณาจากเหตุผลด้านความปลอดภัย?

ไม่ Math.random() ของ JavaScript เป็นตัวสร้างเลขสุ่มเทียม (PRNG) ที่ระบุไว้อย่างชัดเจนว่าไม่ปลอดภัยทางด้านการเข้ารหัส สถานะภายในของมันสามารถถูกสร้างขึ้นใหม่ได้จากผลลัพธ์ที่สังเกตได้ และไม่ควรใช้ในการสร้างรหัสผ่าน โทเค็นเซสชัน คีย์ API หรือค่าใดๆ ที่ผู้โจมตีสามารถเดาผลลัพธ์แล้วก่อให้เกิดอันตรายได้ สำหรับแอปพลิเคชันที่คำนึงถึงความปลอดภัยในเบราว์เซอร์ ให้ใช้ crypto.getRandomValues() จาก Web Crypto API ซึ่งได้รับการสนับสนุนโดย CSPRNG ของระบบปฏิบัติการ

เครื่องกำเนิดเลขสุ่มสามารถคาดเดาไม่ได้อย่างแท้จริงได้หรือไม่?

ตัวสร้างเลขทศนิยมที่เชื่อถือได้ (TRNG) ที่ใช้ฮาร์ดแวร์ซึ่งได้มาจากปรากฏการณ์ควอนตัม เช่น เวลาการมาถึงของโฟตอนหรือความผันผวนของสุญญากาศควอนตัม ถือว่าไม่สามารถคาดเดาได้โดยพื้นฐานตามกลศาสตร์ควอนตัม ซึ่งหมายความว่าไม่มีอัลกอริทึมหรือข้อมูลเพิ่มเติมใด ๆ ที่จะช่วยให้ผู้สังเกตการณ์สามารถคาดเดาผลลัพธ์ได้ดีกว่าโอกาสสุ่ม ส่วนตัวสร้างเลขสุ่มเทียม (PRNG) และตัวสร้างเลขสุ่มเทียมแบบซอฟต์แวร์ส่วนใหญ่ (CSPRNG) นั้นไม่สามารถคาดเดาได้ในทางคำนวณภายใต้สมมติฐานการเข้ารหัสมาตรฐาน ซึ่งหมายความว่ามันปลอดภัยในทางปฏิบัติ แต่ไม่สามารถพิสูจน์ได้ว่าไม่สามารถคาดเดาได้ในเชิงกายภาพอย่างแท้จริง

การกำหนดค่าเริ่มต้นมีผลต่อตัวสร้างเลขสุ่มอย่างไร?

ค่าเริ่มต้น (seed) คือค่าที่ป้อนเข้าไปในอัลกอริธึม PRNG ค่าเริ่มต้นเดียวกันจะสร้างลำดับเดียวกันเสมอ ซึ่งเป็นคุณสมบัติในด้านการคำนวณทางวิทยาศาสตร์ เพราะทำให้การทดลองสามารถทำซ้ำได้ ค่าเริ่มต้นที่ไม่ดี เช่น การใช้เวลาปัจจุบันในหน่วยนาโนวินาทีเป็นแหล่งเอนโทรปีเพียงอย่างเดียว จะลดความสุ่มลงอย่างมาก เพราะผู้โจมตีสามารถแจงนับค่าเริ่มต้นที่เป็นไปได้ทั้งหมดได้ การกำหนดค่าเริ่มต้นที่ดีควรใช้แหล่งเอนโทรปีหลายแหล่งร่วมกัน ได้แก่ เวลาปัจจุบันในหน่วยนาโนวินาที รหัสกระบวนการ ที่อยู่หน่วยความจำ และเอนโทรปีจากระบบปฏิบัติการ เช่น /dev/urandom หรือ CryptGenRandom บน Windows

โมดูล random ของ Python ใช้ตัวสร้างเลขสุ่มแบบใด?

โมดูล random ของ Python ใช้ขั้นตอนวิธี Mersenne Twister (MT19937) ซึ่งมีคาบ ^{2¹⁹⁹³⁷⁻¹} และผ่านการทดสอบทางสถิติส่วนใหญ่ เหมาะสำหรับการจำลอง เกม และการสุ่มตัวอย่างทางสถิติ อย่างไรก็ตาม มันไม่ปลอดภัยทางด้านการเข้ารหัสลับ — สถานะภายในสามารถถูกสร้างขึ้นใหม่ได้หลังจากสังเกตเอาต์พุต 32 บิตติดต่อกัน 624 ครั้ง สำหรับงานที่ต้องการความปลอดภัยสูงใน Python ให้ใช้โมดูล secrets ซึ่งใช้ os.urandom() เป็นตัวสนับสนุน และสุ่มจาก CSPRNG ระดับระบบปฏิบัติการ

เราสร้างตัวเลขสุ่มโดยไม่ใช้คอมพิวเตอร์ได้อย่างไร?

ก่อนยุคคอมพิวเตอร์ การสร้างเลขสุ่มใช้วิธีการทางกายภาพ เช่น การทอยลูกเต๋า การหยิบลูกบอลที่มีหมายเลขจากถังหมุน การโยนเหรียญ หรือการสับไพ่ บริษัท RAND ได้ตีพิมพ์หนังสือที่มีชื่อเสียงในปี 1955 ชื่อ " เลขสุ่มหนึ่งล้านตัวที่มีค่าเบี่ยงเบนปกติ 100,000 ตัว" ซึ่งสร้างขึ้นจากวงล้อรูเล็ตอิเล็กทรอนิกส์ ตารางสถิติของเลขสุ่มถูกนำมาใช้กันอย่างแพร่หลายในการสุ่มตัวอย่างสำรวจและการทดลองทางคลินิก ปัจจุบัน วิธีการแบบดั้งเดิมยังคงใช้ในลอตเตอรี่ที่มีการควบคุมบางประเภทและในการสาธิตในห้องเรียน แม้ว่าจะช้ากว่าและตรวจสอบได้ยากกว่าวิธีการทางอิเล็กทรอนิกส์ก็ตาม

เหตุใดจึงจำเป็นต้องทดสอบตัวสร้างเลขสุ่ม?

แม้แต่อัลกอริทึมที่ออกแบบมาเพื่อสร้างผลลัพธ์ที่ดูเหมือนสุ่ม ก็อาจมีอคติเล็กน้อย วงจรสั้นๆ ในบางมิติ หรือความสัมพันธ์ระหว่างค่าที่ต่อเนื่องกัน ซึ่งมองไม่เห็นได้ด้วยการตรวจสอบทั่วไป แต่สามารถตรวจจับได้ด้วยการทดสอบทางสถิติ ข้อบกพร่องเหล่านี้อาจทำให้ผลลัพธ์การจำลองไม่ถูกต้อง ลดความปลอดภัยของระบบการเข้ารหัส หรือทำให้เกิดความไม่ยุติธรรมในเกมและลอตเตอรี่ การทดสอบด้วยชุดทดสอบเช่น NIST SP 800-22, BigCrush หรือ PractRand จะตรวจพบปัญหาเหล่านี้ก่อนการใช้งาน ตัวอย่างในอดีตของตัวสร้างตัวเลขสุ่มที่มีข้อบกพร่อง — รวมถึงเวอร์ชันแรกๆ ของ mt_rand() ของ PHP และข้อบกพร่องของ Debian OpenSSL ในปี 2008 — แสดงให้เห็นว่าตัวสร้างตัวเลขสุ่มที่ไม่ได้ทดสอบอาจทำให้เกิดความล้มเหลวทางด้านความปลอดภัยอย่างแท้จริง

ตัวสร้างเลขสุ่มเทียมที่มีความปลอดภัยทางด้านการเข้ารหัส (CSPRNG) คืออะไร?

CSPRNG คือ PRNG ที่ตรงตามข้อกำหนดด้านความปลอดภัยเพิ่มเติมอีกสองประการ นอกเหนือจากคุณภาพทางสถิติ ได้แก่ การทดสอบบิตถัดไป (ไม่มีอัลกอริทึมใดที่สามารถทำนายบิตถัดไปได้ด้วยความน่าจะเป็นที่ดีกว่า 50% อย่างมีนัยสำคัญ เมื่อพิจารณาจากบิตก่อนหน้าทั้งหมด) และ ความต้านทานต่อการขยายการรั่วไหลของสถานะ (หากผู้โจมตีเรียนรู้สถานะภายใน ณ เวลา T พวกเขาจะไม่สามารถสร้างเอาต์พุตขึ้นใหม่จากช่วงเวลาก่อน T ได้) CSPRNG ที่ทันสมัย ได้แก่ ตัวสร้างที่ใช้ ChaCha20 (ใช้ใน /dev/urandom ของ Linux ตั้งแต่เคอร์เนล 4.8), Fortuna (ใช้ใน macOS และ iOS) และ CTR_DRBG (ได้รับการกำหนดมาตรฐานโดย NIST ใน SP 800-90A)

เครื่องกำเนิดเลขสุ่มสามารถสร้างค่าซ้ำได้หรือไม่?

ใช่ และนี่คือพฤติกรรมที่คาดหวังได้ กระบวนการสุ่มอย่างแท้จริงจะไม่มีความทรงจำเกี่ยวกับผลลัพธ์ในอดีต ดังนั้นจึงเกิดค่าซ้ำขึ้นได้ตามธรรมชาติ ซึ่งอธิบายได้ด้วยปัญหาวันเกิดในทฤษฎีความน่าจะเป็น ในการสุ่มแบบสม่ำเสมอจาก 1 ถึง N ค่าซ้ำจะเกิดขึ้นได้ง่ายเมื่อสุ่มได้ประมาณ √N ค่าแล้ว หากแอปพลิเคชันของคุณต้องการค่าที่ไม่ซ้ำกัน (เช่น การกำหนด ID ที่ไม่ซ้ำกัน หรือการสับไพ่โดยไม่ให้ซ้ำกัน) คุณควรใช้อัลกอริทึมการสับไพ่ เช่น Fisher-Yates กับชุดค่าที่กำหนดไว้ล่วงหน้า หรือเก็บรักษาชุดค่าที่ใช้แล้วและปฏิเสธค่าซ้ำ แทนที่จะพึ่งพาผลลัพธ์ดิบจาก RNG เพื่อหลีกเลี่ยงการชนกัน

เครื่องมือลอตเตอรี่และการจับรางวัลออนไลน์ช่วยให้เกิดความยุติธรรมได้อย่างไร?

เครื่องมือจับฉลากออนไลน์ที่น่าเชื่อถือจะรับประกันความยุติธรรมด้วยการผสมผสานระหว่าง: การใช้แหล่งเอนโทรปีคุณภาพสูง (โดยอุดมคติคือ TRNG มากกว่า Math.random()), การเผยแพร่อัลกอริธึมและค่าเริ่มต้นก่อนการจับฉลากเพื่อให้สามารถตรวจสอบผลลัพธ์ได้อย่างอิสระ, การให้ใบรับรองความสุ่มที่ลงนามแล้วซึ่งพิสูจน์ได้ว่าตัวเลขถูกสร้างขึ้นก่อนปิดการจับฉลาก และการดำเนินการจับฉลากต่อหน้าผู้ตรวจสอบอิสระ RANDOM.ORG ให้บริการจับฉลากจากบุคคลที่สามซึ่งประทับเวลาและลงนามทางเข้ารหัสลับในการจับฉลากแต่ละครั้ง สร้างบันทึกที่ตรวจสอบได้ สำหรับลอตเตอรี่ที่มีการกำกับดูแล หน่วยงานกำกับดูแลการพนันแห่งชาติกำหนดให้ต้องใช้ฮาร์ดแวร์ RNG ที่ได้รับการรับรองและการอนุมัติจากห้องปฏิบัติการทดสอบอิสระก่อนที่ระบบใด ๆ จะเริ่มใช้งานจริง