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

ล็อค

มีเพียงผู้ถูกเลือกเท่านั้นที่เปิดประตูได้

เดอะเมทริกซ์รีโหลดแล้ว

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

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

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

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

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

กุญแจ

ท่านสุภาพบุรุษ คีย์ทำอะไร กุญแจ... ปลดล็อคของเหรอ

Pirates of the Caribbean – หน้าอกของคนตาย

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

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

คู่แรก: การเข้ารหัส

ฉันคือคีย์มาสเตอร์

โกสท์บัสเตอร์

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

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

X25519 เป็นอัลกอริทึมที่รับ master_key และคำนวณ secret_key การกู้คืน master_key จาก secret_key เป็นไปไม่ได้ในทางปฏิบัติ การโจมตีแบบคลาสสิกบนซูเปอร์คอมพิวเตอร์ในจินตนาการที่คำนวณบนเส้นโค้งได้ 10¹⁸ ครั้งต่อวินาทีจะใช้เวลาประมาณ 2.3 ล้านล้านปีโดยเฉลี่ย (การประมาณการของ SafeCurves)

คู่ที่สอง: ลายเซ็น

สิ่งเดียวที่เป็นต้นฉบับคือลายเซ็น

จับฉันถ้าคุณทำได้

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

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

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

หากต้องการรับคีย์ที่แตกต่างกันสำหรับงานที่แตกต่างกัน เราได้รวมป้ายกำกับคงที่ไว้ในการคำนวณ: ที่นี่ confidex/vault/ed25519/v1 master_key เดียวกันและป้ายกำกับเดียวกันจะสร้างคีย์เดียวกันเสมอ

รหัสผ่านหลักไม่ได้เข้าสู่การคำนวณเหล่านี้ ทั้งสองคู่ขึ้นอยู่กับไบต์สุ่มของ master_key ไม่ใช่ในสตริงที่บุคคลประดิษฐ์ขึ้น ความแตกต่างนี้จะมีความสำคัญในภายหลัง: รหัสผ่านจะป้องกันการเข้าถึงคีย์ที่มีอยู่แล้ว ดังนั้นเราจึงสามารถเปลี่ยนได้โดยไม่ต้องเปลี่ยนคีย์ด้วยตนเอง

การสืบทอดมาจากฟังก์ชันการสืบทอดคีย์แบบแฮช: HKDF, HMAC-based Extract-and-Expand Key Derivation Function Confidex ใช้กับ SHA-256 ดังนั้นชื่อ HKDF-SHA256 ผลลัพธ์ 32 ไบต์คือ seed สำหรับคู่ Ed25519 ส่วนสาธารณะของ signing_key จะไม่เปิดเผย secret_key ดังนั้นเราจึงสามารถส่งไปยังเซิร์ฟเวอร์เพื่อตรวจสอบลายเซ็นได้

ไฟล์ล็อคคืออะไร และมันทำหน้าที่อะไร?

เปิดประตูช่องใส่พ็อด HAL
ขอโทษนะ Dave ฉันเกรงว่าจะทำแบบนั้นไม่ได้

โอดิสซีอวกาศ

ล็อคจะจัดเก็บ master_key ที่เข้ารหัสไว้ การเปิดต้องใช้รหัสผ่านหลักและ secret_key ส่วนหัวสาธารณะประกอบด้วยเวอร์ชันของรูปแบบ, ตัวระบุห้องนิรภัย, ส่วนสาธารณะของ signing_key, Salt และพารามิเตอร์การประมวลผลรหัสผ่าน เวอร์ชันรูปแบบภายในได้รับการเข้ารหัสควบคู่ไปกับ master_key

เมื่อสร้างการล็อก แอปพลิเคชันมี master_key อยู่แล้ว ดังนั้นจึงคำนวณ secret_key ก่อนการเข้ารหัส เมื่อเปิดออก ผู้ใช้จะจัดเตรียม secret_key แยกต่างหาก: ไม่มีอยู่ในสำเนาของล็อคสาธารณะ

หลังจากการถอดรหัส แอปพลิเคชันจะคำนวณส่วนสาธารณะของ master_key โดยใช้ X25519 และกำหนดให้ตรงกับ secret_key จากนั้นจะกู้คืน signing_key และเปรียบเทียบส่วนสาธารณะกับคีย์ในส่วนหัว ด้วยวิธีนี้ ล็อคจะตรวจสอบตัวเอง

เพื่อชะลอการคาดเดารหัสผ่านหลัก ความพยายามแต่ละครั้งต้องใช้เวลาและหน่วยความจำ Confidex ใช้ Argon2id พร้อมหน่วยความจำ 64 MiB และ 3 รอบ การประมวลผลรหัสผ่านยังใช้เกลือแบบสุ่ม เกลือไม่ได้เป็นความลับ: มันทำให้รหัสผ่านเดียวกันให้ผลลัพธ์ที่แตกต่างกันในการล็อคที่ต่างกัน

หากทราบ secret_key อยู่แล้ว ความยาวของรหัสผ่านจะเปลี่ยนขนาดของการโจมตีอย่างมาก มีตัวอักษรละตินตัวพิมพ์เล็กแบบสุ่ม 5 ตัวรวมกันประมาณ 12 ล้านชุด ประมาณ 8 พันล้านของ 7 และประมาณ 9.5 × 10¹⁶ของ 12 การเปลี่ยนจาก 7 เป็น 12 ตัวอักษรจะเพิ่มพื้นที่การค้นหาเกือบ 12 ล้านครั้ง หากการค้นหาตัวอักษร 7 ตัวใช้เวลาโดยเฉลี่ยหนึ่งวันในเครื่องที่กำหนด 5 ตัวจะใช้เวลาประมาณสองนาที และ 12 ตัวประมาณ 33,000 ปี

หากต้องการรับหนึ่งคีย์จากผลลัพธ์ Argon2id และ secret_key เราจะใช้ฟังก์ชัน HKDF-SHA256 ที่แนะนำไปก่อนหน้านี้ โดยมีป้ายกำกับ confidex/lock/wrap/v1 ผลลัพธ์คือ wrapping_key ซึ่งเป็นกุญแจที่เข้ารหัสการล็อค

เราต้องซ่อน master_key และป้องกันไม่ให้มีการปลอมแปลง XChaCha20-Poly1305 เข้ารหัสด้วย wrapping_key และเพิ่มแท็กการตรวจสอบสิทธิ์ แท็ก ผูกข้อความไซเฟอร์เข้ากับส่วนหัวสาธารณะ: รหัสผ่านผิดหรือการเปลี่ยนแปลงไบต์ที่ได้รับการป้องกันทำให้การเปิดล้มเหลว แท็กและค่าแบบใช้ครั้งเดียวแบบสุ่ม nonce จะถูกจัดเก็บไว้พร้อมกับไซเฟอร์เท็กซ์

ทุกครั้งที่สร้างหรือเข้ารหัสการล็อคอีกครั้ง แอปพลิเคชันจะได้รับเกลือใหม่และ nonce เนื้อหาที่เข้ารหัสประกอบด้วยหนึ่งเวอร์ชันไบต์และ 32 ไบต์ของ master_key; nonce ขนาด 24 ไบต์และแท็กขนาด 16 ไบต์จะถูกเก็บไว้ข้างๆ เอกสารประกอบของอัลกอริทึม อธิบายโครงสร้าง

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

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

ห้องนิรภัย

ตอนนี้เราสามารถเผยแพร่ล็อคได้แล้ว มีเพียงคนที่รู้จัก secret_key และ master password เท่านั้นที่สามารถอ่าน master_key ได้ ในขณะที่ใครๆ ก็สามารถนำคีย์การลงนามสาธารณะจากไฟล์ล็อคและตรวจสอบข้อมูลที่ลงนามโดยไม่ต้องดูเนื้อหาของการล็อคหรือข้อมูล

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

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

จากไบต์สุ่มใหม่ แอปพลิเคชันจะสร้างคู่ X25519 ชั่วคราวสำหรับการเข้ารหัสนี้เท่านั้น: record_key จากนั้นจะนำส่วนส่วนตัวของ record_key และคีย์สาธารณะถาวรของห้องนิรภัย secret_key และคำนวณความลับที่แชร์ ฟังก์ชันที่แยกต่างหากได้รับ message_key จากความลับนั้น คีย์นี้เข้ารหัสรหัสผ่านของเรา

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

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

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

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

เราได้อธิบายโครงสร้างที่คู่ที่ไม่สมมาตรช่วยสร้างความลับร่วมกัน ในขณะที่ message_key เข้ารหัสเนื้อหา สิ่งนี้เรียกว่า Hybrid Public Key Encryption หรือ HPKE และระบุไว้ใน RFC 9180 Confidex ใช้ X25519 เพื่อยอมรับความลับ HKDF-SHA256 เพื่อรับคีย์ และ ChaCha20-Poly1305 สำหรับการเข้ารหัสด้วยการตรวจสอบความสมบูรณ์ ในที่นี้ HKDF รับความลับที่ตกลงร่วมกันโดยใช้ record_key และคู่ master_key นี่เป็นงานที่แยกต่างหากจากการได้รับ Ed25519 seed RFC 5869 อธิบาย HKDF

สำหรับการเข้ารหัสครั้งถัดไป แอปพลิเคชันจะสร้าง record_key ใหม่และบริบท HPKE ใหม่ การใช้ message_key และ nonce ร่วมกันซ้ำจะทำลายการป้องกันของการเข้ารหัส ใน Confidex คีย์และ nonce ได้รับมาจาก HPKE ซึ่งใช้สำหรับข้อความเดียว จากนั้นบริบทจะถูกละทิ้งไป

ChaCha20 เองใช้ message_key 256 บิต เพื่อให้เข้าใจถึงการโจมตีโดยตรง ลองจินตนาการถึงซูเปอร์คอมพิวเตอร์สมมติที่ทดสอบคีย์ที่เป็นไปได้ 10¹⁸ ค่าต่อวินาที การค้นหาคีย์ที่เป็นไปได้2²⁵⁶ จะใช้เวลาประมาณ 1.8 × 10⁵¹ ปี RFC 8439 อธิบายอัลกอริทึมและการวิเคราะห์

บันทึก

เรามีความสุขไหม

นิยายเยื่อกระดาษ

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

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

แฮชเชน

โครงการของคุณควรใช้บล็อกเชนไหม → ไม่

เอ็กซ์เคซีดี 2267

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

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

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

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

จำบล็อกเชนได้ไหม? นั่นสินะ :-)

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

ซิงค์

“ไม่ใช่ข้อมูลรั่วไหล เป็นการสำรองข้อมูลแบบกระจายฟรี”

มีมอินเทอร์เน็ต

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

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

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

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

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

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

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

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

การเปลี่ยนรหัสผ่านหลัก

ถ้าอย่างนั้น ศักดิ์สิทธิ์ของคุณสนใจที่จะเปลี่ยนรหัสผ่านของเธอไหม

แฮกเกอร์ (1995)

การเปลี่ยนรหัสผ่านหลักจะเข้ารหัสใหม่เฉพาะการล็อคเท่านั้น master_key ภายในยังคงเหมือนเดิม บันทึก ลายเซ็น secret_key และที่อยู่ของห้องนิรภัยจึงยังคงไม่เปลี่ยนแปลง ล็อคใหม่ได้รับการลงนามด้วย signing_key เดียวกัน

สำเนาล็อคเก่ายังคงเปิดขึ้นด้วยรหัสผ่านเก่าและ secret_key เดิม การเปลี่ยนรหัสผ่านจะไม่เพิกถอนคีย์ที่ถูกเปิดเผยแล้ว

ภาพเต็มครับ

การล็อคจะป้องกัน master_key, message_key เข้ารหัสบันทึก และ signing_key สร้างลายเซ็น ไฟล์เก็บถาวร ZIP และเซิร์ฟเวอร์ได้รับออบเจ็กต์ที่เข้ารหัสพร้อมลายเซ็น