มีการใช้งานจาวาสคริปต์ SHA-256 ที่โดยทั่วไปถือว่าน่าเชื่อถือหรือไม่?

ฉันกำลังเขียนล็อกอินสำหรับฟอรัมและจำเป็นต้องแฮชรหัสผ่านฝั่งไคลเอ็นต์ในจาวาสคริปต์ก่อนที่จะส่งไปยังเซิร์ฟเวอร์ ฉันมีปัญหาในการหาการใช้งาน SHA-256 ที่ฉันสามารถเชื่อถือได้ ฉันคาดหวังว่าจะมีสคริปต์ที่เชื่อถือได้บางประเภทที่ทุกคนใช้ แต่ฉันพบโครงการต่างๆมากมายด้วยการใช้งานของตัวเอง

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

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

ล้าสมัย:เบราว์เซอร์สมัยใหม่จำนวนมากรองรับการใช้งาน crypto ระดับเฟิร์สคลาสแล้ว ดูคำตอบของ Vitaly Zdanevichด้านล่าง

Crypto ห้องสมุด Stanford JSมีการดำเนินการของ SHA-256 แม้ว่าการเข้ารหัสลับใน JS จะไม่ได้รับการตรวจสอบอย่างดีเท่าแพลตฟอร์มการนำไปใช้งานอื่น ๆ แต่อย่างน้อยก็มีการพัฒนาบางส่วนโดยDan Bonehซึ่งเป็นชื่อที่มีชื่อเสียงและเชื่อถือได้ในการเข้ารหัส และหมายความว่าโครงการมีการดูแลบางอย่างโดยคนที่รู้ว่าเขากำลังทำอะไรอยู่ โครงการนี้ยังได้รับการสนับสนุนโดยNSF

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

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

ในhttps://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digestฉันพบตัวอย่างข้อมูลนี้ที่ใช้โมดูล js ภายใน:

async function sha256(message) {
    // encode as UTF-8
    const msgBuffer = new TextEncoder().encode(message);                    

    // hash the message
    const hashBuffer = await crypto.subtle.digest('SHA-256', msgBuffer);

    // convert ArrayBuffer to Array
    const hashArray = Array.from(new Uint8Array(hashBuffer));

    // convert bytes to hex string                  
    const hashHex = hashArray.map(b => ('00' + b.toString(16)).slice(-2)).join('');
    return hashHex;
}

โปรดทราบว่าcrypto.subtleมีให้เฉพาะในhttpsหรือlocalhost- ตัวอย่างเช่นสำหรับการพัฒนาในพื้นที่ของpython3 -m http.serverคุณคุณต้องเพิ่มบรรทัดนี้ใน/etc/hosts: 0.0.0.0 localhost

Reboot - และคุณสามารถเปิดกับการทำงานlocalhost:8000crypto.subtle

การใช้งาน SHA-256 ของForgeนั้นรวดเร็วและเชื่อถือได้

เรียกใช้การทดสอบบน SHA-256 การใช้งานจาวาสคริหลายไปhttp://brillout.github.io/test-javascript-hash-implementations/

ผลลัพธ์บนเครื่องของฉันแสดงให้เห็นว่าการปลอมเป็นการใช้งานที่เร็วที่สุดและยังเร็วกว่า Stanford Javascript Crypto Library (sjcl) ที่กล่าวถึงในคำตอบที่ยอมรับ

Forge มีขนาดใหญ่ 256 KB แต่การแยกโค้ดที่เกี่ยวข้องกับ SHA-256 จะลดขนาดลงเหลือ 4.5 KB โปรดดูที่https://github.com/brillout/forge-sha256

สำหรับผู้ที่สนใจนี่คือรหัสสำหรับสร้างแฮช SHA-256 โดยใช้sjcl:

import sjcl from 'sjcl'

const myString = 'Hello'
const myBitArray = sjcl.hash.sha256.hash(myString)
const myHash = sjcl.codec.hex.fromBits(myBitArray)

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

"ปัญหาไก่ - ไข่" ในการส่งการเข้ารหัส Javascript คืออะไร

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

[... ]

เหตุใดฉันจึงไม่สามารถใช้ TLS / SSL เพื่อส่งรหัสการเข้ารหัส Javascript ได้

คุณสามารถ. มันยากกว่าที่คิด แต่คุณส่ง Javascript crypto ไปยังเบราว์เซอร์โดยใช้ SSL ได้อย่างปลอดภัย ปัญหาคือเมื่อสร้างช่องทางที่ปลอดภัยด้วย SSL แล้วคุณไม่จำเป็นต้องใช้การเข้ารหัส Javascript อีกต่อไป คุณมีการเข้ารหัส "ของจริง"

ซึ่งนำไปสู่สิ่งนี้:

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

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

โดยทั่วไปปัญหาคือ:

• ลูกค้าของคุณไม่เชื่อถือเซิร์ฟเวอร์ของคุณดังนั้นพวกเขาจึงต้องการเพิ่มรหัสความปลอดภัยเพิ่มเติม
• รหัสความปลอดภัยนั้นจัดส่งโดยเซิร์ฟเวอร์ของคุณ (รหัสที่พวกเขาไม่เชื่อถือ)

หรืออีกทางหนึ่งคือ

• ลูกค้าของคุณไม่เชื่อถือ SSL ดังนั้นพวกเขาจึงต้องการให้คุณใช้รหัสความปลอดภัยเพิ่มเติม
• รหัสความปลอดภัยนั้นถูกส่งผ่าน SSL

หมายเหตุ: นอกจากนี้ SHA-256 ไม่เหมาะสำหรับการนี้เนื่องจากมันจึงง่ายต่อการบังคับเดรัจฉานรหัสผ่านที่ไม่ซ้ำจืด ถ้าคุณตัดสินใจที่จะทำต่อไปนี้ดูสำหรับการดำเนินการของbcrypt , ScryptหรือPBKDF2

ฉันพบว่าการใช้งานนี้ใช้งานง่ายมาก นอกจากนี้ยังมีใบอนุญาตสไตล์ BSD ที่ใจกว้าง:

jsSHA: https://github.com/Caligatio/jsSHA

ฉันต้องการวิธีที่รวดเร็วในการรับการแทนค่า hex-string ของแฮช SHA-256 ใช้เวลาเพียง 3 บรรทัด:

var sha256 = new jsSHA('SHA-256', 'TEXT');
sha256.update(some_string_variable_to_hash);
var hash = sha256.getHash("HEX");

นอกเหนือจาก Stanford lib ที่ tylerl กล่าวถึง ฉันพบว่าjsrsasignมีประโยชน์มาก (Github repo ที่นี่: https://github.com/kjur/jsrsasign ) ฉันไม่รู้ว่ามันน่าเชื่อถือแค่ไหน แต่ฉันใช้ API ของ SHA256, Base64, RSA, x509 เป็นต้นและมันก็ใช้ได้ดีทีเดียว ในความเป็นจริงมันรวมถึง lib Stanford ด้วย

หากสิ่งที่คุณต้องการทำคือ SHA256 jsrsasignอาจจะมากเกินไป แต่ถ้าคุณมีความต้องการอื่น ๆ ในส่วนที่เกี่ยวข้องฉันรู้สึกว่ามันเหมาะสมดี