หน้านี้ได้รับการแปลโดย Cloud Translation API

แบบพื้นฐานและอินเทอร์เฟซ

ต่อไปเราจะอธิบาย (อย่างไม่เป็นทางการ แต่เป็นทางการมากขึ้น) สองส่วนสำคัญคือ ภาษาที่ใช้ใน Tink, Primitive และ Interface

แบบพื้นฐาน

ค่าดั้งเดิมเป็นออบเจ็กต์ทางคณิตศาสตร์ที่เกี่ยวข้องกับอัลกอริทึมทั้งหมด ดำเนินการบางอย่างได้อย่างปลอดภัย ตัวอย่างเช่น AEAD Primitive ประกอบด้วย อัลกอริทึมการเข้ารหัสซึ่งเป็นไปตามคุณสมบัติด้านความปลอดภัยที่ Tink ต้องการ ของ Aead

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

อินเทอร์เฟซ

อินเทอร์เฟซคือวิธีที่เราให้ผู้ใช้ได้เข้าถึงพื้นฐาน เช่น เราคาดว่าในอนาคต Tink จะมีอินเทอร์เฟซ Mac แต่ยังใช้อินเทอร์เฟซ StreamingMac ซึ่งช่วยให้สามารถคำนวณ Mac ข้อมูลที่ไม่ได้โหลดลงในหน่วยความจำโดยตรง

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

คำจำกัดความอย่างเป็นทางการ

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

ฟังก์ชันการเข้ารหัส

แนวคิดของฟังก์ชันการเข้ารหัสไม่สำคัญเท่ากับแนวคิดของ พื้นฐาน แต่เราต้องนำมาใช้เพื่อให้นิยามของคำว่า "ดั้งเดิม" อย่างเป็นทางการ

ฟังก์ชันการเข้ารหัสลับ

ฟังก์ชันการเข้ารหัสลับเป็นแผนที่

\[ f: {\bf K} \times {\bf R} \times {\bf I} \to {\bf O}\]

จากชุด \({\bf K}\) (ช่องว่างหลัก) ชุด \({\bf R} = \{0,1\}^{\infty}\) (ความสุ่มเลือก ซึ่งเราถือว่าเป็นชุดบิตสตริงที่ไม่จำกัด) และ set \({\bf I}\) (พื้นที่อินพุต) เป็นชุด \({\bf O}\) (พื้นที่เอาต์พุต)

เราจะชัดเจนในภายหลังว่าเพราะเหตุใดเราจึงเพิ่มพารามิเตอร์การสุ่มเฉพาะ

เช่น เราจะแสดงให้เห็นความเป็นไปได้หนึ่งในการนำแนวคิดเหล่านี้ไปจับคู่กับ AES-GCM สำหรับขนาดคีย์ที่ถูกต้อง \(s_k\), ขนาด Nonce \(s_n\)และขนาดแท็ก \(s_t\), AES-GCM ประกอบด้วยฟังก์ชันการเข้ารหัส 2 ฟังก์ชัน โดยฟังก์ชันหนึ่งสำหรับ การเข้ารหัส และอีกรายการสำหรับถอดรหัส ทั้ง 2 อย่างจะมีพื้นที่คีย์เดียวกัน \({\bf K} = \{0,1\}^{s_k}\)

สำหรับฟังก์ชันการเข้ารหัส \(\mathrm{Enc}\)\(s_n\) บิตแรกของ ระบบจะใช้การสุ่มเพื่อเลือกค่าที่ได้จากการสุ่ม

อนุญาตให้ใช้ \({\bf B} = \{0,1\}^8\) แทนค่าไบต์ พื้นที่อินพุตของฟังก์ชันการเข้ารหัสคือคู่ของ \({\bf I} = {\bf B}^{*} \times {\bf B}^{*}\) คู่ของสตริงที่เป็นไบต์ที่มีความยาวที่กำหนดเอง องค์ประกอบแรกของคู่ข้อความจะเป็นข้อความ องค์ประกอบที่ 2 คือ ข้อมูลที่เกี่ยวข้อง มาตรฐาน AES-GCM มีขีดจำกัดสูงสุดเกี่ยวกับความยาวของ อินพุต แต่เราเลือกความยาวที่กำหนดเองมากกว่า และเพิ่มพิเศษ สัญลักษณ์ข้อผิดพลาด \(\bot\) ไปยังพื้นที่เอาต์พุต พื้นที่เอาต์พุตจะกลายเป็น \({\bf O} = {\bf B}^* \cup \{\bot\}\)ซึ่งเราสามารถกำหนดผลลัพธ์ของ ผลสำเร็จเป็นการเชื่อมโยงเข้าด้วยกัน \((\mathrm{IV} \| \mathrm{ciphertext} \| \mathrm{tag})\) ตามที่ระบุไว้ในมาตรฐาน และเอาต์พุต \(\bot\)ในกรณีที่อินพุตบางส่วนยาวเกินไป ดังนั้น สำหรับคีย์คงที่ ฟังก์ชันการเข้ารหัสกลายเป็นประเภท \(\mathrm{Enc}_k : {\bf R} \times {\bf B}^* \times {\bf B}^* \rightarrow {\bf B}^* \cup \{\bot\}\)

สำหรับฟังก์ชันการถอดรหัส \(\mathrm{Dec}\) ช่องว่างของคีย์จะเหมือนกัน พื้นที่อินพุตเหมือนกัน: \({\bf I} ={\bf B}^* \times {\bf B}^*\) แต่ตอนนี้ องค์ประกอบแรกควรเป็นเอาต์พุตของฟังก์ชันการเข้ารหัส ในขณะที่ข้อมูลที่ 2 จะยังเป็นข้อมูลที่เชื่อมโยงกัน

พื้นที่สำหรับกระดาษออกก็เช่นกัน \({\bf O} = {\bf B}^* \cup \{\bot\}\) (แต่บังเอิญเสียที) การตีความจะแตกต่างกันบ้าง โดยทั่วไป \(\bot\) จะหมายถึงข้อผิดพลาดในการตรวจสอบสิทธิ์ (แต่ก็เป็นข้อผิดพลาด ในกรณีที่อินพุตบางรายการยาวเกินไป)

เราตอกย้ำว่าการจัดงานแบบเป็นทางการข้างต้นไม่ใช่ตัวเลือกเดียวที่จะทำให้ มาตรฐาน ตัวอย่างเช่น บางคนอาจถือว่า Nonce เป็นส่วนหนึ่งของข้อมูลที่ป้อน แทน จากการอ่านค่าจากการสุ่ม (ซึ่งได้ผลลัพธ์ดั้งเดิมที่ต่างกันมาก) หรืออาจกำหนดเอาต์พุตเป็น 3 ตัวที่มี Nonce ข้อความเข้ารหัส และแท็ก (แทนการต่อคำ) หรืออาจมี จำกัดพื้นที่คีย์ (ตามกฎเกณฑ์) \({\bf K} = \{0,1\}^{128} \cup \{0,1\}^{256}\)

อัลกอริทึมการเข้ารหัส:

อัลกอริทึมวิทยาการเข้ารหัสลับ (แบบสมมาตร) คือ Tuple

\[(f_1, ... f_k)\]

ของฟังก์ชันการเข้ารหัส โดยที่ฟังก์ชันทั้งหมดมีพื้นที่คีย์เท่ากัน ประเภทของอัลกอริทึมการเข้ารหัสคือทูเพิล \((({\bf I}_1, {\bf O}_1), \ldots, ({\bf I}_k, {\bf O}_k))\)

ตัวอย่างเช่น สำหรับ 3 ค่า \((s_k, s_n, s_t)\) ของคีย์ ค่า Nonce และแท็กที่ถูกต้องแต่ละรายการ AES-GCM\({}_{s_k, s_n, s_t}\) เป็นอัลกอริทึมการเข้ารหัสที่มี 2 ฟังก์ชัน \(\mathrm{Enc}\) และ \(\mathrm{Dec}\) อธิบายไว้ข้างต้น

แบบพื้นฐานและอินเทอร์เฟซ

ต่อไปเราจะนิยาม Primitive ของการเข้ารหัส

แบบพื้นฐาน: พื้นฐานคือชุดอัลกอริทึมวิทยาการเข้ารหัสลับที่โดยอัลกอริทึมทั้งหมด มีประเภทเดียวกัน \((({\bf I}_1, {\bf O}_1), \ldots, ({\bf I}_k, {\bf O}_k))\)และช่องว่างที่สำคัญของอัลกอริทึมจะแยกออกเป็นส่วนๆ

ลองพิจารณา \(\mathrm{AEAD}\) ค่าพื้นฐานใน Tink มีหลาย หนึ่งในอัลกอริทึมเหล่านั้นคือ AES-GCM สำหรับคีย์ขนาด 128 และ 256 บิตที่มีค่า Nonce ขนาด 96 บิต, AES-EAX ที่มีขนาดคีย์บางขนาด และ XChaCha20Poly1305 ซึ่งมี ช่องว่างคีย์ที่ไม่ต่อเนื่อง แต่ทั้งหมดมีฟังก์ชันการเข้ารหัสเหมือนกัน \(\mathrm{Enc}\) และ \(\mathrm{Dec}\)(เราไม่เห็นถึงจุดประสงค์บางประการ การย่อขนาดหลักต่างๆ ของ AES-GCM ในการพูดคุยอย่างเป็นทางการนี้ ก็ต้องทำตามได้)

การให้นิยามของสิ่งพื้นฐาน

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

เช่น สำหรับ AEAD เราจะบอกว่า \(\mathrm{Dec}_k(\mathrm{Enc}_k(m, a), a) = m\) คือ "always" (ยกเว้นหากข้อความธรรมดา \(m\) เหมือนกัน ยาว) นอกจากนี้ เรายังมีคุณสมบัติด้านความปลอดภัย ตัวอย่างเช่น สำหรับ คีย์แบบสุ่ม การเข้ารหัสจะมี ความปลอดภัยในตัว

AEAD Primitive คือชุดของอัลกอริทึมการเข้ารหัสทั้งหมด มีคุณสมบัติเหล่านี้ กล่าวคือ ในทางปฏิบัติ เมื่อเรากำหนด พื้นฐาน เรานิยามตามสมบัติ เราไม่มีรายชื่อของ ตามที่คำจำกัดความแนะนำ

อินเทอร์เฟซ

อินเทอร์เฟซใน Tink ให้การเข้าถึงพื้นฐานในลักษณะที่ เพื่อคำนวณองค์ประกอบของพื้นที่เอาต์พุตจากพื้นที่อินพุต ตัวอย่างเช่น พิจารณาอินเทอร์เฟซ AEAD ใน Java ดังนี้

public interface Aead {
  byte[] encrypt(byte[] plaintext, byte[] associated_data) throws GeneralSecurityException;
  byte[] decrypt(byte[] ciphertext, byte[] associated_data) throws GeneralSecurityException;
}

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

บางครั้ง Tink มีหลายอินเทอร์เฟซสําหรับ 1 แหล่งกำเนิด ซึ่งอาจเป็นประโยชน์มาก เนื่องจากข้อกำหนดอาจแตกต่างกันไปในบางครั้ง แต่ก็ยังทำได้อยู่ มีราคาต่ำ: โดยทั่วไป ยิ่งอินเทอร์เฟซหนึ่งๆ นำเสนอมากเท่าไหร่ ยิ่งมีอินเทอร์เฟซที่หลากหลาย ความสามารถในการทำงานร่วมกัน ตัวอย่างเช่น สมมติว่า เขียนไลบรารีโดยใช้ Tink ซึ่งกำหนดให้ผู้ใช้ส่ง ออบเจ็กต์ Aead รายการ (เพื่อเข้ารหัสภายในบางอย่าง) หาก Tink เสนอบริการมากเกินไป อินเทอร์เฟซที่แตกต่างกันกับ \(\mathrm{AEAD}\) พื้นฐาน มีโอกาสสูงที่จะ ที่ผู้ใช้ ไม่มีอินสแตนซ์ที่พร้อมใช้งานสำหรับคีย์ที่ผู้ใช้เลือกและ ไปพร้อมๆ กัน ดังนั้น การเพิ่มอินเทอร์เฟซจึงเป็นข้อดี

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