การเข้ารหัส homomorphic สามารถนำไปใช้สำหรับการประมวลผลรหัสที่ลืมเลือนได้หรือไม่?

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

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

ด้วยการเรียกใช้โค้ดที่ลืมเลือนฉันหมายความว่าเราเข้ารหัสชิ้นส่วนของรหัสออกแบบมาเพื่อแก้ปัญหาPและส่งไปยังสภาพแวดล้อมที่เป็นมิตร ฝ่ายตรงข้ามต้องการใช้Cเพื่อแก้Pแต่เราไม่ต้องการให้เขารู้ว่าCทำงานอย่างไร หากเขามีอินพุตIสำหรับPเขาสามารถเข้ารหัสIแล้วใช้ (รูปแบบการเข้ารหัสบางส่วน) CกับIซึ่งจะส่งคืนเอาต์พุต (ไม่เข้ารหัส) O (โซลูชันของPสำหรับอินพุต$C$$P$$C$$P$$C$$I$$P$$I$$C$$I$$O$$P$$I$) รูปแบบการเข้ารหัสทำให้แน่ใจว่าฝ่ายตรงข้ามไม่เคยรู้ว่าชิ้นส่วนของโค้ดทำงานอย่างไร

การใช้ประโยชน์หลัก ๆ (ฉันนึกถึง) สำหรับรูปแบบการเข้ารหัสนั้นจะทำให้การละเมิดลิขสิทธิ์ทำได้ยากขึ้นหรือเป็นไปไม่ได้

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

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

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

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

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

น่าเสียดายที่มีผลลัพธ์ที่ทางทฤษฎีห้าม "การเรียกใช้โค้ดที่ลืมเลือน":

Boaz Barak, Oded Goldreich, Russell Impagliazzo, Steven Rudich, Amit Sahai, Salil Vadhan และ Ke Yang ในความเป็นไปได้ (Im) ของโปรแกรมที่ทำให้งงงวย , ความก้าวหน้าทางจิตวิทยา - CRYPTO 2001

นี่คือลิงค์:

• http://www.wisdom.weizmann.ac.il/~oded/p_obfuscate.html
• http://eprint.iacr.org/2001/069
• http://www.springerlink.com/content/telalqdcx3n600uf/

นามธรรมอ่าน:

อย่างไม่เป็นทางการ obfuscator คือ "คอมไพเลอร์" ที่มีประสิทธิภาพ (น่าจะเป็น) ที่ใช้เป็นอินพุตโปรแกรม (หรือวงจร) Pและสร้างโปรแกรมใหม่O ( P )ที่มีฟังก์ชั่นเช่นเดียวกับPแต่ก็เป็น "ไม่สามารถอ่านได้" ในบางกรณี . ถ้าพวกมันมี Obfuscators จะมีแอปพลิเคชั่นการเข้ารหัสและความซับซ้อน - ทางทฤษฎีที่หลากหลายตั้งแต่การปกป้องซอฟต์แวร์ไปจนถึงการเข้ารหัสโฮโมมอร์ฟิคจนถึงการอะนาล็อกเชิงทฤษฎีที่ซับซ้อนของข้าว แอปพลิเคชันส่วนใหญ่ขึ้นอยู่กับการตีความเงื่อนไข "ไม่สามารถอ่านได้" ในการทำให้งงงวยซึ่งหมายถึงO ( P $\cal O$$P$$\cal O(P)$$P$$\cal O(P)$เป็น "กล่องดำเสมือนจริง" ในแง่ที่ว่าสิ่งใดก็ตามที่สามารถคำนวณได้อย่างมีประสิทธิภาพเมื่อได้รับเราสามารถคำนวณ oracle ที่ได้รับจากการเข้าถึงPได้อย่างมีประสิทธิภาพ$\cal O(P)$$P$

ในงานนี้เราเริ่มต้นการตรวจสอบเชิงทฤษฎีของการทำให้งงงวย ผลลัพธ์หลักของเราคือแม้ภายใต้ความเชื่อที่เข้มงวดมากของปรีชาข้างต้นการทำให้งงงวยเป็นไปไม่ได้ เราพิสูจน์สิ่งนี้โดยการสร้างตระกูลของฟังก์ชันที่ไม่สามารถหาได้โดยธรรมชาติในแง่ต่อไปนี้: มีภาคแสดงπที่ (a) ให้โปรแกรมใด ๆ ที่คำนวณฟังก์ชันfในF , ค่าπ ( f )สามารถคำนวณได้อย่างมีประสิทธิภาพ , แต่ (b) ให้ oracle เข้าถึงฟังก์ชั่น (เลือกแบบสุ่ม) fในF , อัลกอริทึมที่มีประสิทธิภาพไม่สามารถคำนวณπ ( f $\cal F$$\pi$$f$$\cal F$$\pi(f)$$f$$\cal F$$\pi(f)$ ดีกว่าการคาดเดาแบบสุ่ม

เราขยายผลไปไม่ได้ของเราในหลาย ๆ ด้านรวมทั้ง obfuscators แม้กระทั่งว่า (ก) ไม่จำเป็นต้องคำนวณในเวลาพหุนาม (ข) เพียงประมาณรักษาฟังก์ชันการทำงานและ (ค) ต้องการเพียงที่จะทำงานสำหรับรุ่นที่ จำกัด มากของการคำนวณ 0 ) นอกจากนี้เรายังแยกแอพพลิเคชั่นที่เป็นไปได้หลายอย่างของ obfuscators โดยสร้าง "ลายเซ็น" unobfuscatable "แบบแผนการเข้ารหัสแบบเข้ารหัส$\rm{TC}$ $0$

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

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

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

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

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