ฉันคิดว่าฉันเข้าใจถูกต้องแล้ว แต่ฉันต้องการให้แน่ใจว่าสิ่งนี้เกี่ยวข้องกับเงิน
ไบต์คงที่ส่วนตัว [] SaltPassphrase (ไบต์ [] เกลือรหัสผ่านสตริง)
{
var sha512 = SHA512.Create();
// เกลือเป็นสตริง Base64 (ไม่มี == ต่อท้าย) ตามด้วยรหัสผ่าน
อินพุตสตริง = $"{Convert.ToBase64String(salt)[0..^2]}{รหัสผ่าน}";
ไบต์ [] ไบต์ = sha512.ComputeHash (การเข้ารหัส UTF8.GetBytes (อินพุต));
สำหรับ (int i = 0; i < 100_000; i++)
ไบต์ = sha512.ComputeHash (ไบต์);
ส่งคืนไบต์
}
แก้ไข ขอบคุณทุกคนสำหรับคำอธิบายโดยละเอียดและความคิดเห็นที่เป็นประโยชน์!
ยกเว้นจำนวนการวนซ้ำ ( เราเถียงได้ว่าน้อยด้วย ¡ และการสูญเสียเอนโทรปีบางส่วน *) คำตอบคือไม่!
มีอัลกอริธึมการแฮชรหัสผ่านนอกเหนือจากแฮชการเข้ารหัส เช่น ซีรีส์ SHAx อยู่แล้ว ที่สำคัญคือ เข้ารหัส (2009), PBKDF2 (2543), อาร์กอน 2 (2558), และ การแฮชบอลลูน (2559). Argon2 เป็นผู้ชนะของ การแข่งขันแฮชรหัสผ่าน ที่จัดขึ้นในปี 2015 ตอนนี้ Balloon Hashing สามารถสู้กับ Argon2 ได้แล้ว ใช้ Balloon Hashing หรือ Argon2 สำหรับการแฮชรหัสผ่านที่ปลอดภัย
มีไลบรารี่สำหรับแต่ละไลบรารีอยู่แล้วซึ่งคุณจะต้องกำหนดพารามิเตอร์ให้เหมือนกัน อาร์กอน2 แทนที่จะเขียนรายละเอียดเอง
ห้องสมุด Argon2 ที่ดี
นี่คือพารามิเตอร์
การใช้งาน: ./argon2 [-h] salt [-i|-d|-id] [-t iterations] [-m memory] [-p parallelism] [-l hash length] [-e|-r] [- v (10|13)]
รหัสผ่านถูกอ่านจาก stdin
พารามิเตอร์:
เกลือ เกลือที่จะใช้อย่างน้อย 8 ตัว
-i ใช้ Argon2i (นี่คือค่าเริ่มต้น)
-d ใช้ Argon2d แทน Argon2i
-id ใช้ Argon2id แทน Argon2i
-t N กำหนดจำนวนการวนซ้ำเป็น N (ค่าเริ่มต้น = 3)
-m N ตั้งค่าการใช้หน่วยความจำของ 2^N KiB (ค่าเริ่มต้น 12)
-p N ตั้งค่าความขนานเป็น N เธรด (ค่าเริ่มต้น 1)
-l N ตั้งค่าความยาวเอาต์พุตแฮชเป็น N ไบต์ (ค่าเริ่มต้น 32)
-e เอาต์พุตแฮชที่เข้ารหัสเท่านั้น
-r ส่งออกเฉพาะไบต์ดิบของแฮช
-v (10|13) เวอร์ชัน Argon2 (ค่าเริ่มต้นเป็นเวอร์ชันล่าสุด ปัจจุบันคือ 13)
-h พิมพ์การใช้งาน argon2
ฉันอาจจะถามว่าคืออะไร $i,d,$ และ $id$ ใน Argon2 คำตอบคือจาก ร่าง-irtf-cfrg-argon2-03;
หากคุณไม่ทราบความแตกต่างระหว่างพวกเขา หรือคุณพิจารณาว่าการโจมตีด้วยช่องทางด้านข้างเป็นภัยคุกคามที่ทำงานได้ เลือก Argon2id.
อาร์กอน2d เร็วกว่าและใช้การเข้าถึงหน่วยความจำขึ้นอยู่กับข้อมูล การพึ่งพาข้อมูลเปิดใช้งานช่องทางด้านข้างทันที เหมาะสำหรับการเข้ารหัสลับและแอปพลิเคชันที่ไม่มีภัยคุกคามจากการโจมตีช่องทางด้านข้าง
อาร์กอน2ไอ ใช้การเข้าถึงหน่วยความจำที่ไม่ขึ้นกับข้อมูล และวิธีนี้เป็นที่นิยมสำหรับการแฮชรหัสผ่านและการสร้างคีย์ตามรหัสผ่าน
อาร์กอน2id ในช่วงครึ่งแรกของการวนซ้ำครั้งแรกจะทำงานเป็น Argon2i และส่วนที่เหลือจะทำงานเป็น Argon2d สิ่งนี้เปิดใช้งานทั้งการป้องกันช่องทางด้านข้างและการแลกเปลี่ยนหน่วยความจำเวลา
การแฮชบอลลูน
ตอนนี้มันอยู่ใน NIST สิ่งพิมพ์พิเศษ 800-63B และต้องใช้เวลาในการปรับตัว มี ห้องสมุดบางส่วนพร้อมใช้งาน.
คุณสมบัติหลักคือ
เล็กน้อยเกี่ยวกับรหัสผ่าน
สำหรับรหัสผ่านของผู้ใช้ คุณควรให้ความรู้ในการใช้งาน ลูกเต๋า การสร้างรหัสผ่านตาม หากไม่ได้ใช้ การจำกัดก็มีประโยชน์ โปรดทราบว่ารหัสผ่านแบบ dicewire ไม่จำเป็นต้องมีข้อจำกัดบน ล่าง หลัก ฯลฯดังนั้นควรระมัดระวังเกี่ยวกับการจำกัดผู้ใช้ตามกฎบางอย่าง
เล็กน้อยเกี่ยวกับผู้จัดการรหัสผ่าน
นอกจากนี้ เกือบทุกคนมีสมาร์ทโฟน หนึ่งสามารถใช้ ผู้จัดการรหัสผ่าน เพื่อจัดเก็บรหัสผ่านที่เกือบจะเป็นรหัสผ่านแบบสุ่มที่สร้างโดยผู้จัดการรหัสผ่านและจัดเก็บไว้ แจ้งให้ผู้ใช้ทราบเกี่ยวกับเรื่องนี้ด้วย บางส่วนของพวกเขาฟรีเช่น LastPass, 1รหัสผ่าน, และ คีพาส.
ตอบกลับความคิดเห็น:
ฉันไม่สามารถใช้อัลกอริทึมที่ใช้หน่วยความจำจำนวนมากได้ (หากฉันเข้าใจ Memory Hardness อย่างถูกต้อง) เนื่องจากเป็นเซิร์ฟเวอร์ แนวทางถูกต้องหรือไม่ SHA512 เหมาะสมหรือไม่ และการวนซ้ำเหมาะสมหรือไม่เมื่อพิจารณาจากความยาวของรหัสผ่าน
SHA-512 มีการใช้หน่วยความจำน้อยมากในรหัสผ่าน ต้องจัดเก็บเพียง 1024 บิตเพื่อสร้างแฮชรหัสผ่าน พารามิเตอร์หน่วยความจำเริ่มต้นของ Argon2 คือ $2^{12}$KiB = 4MiB หากเราพิจารณาว่าระบบสามารถเรียกใช้เธรดเท่าใดก็ได้ พลังในการบังคับเดรัจฉานตามอัลกอริทึมที่ใช้ SHA-512 จะลดลง 32768 เท่า ดังนั้น การใช้หน่วยความจำเพียงเล็กน้อยก็ช่วยเสริมความแข็งแกร่งให้กับความซับซ้อนในการแฮชรหัสผ่าน $2^{15}$. 4MiB นั้นใช้ได้ดีสำหรับเซิร์ฟเวอร์และสามารถปรับหน่วยความจำตามการเข้าถึงการเข้าสู่ระบบต่อวินาที หรือซื้อหน่วยความจำเพิ่มดีกว่า โปรดจำไว้ว่าอัลกอริธึมการแฮชรหัสผ่านจะทิ้งหน่วยความจำไว้ที่ระบบ คอขวดที่ต้องพิจารณาคือจำนวนคำขอเข้าสู่ระบบต่อวินาที
â¡) ผลความเร็ว OpenSSL แสดงให้เห็นว่า SHA-512 100K มีขนาดเล็ก
ทำ sha512 เป็นเวลา 3 วินาทีบนบล็อกขนาด 64 บล็อก: 10896142 sha512 ใน 3.00 วินาที
ทำ sha512 เป็นเวลา 3 วินาทีบนบล็อกขนาด 256 บล็อก: 4673961 sha512 ใน 2.99 วินาที
*) เราสูญเสียเอนโทรปีเท่าใดต่อการวนซ้ำของฟังก์ชันแฮชการเข้ารหัส
Ossifrage คลื่นไส้ เขียนคำตอบที่ดีเกี่ยวกับเรื่องนี้. หลักของผลลัพธ์คือ
แต่มีโอกาสดีที่ฟังก์ชัน F คงที่ใดๆ จะมีมากมาย รอบ โดยที่ F เป็นการเรียงสับเปลี่ยน และจำกัดให้ F รักษาค่าเอนโทรปีไว้
นอกเหนือจากคำตอบที่ยอดเยี่ยมของ @ kelalka มันคุ้มค่าที่จะชี้ให้เห็นถึงความแตกต่างที่สำคัญระหว่างการใช้งานของคุณและวิธีการแฮชแบบวนซ้ำมาตรฐานเช่น PBKDF2 แม้ว่า PBKDF2 จะไม่ใช่ฮาร์ดหน่วยความจำ เช่นเดียวกับอัลกอริธึมการแฮชรหัสผ่านที่ใหม่กว่าบางตัว ฉันถือว่า (หรือ bcrypt) เพียงพอสำหรับวัตถุประสงค์ส่วนใหญ่ อาจคล้ายกับวิธีแก้ปัญหาที่คุณเสนอมากที่สุด ดังนั้นจะเข้าใจได้ง่ายขึ้น https://en.wikipedia.org/wiki/PBKDF2
การเปลี่ยนแปลงที่สำคัญคือการแฮชรหัสผ่านซ้ำกับผลลัพธ์ก่อนหน้า สิ่งนี้ป้องกันการบรรจบกันของแฮช จำนวนการวนซ้ำน่าจะน้อยเมื่อเทียบกับช่องว่างของฟังก์ชันแฮช ดังนั้นนี่อาจไม่มีนัยสำคัญ แต่ถ้าพื้นที่ที่มีประสิทธิภาพจบลงมีขนาดเล็กกว่าที่เราคิดไว้ เมื่อคุณแฮชค่าต่างๆ ซ้ำๆ กัน การวนซ้ำแต่ละครั้งจะลดพื้นที่เอาต์พุตที่เป็นไปได้ของคุณลงเล็กน้อยเนื่องจากการชนกัน เมื่อวนซ้ำแล้วซ้ำอีก คุณจะจบลงด้วยค่าที่แตกต่างกันน้อยลงเรื่อยๆ
นอกจากนี้ ข้อกำหนดด้านความซับซ้อนของรหัสผ่านยังถือเป็นอันตรายอีกด้วย พิจารณานโยบายรหัสผ่านที่ทันสมัย: https://auth0.com/blog/dont-pass-on-the-new-nist-password-guidelines/
การสร้างฟังก์ชันการเข้ารหัสยังคงเป็นกระบวนการลองผิดลองถูกอยู่มาก แน่นอน เมื่อเวลาผ่านไป เราสะดุดกับบางสิ่งที่เป็นความคิดที่ดีหรือแม้กระทั่งเป็นข้อบังคับ และเราได้เรียนรู้หลายสิ่งหลายอย่างอย่างแน่นอน อย่า งาน. แต่เราไม่รู้วิธีสร้างสิ่งที่พิสูจน์แล้วว่าปลอดภัยตลอดทาง ข้อผิดพลาดเล็กน้อยที่ละเอียดอ่อนมากอาจทำให้โครงสร้างการเข้ารหัสล้มเหลวอย่างร้ายแรง และมี มาก ของโอกาสในการผิดพลาดดังกล่าว ฉันจะตั้งชื่อบางอย่างในภายหลัง
สิ่งที่ดีที่สุดที่เราสามารถทำได้ในตอนนี้คือผู้คนที่มีประสบการณ์ในเรื่องนี้สร้างสิ่งเข้ารหัสลับ จากนั้นทุกคนก็พยายามและทำลายสิ่งเข้ารหัสลับนั้น ถ้าทุกคนพยายามมากพอและไม่ประสบความสำเร็จเป็นเวลานาน เราก็มีบางอย่างที่น่าจะดีพอ เรายังไม่สามารถพิสูจน์ได้ว่าไม่มีปัญหา แต่ถ้าการเข้ารหัสลับนับพันไม่สามารถทำได้ หวังว่าพันถัดไปก็ทำไม่ได้เช่นกัน
แต่ถึงแม้จะล้มเหลวเป็นครั้งคราว บางครั้งหลังจากผ่านไปหลายปี หลายสิบปี ปัญหาร้ายแรงก็พบได้ในสิ่งที่คนที่ฉลาดที่สุดพิจารณามาเป็นเวลานาน นั่นคือสาเหตุที่ MD5 ไม่ถือว่าตกลงอีกต่อไป และเหตุใด RC4 จึงถูกพิจารณาว่าเป็นปัญหา หรือภูมิลักษณ์เปลี่ยนไป เป็นต้นว่า ความต้องการเกลือในแฮชรหัสผ่านและฟังก์ชันแฮชที่ช้าโดยเจตนา
ด้วยการใช้อัลกอริทึมการเข้ารหัสที่รู้จักกันดีที่สุดในปัจจุบัน เราสามารถใช้ประโยชน์จากประสบการณ์โดยรวมนี้ และอาจหลีกเลี่ยงข้อผิดพลาดในอดีตซ้ำได้ อาจมีการค้นพบข้อผิดพลาดใหม่ ๆ แต่ก็ไม่สามารถช่วยได้ ผู้ที่สร้างฟังก์ชันการเข้ารหัสลับของตัวเองมีแนวโน้มที่จะทำซ้ำข้อผิดพลาดเหล่านั้นหรือสร้างใหม่ทั้งหมด
ฉันรู้ ฉันรู้ว่ามันสนุกที่ได้ออกแบบสิ่งนั้นด้วยตัวคุณเอง และรู้สึกดีที่จะสร้างสิ่งที่รู้สึกปลอดภัย Stack Exchange เต็มไปด้วยคำถามเกี่ยวกับการเข้ารหัสแบบกำหนดเองและแฮชรหัสผ่าน (โดยเฉพาะ) ปัญหาคือมันง่ายที่จะสร้างสิ่งที่คุณไม่สามารถทำลายได้ แต่ไม่ได้หมายความว่าคนอื่นทำไม่ได้สุภาษิตนี้มีมาแต่โบราณ และเกิดขึ้นบ่อยจนปัจจุบันเรียกว่า กฎของชไนเออร์.
ดังนั้นจึงอาจมีปัญหากับแกนหลักของอัลกอริทึมการเข้ารหัสลับ นี่คือสิ่งที่ทำให้ MD5 และ RC4 พัง
หรืออัลกอริทึมอาจใช้ได้ดี แต่การใช้งานอาจเสียหายได้ นี่อาจเป็นจุดบกพร่องธรรมดาๆ หรืออาจเป็นจุดบกพร่องที่ละเอียดกว่านั้น เช่น การโจมตีช่องทางด้านข้าง (ซึ่งบางครั้งก็ยากที่จะหลีกเลี่ยง)
แต่ก็เป็นไปได้เช่นกัน (ง่ายเหมือนกัน) สำหรับการเข้ารหัสดั้งเดิมที่ปลอดภัยพร้อมการใช้งานที่ปราศจากข้อผิดพลาดซึ่งจะถูกนำไปใช้อย่างไม่ถูกต้อง ซึ่งทำให้ระบบไม่ปลอดภัย ตัวอย่างเช่น การใช้การเข้ารหัสและลายเซ็นดิจิทัลอย่างถูกต้อง แต่การตั้งสมมติฐานที่ไร้เดียงสาระหว่างการจับมือสื่อสาร (SSL มีปัญหาร่วมกันในเรื่องนี้) อีกตัวอย่างที่รู้จักกันดีคือ เออีเอส-อีซีบีซึ่งใช้ AES ที่สมบูรณ์แบบในลักษณะที่อาจทำให้ข้อมูลสำคัญรั่วไหลได้
ฟังก์ชันการแฮชรหัสผ่านของคุณเองก็ตกเป็นเหยื่อของสิ่งนี้เช่นกัน:
ทำซ้ำ 100_000:
แฮช = sha512 (แฮช)
SHA-512 นั้นใช้ได้อย่างสมบูรณ์แบบ (เท่าที่เรารู้) ใช้แบบนี้ถือว่าพลาด
SHA-512 สร้างเอาต์พุต 512 บิตที่ "แยกแยะไม่ออกจากการสุ่ม" สำหรับทุกอินพุต มันอาจสร้างเอาต์พุตเดียวกันสำหรับสองอินพุตที่แตกต่างกัน ซึ่งเรียกว่าการชนกัน ปัญหาคือโดยทั่วไปแล้วฟังก์ชันแฮช N-บิตบนอินพุต N-บิตไม่ใช่ วัตถุประสงค์. ซึ่งหมายความว่าเมื่อป้อนเอาต์พุต SHA-512 ให้กับตัวมันเอง ค่า 512 บิตที่เป็นไปได้บางค่าจะชนกับค่าอื่น ทำให้เกิดเอาต์พุตเดียวกัน โดย ความจำเป็นซึ่งหมายความว่าไม่สามารถสร้างค่าแฮชอื่นๆ บางค่าได้เลย
ลองดูวิธีการทำงานสำหรับ SHA-512 ที่ตัดเหลือ 4 บิต โดยเฉพาะอย่างยิ่ง เรารับไบต์แรกจากเอาต์พุต และนำ 4 บิตสูงเป็นศูนย์ในไบต์นี้ ไบต์เดียวที่เป็นผลลัพธ์จะถูกใช้เป็นอินพุตสำหรับรอบถัดไป วิธีเลือกบิตต่างกันให้ผลลัพธ์ต่างกัน แต่หลักการเหมือนกัน
การลองอินพุตที่เป็นไปได้ทั้งหมด 16 รายการสำหรับหลายๆ รอบทำให้เรามีห่วงโซ่เหล่านี้:
ใน 1. 2. 3. 4. 5. 6. 7.
00 -> 08 -> 06 -> 08 -> 06 -> 08 -> 06 -> 08
06 -> 08 /
07 -> 06 -> 08 -> 06 -> 08 -> 06 -> 08 -> 06
08 -> 06 /
03 -> 04 -> 05 \
13 -> 15 -> 05 -> 09 -> 02 -> 10 -> 14 -> 14
04 -> 05 -> 09 -> 02 -> 10 -> 14 -> 14 /
15 -> 05 -> 09 -> 02 -> 10 -> 14 /
05 -> 09 -> 02 -> 10 -> 14 -> 14
01 -> 11 -> 02 -> 10 -> 14 /
09 -> 02 -> 10 -> 14 -> 14
11 -> 02 -> 10 -> 14 /
02 -> 10 -> 14 -> 14
12 -> 10 / /
10 -> 14 -> 14
14 -> 14 /
หลังจากผ่านไปเพียง 6 รอบ เอาต์พุตที่เป็นไปได้ 16 รายการได้ลดลงเหลือเพียง 3 เอฟเฟกต์เดียวกันนี้สามารถเห็นได้สำหรับการตัดทอนที่ใหญ่ขึ้น ฉันเรียกใช้การจำลองบางอย่างสำหรับ SHA-512 ที่ตัดทอนเป็น 1 ไบต์แรก (2â¸), 2 ไบต์ (2¹â¶) และ 3 ไบต์ (2²â´):
ไบต์: 1 2 3
ช่องใส่ข้อมูล: 256 65536 16777216
รวมกันเป็นค่า M: 13 330 2765
หลังจาก N รอบ: 31 518 7114
คุณจะเห็นว่าเอฟเฟกต์คอนเวอร์เจนซ์มีอยู่ในทั้งสามสถานการณ์ สำหรับการเจียระไน SHA-512 คอมพิวเตอร์ของฉันไม่เร็วพอที่จะคำนวณสิ่งนี้ ฉันไม่พบข้อมูลใด ๆ เกี่ยวกับความแรงและความแน่นอนของเอฟเฟกต์ และฉันไม่ฉลาดพอที่จะสร้างหลักฐาน (หากการพิสูจน์คือ เป็นไปได้ด้วยซ้ำ) แต่โอกาสที่คุณจะเห็นผลใน SHA-512 เต็มรูปแบบเช่นกัน สัญชาตญาณของฉันสงสัยว่ามันลดพื้นที่แฮชด้วยสแควร์รูท (ลดความยาวบิตลงครึ่งหนึ่ง) แต่ฉันอาจคิดผิดมาก [อัปเดต: ดูลิงก์ที่ให้ไว้ในความคิดเห็น: หนึ่ง, สอง, สาม]. 100,000 รอบอาจจำกัดความเสียหายด้วย
ตอนนี้สิ่งนี้เป็นอันตรายต่อแฮชของคุณหรือไม่? อาจจะไม่. แต่มัน เป็น จุดอ่อนอย่างหนึ่งที่ฟังก์ชันแฮชรหัสผ่านในโลกแห่งความเป็นจริงพยายามหลีกเลี่ยง (เช่น ตรวจสอบว่ารหัสผ่านและเกลือผสมกันเป็นประจำ)
ฉันคิดว่านี่เป็นตัวอย่างที่ดีของกับดักเล็กๆ น้อยๆ ในการออกแบบคริปโต มันง่ายมากที่จะพลาดอะไรแบบนี้ นั่นเป็นเหตุผลที่ฉันแนะนำให้ใช้อัลกอริทึมที่ผ่านการทดสอบการต่อสู้ พวกเขาดีกว่าสิ่งที่คุณหรือฉันจะคิดได้
คำตอบอื่นๆ ได้ให้คำแนะนำเกี่ยวกับแฮชที่จะใช้แล้ว ตกลง: pbkdf2, bcrypt ดีกว่า: argon2, scrypt ฉันได้ยินมาว่าบอลลูนเป็นสิ่งหนึ่ง แต่ฉันไม่รู้อะไรเลยเกี่ยวกับเรื่องนี้ ดังนั้นฉันจึงไม่มีความคิดเห็นเกี่ยวกับเรื่องนี้
คิดว่าคำตอบคือ: "ปลอดภัย" นั้นสัมพันธ์กัน เกลือ 512 บิต (8*64 บิต) เพียงอย่างเดียวให้ความเป็นไปได้ประมาณ 6*10^57 การเปลี่ยนรูปเกลือ (ผ่าน BASE64) จะไม่เปลี่ยนความแข็งแรง
จากนั้นคุณมี 992 บิต (62*16 บิต) ที่สร้างรหัสผ่าน (26*2 ตัวอักษรบวก 10 หลัก) หรือความเป็นไปได้ประมาณ 4*10^28 สมมติว่าความน่าจะเป็นเหมือนกัน (ค่อนข้างไม่น่าเป็นไปได้หากมนุษย์เลือก) คุณจะมีบิตอินพุตประมาณ 1504 บิตเพื่อสร้างบิตเอาต์พุต 512 บิต สูงสุด (มีความเป็นไปได้ที่จะเกิดความขัดแย้ง) 5*10^452 ความเป็นไปได้ นั่นคือ ใหญ่ ตัวเลข.
ตัวเลขจะถือว่าเกลือไม่สามารถ "แยกตัวประกอบ" จากแฮชได้ ดังนั้นเกลือจึงขยายช่วงการค้นหา
การทำซ้ำแฮชจะทำให้การสร้างตารางช้าลงเท่านั้น และไม่ค้นหาผลลัพธ์ (ตารางผลลัพธ์จะมีขนาดใหญ่สุด 2^512 รายการ)
คนส่วนใหญ่ไม่เข้าใจว่าการถามคำถามมากมายจะปลดล็อกการเรียนรู้และปรับปรุงความสัมพันธ์ระหว่างบุคคล ตัวอย่างเช่น ในการศึกษาของ Alison แม้ว่าผู้คนจะจำได้อย่างแม่นยำว่ามีคำถามกี่ข้อที่ถูกถามในการสนทนา แต่พวกเขาไม่เข้าใจความเชื่อมโยงระหว่างคำถามและความชอบ จากการศึกษาทั้ง 4 เรื่องที่ผู้เข้าร่วมมีส่วนร่วมในการสนทนาด้วยตนเองหรืออ่านบันทึกการสนทนาของผู้อื่น ผู้คนมักไม่ตระหนักว่าการถามคำถามจะมีอิทธิพลหรือมีอิทธิพลต่อระดับมิตรภาพระหว่างผู้สนทนา
