การแนะนำ

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

ZK-SNARK สำหรับพหุนาม

เราจะสร้าง zk-SNARK ทีละขั้นตอน โดยเริ่มจากการสร้างที่เรียบง่ายกว่าซึ่งไม่ใช่ SNARK แล้วปรับปรุงด้วยเทคนิคใหม่จนกว่าจะบรรลุวัตถุประสงค์ของเรา

ขั้นตอนแรก: Schwartz - บทแทรก Zippel

เราต้องการสร้างโปรโตคอลที่อนุญาตให้ผู้พิสูจน์ P โน้มน้าวผู้ตรวจสอบ V เกี่ยวกับความรู้ของพหุนามเฉพาะของดีกรี n ด้วยสัมประสิทธิ์ในฟิลด์จำกัด F กล่าวอีกนัยหนึ่ง P ต้องการโน้มน้าวให้ V รู้ว่าเขารู้พหุนามของรูปแบบ

สมมติว่า a_1, a_2, … , a_n ∈ F เป็นราก n ของพหุนามนี้ ดังนั้น p(x) สามารถเขียนเป็น

สมมติว่า V รู้ d < n รากของพหุนาม p(x)

จากนั้นเราสามารถจัดรูปแบบโจทย์ของเราใหม่ได้ ตอนนี้ P ต้องการพิสูจน์ให้ V เห็นว่าเขารู้พหุนาม h(x) เช่นนั้น

พหุนาม t(x) จะถูกเรียกว่าพหุนามเป้าหมาย สังเกตว่ามีรูปแบบ

เวอร์ชันแรกของ zk-SNARK อิงจาก Schwartz — Zippel lemma: ให้ F เป็นฟิลด์ และ f: F^m → F เป็นพหุนามหลายตัวแปรของดีกรี n จากนั้น สำหรับเซตจำกัดใดๆ S ⊆ F:

สิ่งที่บทแทรกแสดงให้เห็นคือถ้าเราสุ่ม u ∈ Sm อย่างสม่ำเสมอ ความน่าจะเป็นที่ u จะเป็นเซตของรูทสำหรับ f นั้นมีค่ามากที่สุดที่ n / |S| สังเกตว่าความน่าจะเป็นนี้น้อยมากหากเราถือว่า S เป็นฟิลด์จำกัด F ขนาดฟิลด์จะใหญ่มากเมื่อเทียบกับ n

อาจดูขัดแย้งกันแต่บทแทรกนี้ช่วยให้เราสามารถพิสูจน์ความรู้เรื่องพหุนาม f เราไม่จำเป็นต้องพิสูจน์ว่าเรารู้ค่าสัมประสิทธิ์ทั้งหมดของ p แต่เรารู้วิธีคำนวณคู่ (s, f(s)) สำหรับ s ∈ Fm ใดๆ Schwartz — Zippel lemma ให้ประสิทธิภาพที่จำเป็นใน zk-SNARK ของเรา

โปรโตคอลแรก

เราจำได้ว่า P รู้พหุนาม p(x) และ V รู้ d < n รากของ p(x) หรือเทียบเท่า V รู้พหุนามเป้าหมาย t(x) P ยังรู้จัก t(x)

แนวทางแรกของเรามีดังนี้:

1. V ใช้ค่าสุ่ม s และคำนวณ t = t(s) V ส่ง s ให้ P
2. P คำนวณพหุนาม

4. V ตรวจสอบว่าความเท่าเทียมกัน p = t · h.

โปรโตคอลนี้ถูกต้อง เนื่องจากถ้า P รู้พหุนาม p(x) เขาก็สามารถคำนวณ h(x) ได้ ดังนั้น P จึงสามารถคำนวณค่า h และ p ในลักษณะที่ p = h · t ในทางกลับกัน โปรโตคอลนี้ก็มีประสิทธิภาพเช่นกัน เนื่องจาก Schwartz — Zippel lemma

อย่างไรก็ตาม โปรโตคอลนี้ไม่มีประสิทธิภาพเนื่องจากผู้พิสูจน์สามารถคำนวณ t = t(s) โดยใช้พหุนามเป้าหมาย แม้ว่า P จะไม่รู้จัก p(x) ก็ตาม เขาสามารถสุ่ม h และคำนวณ p = h · t และส่งคู่ (h, p) ไปยัง V ซึ่งจะยอมรับว่าคู่นั้นถูกต้อง

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

ขั้นตอนที่สอง: การทำให้งงงวยแบบโฮโมมอร์ฟิค

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

เราจะทำเช่นนั้นโดยอาศัยความแข็งของปัญหาลอการิทึมที่ไม่ต่อเนื่อง สำหรับคอมพิวเตอร์แบบดั้งเดิม ปัญหาลอการิทึมไม่ต่อเนื่องนั้นไม่สามารถคำนวณได้: ในกลุ่มวงจร G ลำดับ p และสร้างโดยองค์ประกอบ g โดยกำหนดองค์ประกอบ a ที่ = ga (mod p) สำหรับ ที่รู้จัก

ดังนั้น สมมติความแข็งของพหุนามลอการิทึมแยก เราสามารถทำให้ค่า a สับสนได้โดยการคำนวณ = ga (mod p) ตัวรับ เพียงอย่างเดียวไม่สามารถเรียนรู้ค่า a ประเด็นที่น่าสนใจของเทคนิคนี้คือการยกกำลังมีคุณสมบัติโฮโมมอร์ฟิคบางประการ:

ผลคูณของค่าที่คลุมเครือสองค่าจะเหมือนกับการทำให้งงงวยของการเพิ่มค่าที่เกี่ยวข้องอย่างชัดเจน

ถ้าเราต้องการหาค่าพหุนาม

บนจุด x = s โดยไม่แจ้งให้ผู้ประเมินทราบจุดที่แน่นอน เราจำเป็นต้องทำให้พหุนามทั้งหมดสับสน:

นอกจากนี้ เรายังจำเป็นต้องคำนวณกำลังจาก 1 ถึงดีกรีของพหุนาม ของค่าที่สับสนทั้งหมดสำหรับ x = r นั่นคือ:

สังเกตว่าด้วยองค์ประกอบทั้งหมดเหล่านี้ ตอนนี้เราสามารถคำนวณการประเมินพหุนาม p บนจุด x =r ที่คลุมเครือได้แล้ว อย่างแท้จริง:

ตัวอย่างของการซ่อนโฮโมมอร์ฟิค

ลองพิจารณาฟิลด์จำกัด F = ℤ127 และ g = 3 เครื่องกำเนิดไฟฟ้า สมมติว่า P รู้พหุนาม p(x) = 4x2 + 3x + 1 และ V ต้องการให้ P ประเมินพหุนามบนจุด x = 2 โดยไม่ให้ P รู้จุด เราสามารถทำได้ตามขั้นตอนต่อไปนี้

1. V คำนวณกำลังทั้งหมดของ x = 2 จาก 0 ถึงดีกรีของพหุนาม n = 2:

1.b. 32 (สมัย 127) = 9

1.ค. 34 (สมัย 127) = 81

และส่งคู่ (9, 81) ไปที่ P.

2. P สามารถคำนวณค่าของ p(x) บน x = 2 โดยไม่ทราบค่าของ x แท้จริงแล้ว โดยใช้ข้อมูลที่ได้รับจาก V เขาสามารถคำนวณ:

โปรโตคอลที่สอง

ตอนนี้เรารู้วิธีทำให้จุดสับสนเพื่อให้ผู้พิสูจน์สามารถประเมินพหุนามบนจุดที่สับสนได้ เราจะปรับปรุงโปรโตคอลแรก เราจำได้ว่า P รู้พหุนาม p(x) และ V รู้ d < n รากของ p(x) หรือเทียบเท่า V รู้พหุนามเป้าหมาย t(x) P ยังรู้จัก t(x)

โปรโตคอลที่สองของเรามีดังนี้:

1. V ใช้ค่าสุ่ม s และคำนวณ t = t(s)
2. V คำนวณและส่งพลังต่อไปนี้ให้ P:

4. ใช้ค่า , P คำนวณ g^p = g^{p(s)} และ g^h = g*{h(s)} โดยใช้คำสั่งของตัวอย่างก่อนหน้า

5. P ส่ง g^p และ g^h ไปยัง V

6. V ตรวจสอบว่ามีตัวตนต่อไปนี้หรือไม่: g^p = (g^h)^t

สังเกตว่าข้อบกพร่องที่ตรวจพบในโปรโตคอลแรกได้รับการแก้ไขแล้ว แต่โปรโตคอลที่สองนี้ยังไม่แข็งแกร่ง จริงๆ แล้ว P ยังคงสามารถใช้ค่า zp และ zh ในลักษณะที่ z_p = (z_h)^t และส่งค่าเหล่านี้ไปยัง V เหมือนกับว่ามีค่าเป็น g^p และ g^h P ทำได้โดยการสุ่ม r คำนวณ z_h = g^r และตั้งค่า z_p = (g^t)^r ค่า z_p สามารถคำนวณได้โดยใช้กำลังที่สับสนซึ่งส่งมาจาก V

เพื่อหลีกเลี่ยงสถานการณ์นี้ เราจำเป็นต้องตรวจสอบให้แน่ใจว่า g^p และ g^h คำนวณโดยใช้เฉพาะพลังที่สับสนซึ่งส่งมาโดย V

ขั้นตอนที่สาม: สมมติฐานความรู้ของเลขยกกำลัง

มีข้อสันนิษฐานทั่วไปข้อหนึ่งในการนิยาม SNARK: ให้เราพิจารณาจำนวนเฉพาะ q โดยที่ 2q + 1 ก็เป็นจำนวนเฉพาะเช่นกัน ให้เราพิจารณาตัวกำเนิด ga ของ ℤ_{2q + 1} ให้ q, g และ g' = g^ เราต้องการหาคู่ (x, y) ที่ทำให้ x ≠ g, y ≠ g' และ y = x^ สมมติฐานความรู้ของเลขยกกำลัง (KEA) กล่าวว่าวิธีเดียวที่จะหาคู่ (x, y) คือการหาค่า c ∈ ℤ_q โดยคำนวณ x = g^c ก่อนแล้วจึงหา y = (g')^ ค.

KEA หมายความว่าหากต้องการได้คู่ (x, y) วิธีเดียวที่จะทำได้คือการรู้เลขชี้กำลัง c ซึ่ง x = g^c กล่าวอีกนัยหนึ่ง เราสามารถหาคู่ (x, y) ด้วยคุณสมบัติ KEA ได้โดยใช้กำลังของ g

การใช้โปรโตคอล KEA ด้านล่างช่วยให้แน่ใจว่า P ส่งคืนค่ากำลังเฉพาะของ g ซึ่งเป็นตัวกำเนิดของกลุ่มย่อยแบบทวีคูณ จัดส่งโดย V:

1. V ใช้ค่าสุ่ม และคำนวณ g' = g^ (mod 2q + 1)
2. V ส่งคู่ (g, g') ไปยัง P และขอคู่ (b, b') เพื่อให้ (b, b') = (g, g')
3. P รับค่า c และคำนวณ b = g^c (mod 2q + 1), b' = (g')^c (mod 2q + 1) และส่งคู่ (b, b') ไปยัง V
4. V ตรวจสอบว่า b' = b^ (mod 2q + 1) หรือไม่

P ใช้กำลัง c เท่ากันสำหรับทั้ง g และ g' และเขาสามารถใช้ค่าที่ส่งโดย V เท่านั้น

โปรโตคอลที่สาม

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

1. V ใช้ค่าสุ่ม s และคำนวณ t = t(s)
2. V ใช้ค่าสุ่ม และคำนวณ t( · s)
3. V คำนวณชุดค่าที่คลุมเครือต่อไปนี้ และส่งไปยัง P
4. V คำนวณชุดของค่าที่คลุมเครือต่อไปนี้

5. P คำนวณพหุนาม h(x)

6. การใช้ , P คำนวณ p(s) และ h(s) ร่วมกับ g^p = g^{p(s)} และ g^h = g^{h(s)}

7. ใช้ P คำนวณ p(s) และ h(s) ร่วมกับ g^{p'} = g^{p( · s)}

8. P ส่ง g^p, g^h และ g^{p'} ไปยัง V

9. V ตรวจสอบว่า P ทำการคำนวณค่าที่สับสนโดยใช้ข้อมูลที่เขาส่งไปให้เขาเท่านั้น ในการทำเช่นนั้น V จะตรวจสอบว่า g^p = g^{p'} หรือไม่

10. V ตรวจสอบว่ามีตัวตนต่อไปนี้หรือไม่: g^p = (g^h)^{t(s)}

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

หมายเหตุ:ขั้นตอนที่ 6 และ 7 ในโปรโตคอลด้านบนทำตามตัวอย่างการซ่อนโฮโมมอร์ฟิค

ไม่มีความรู้

ในโปรโตคอลที่เรานำเสนอจนถึงตอนนี้ ค่าสัมประสิทธิ์ ci ของพหุนามที่ P รู้จักนั้นมีความเฉพาะเจาะจงมาก และ V สามารถพยายามเรียนรู้ข้อมูลบางอย่างเกี่ยวกับพวกมันโดยใช้ gp, gh และ gp' ที่มาจาก P ดังนั้น เพื่อให้ P แน่ใจ ที่ V จะไม่เรียนรู้อะไรเลย P จำเป็นต้องซ่อนค่าเหล่านี้

กลยุทธ์ในการซ่อนค่าที่ส่งโดย P ทำตามขั้นตอนที่ใช้ก่อนหน้านี้: P ใช้การสุ่ม และใช้เพื่อซ่อนค่าที่ส่งในการสื่อสารกับ V เพื่อให้แม่นยำ แทนที่จะส่ง g^p, g^h และ g ^{p'}, P คำนวณและส่ง (g^p)^, (g^h)^ และ (g^{p'})^ จากนั้น V จะทำการตรวจสอบค่าที่ซ่อนอยู่ภายใต้

ขั้นตอนการยืนยันที่ V จำเป็นต้องเรียกใช้ยังคงใช้ได้กับการซ่อนนี้:

ดังนั้นเพื่อให้โปรโตคอลที่สามไม่มีความรู้ โปรโตคอลหนึ่งจะแทนที่ขั้นตอนที่ 8 เพื่อให้ P สามารถส่งค่าที่คลุมเครือได้

ไม่โต้ตอบ

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

หากเราต้องการทำซ้ำโปรโตคอลใดๆ ข้างต้นด้วยตัวตรวจสอบ V' ตัวอื่น V' จะต้องเลือกค่าใหม่ s' และ ' การใช้ค่าที่สร้างโดย V อาจทำให้ P สามารถโกงได้หากเขาสมรู้ร่วมคิดกับ V และ V เปิดเผยค่า s และ ถึง P

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

เราจะแนะนำการจับคู่เพื่อแก้ปัญหานี้ จำไว้ว่าการจับคู่มีคุณสมบัติดังต่อไปนี้:

คุณสมบัตินี้เปิดใช้งานการตรวจสอบความเท่าเทียมกันของผลิตภัณฑ์ในโดเมนที่คลุมเครือ

ดังนั้นในการทำให้โปรโตคอลของเราไม่โต้ตอบ ขั้นตอนแรกคือการใช้ค่าสุ่มลับ s และ และทำให้สับสน: g^, และ

เมื่อเราคำนวณพลังเหล่านี้แล้ว เราสามารถกำจัดค่าลับ s และ และเผยแพร่ค่าที่สับสนได้ ซึ่งเรียกว่า Common Reference String (CRS) ค่า CRS มักจะเก็บไว้เป็น:

1. คีย์การประเมิน: (, )
2. รหัสยืนยัน: (g^, g^{t(s)})

โปรโตคอลขั้นสุดท้าย: zk-SNARK สำหรับความรู้เกี่ยวกับพหุนาม

ตอนนี้เรากำหนด zk-SNARK เพื่อพิสูจน์ความรู้เกี่ยวกับพหุนาม p(x) ของดีกรี n ที่กำหนดพหุนามเป้าหมาย t(x)

การตั้งค่าพารามิเตอร์

1. แต่ละฝ่ายรับค่าลับสองค่า s และ โดยการสุ่ม
2. แต่ละฝ่ายคำนวณ g, และ
3. ค่า s และ ถูกทำลาย
4. หนึ่งออกอากาศคีย์การประเมินผล ( และ )
5. หนึ่งออกอากาศรหัสยืนยัน g^, g^{t(s)}

1. สมมติว่า P รู้ p(x) P จะคำนวณพหุนาม h(x)
2. P ประเมิน p(x) และ h(x) และคำนวณ gp(s) และ gh(s) โดยใช้ค่าที่มีอยู่ในคีย์การประเมิน
3. P คำนวณค่า g^{p( · s)} โดยใช้คีย์การประเมิน
4. P รับค่าสุ่ม
5. P ออกอากาศหลักฐาน π = (g^{ · p(s)}, g^{ · h(s)}, g^{ · p( · s)}) = (g^{ · p }, g^{ · h}, g^{ · p'}).

สมมติว่า V สามารถเข้าถึง π = (g^{ · p}, g^{ · h}, g^{ · p'}) จะตรวจสอบว่า

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

การสร้างครส

Zk-SNARK สามารถทำให้ไม่โต้ตอบได้โดยใช้ชุดของค่าที่ซ่อนอยู่ ซึ่งเรียกว่า Common Reference String (CRS) ค่าที่ซ่อนอยู่เหล่านี้ ซึ่งในกรณีของเราอยู่ในรูปแบบ และ มาจากค่าลับ s และ ซึ่งจะต้องถูกทำลายเมื่อได้รับค่าที่ซ่อนอยู่แล้ว สังเกตว่าการสร้าง CRS นั้นมีความสำคัญอย่างยิ่ง เนื่องจากหากมีคนมอบหมายรุ่นให้กับผู้เข้าร่วมคนที่สาม ทุกคนต้องวางใจว่าผู้เข้าร่วมจะทำลายค่านิยม s และ บุคคลที่สามแสดงถึงความล้มเหลวเพียงจุดเดียว

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

ลองใช้ CRS สำหรับ SNARK ที่เราสร้างไว้ในตัวอย่างก่อนหน้า เราจำได้ว่าการใช้ s และ เป็นความลับ เราจำเป็นต้องคำนวณค่าและพลังที่ซ่อนอยู่ g^, และ

ในโปรโตคอลใหม่ของเรา เราจะแทนที่ค่า s และ ที่สร้างโดยบุคคลที่สามเพียงรายเดียว ด้วยค่า s_{ABC} และ _{ABC} ที่สร้างโดยผู้ใช้ 3 ราย A, B และ C การขยายกลไกไปยังผู้ใช้ n รายนั้นตรงไปตรงมา .

โปรโตคอลดังต่อไปนี้:

1. ผู้ใช้ A สร้างคู่ (sA, A) คำนวณและออกอากาศ:

3. B ออกอากาศ:

4. C ใช้คู่สุ่ม (sC, C) คำนวณและออกอากาศ:

โปรโตคอลนี้สร้างค่าที่ซ่อนอยู่สำหรับ s_{ABC} = s_A · s_B · s_C และ _{ABC} = _A · _B · _C โดยไม่มีผู้เข้าร่วมแม้แต่คนเดียวที่ทราบค่าคู่นี้

อย่างไรก็ตาม เราต้องการโปรโตคอลที่ช่วยให้ผู้เข้าร่วมตรวจสอบได้ว่าค่าที่ซ่อนอยู่เหล่านั้นถูกคำนวณอย่างถูกต้อง เราจำเป็นต้องตรวจสอบให้แน่ใจว่าค่าที่สร้างโดยผู้ใช้แต่ละคนเป็นไปตามข้อกำหนด นั่นคือชุดของค่า เป็นกำลังของ gs สำหรับค่า s ของผู้ใช้แต่ละราย และชุด นั้นคำนวณอย่างถูกต้อง ในการทำเช่นนั้น เราตรวจสอบว่าแต่ละ (g^s)^i มีค่าเท่ากับกำลัง i-th ของ gs ซึ่งสามารถทำได้โดยตรวจสอบว่ามีความเท่าเทียมกันดังต่อไปนี้ ผู้เข้าร่วมแต่ละคนดำเนินการตรวจสอบนี้สำหรับค่าทั้งหมด sU และ U ที่เชื่อมโยงกับผู้เข้าร่วมแต่ละคน U:

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

บทสรุป

จนถึงตอนนี้ เราได้เรียนรู้วิธีสร้าง SNARK ตั้งแต่เริ่มต้นและด้วยรายละเอียดทั้งหมด เพื่อพิสูจน์ความรู้เกี่ยวกับพหุนาม ในโพสต์ถัดไป บทความสุดท้าย เราจะขยายโครงสร้างข้างต้นไปยังการคำนวณใดๆ ในการทำเช่นนั้น เราจะแนะนำแนวคิดหลักสองแนวคิด: โปรแกรมเลขคณิตกำลังสอง, QAP และระบบข้อจำกัดอันดับ 1, R1CS แม้ว่าจะไม่ได้แนะนำอย่างหลังอย่างเจาะจง (จะปรากฏเป็นข้อความอ่อนเกิน)

อ้างอิง

Jordi Herrera Joancomartí, Cristina Pérez Solà, Criptografia avançada บันทึกการบรรยาย. มหาวิทยาลัยเปิดแห่งคาตาโลเนีย 2022