RAM-LFE

RAM-LFE stands for Random-Access Machine Laconic Function Evaluation. in Iroha, ეს არის ზოგადი დამალული ფუნქციის ფენა პროგრამებისთვის, რომელთა საჯარო პოლიტიკაა ჯაჭვზე, მაგრამ რომლის შეფასებელი ლოგიკა, საიდუმლო ან ნედლეულის შემოტანა არ უნდა იყოს დაწერილი მსოფლიო სახელმწიფოსთვის. იგი გამოიყენება SORA Nexus იდენტიფიკატორის ნაკადებით, როგორიცაა კერძო ტელეფონის ან ელ.ფოსტის ძებნა და ასევე შეიძლება გამოჩნდეს როგორც ზოგადი Torii პროგრამის შესრულების დამხმარე, როდესაც ბმულის პროფილი საშუალებას აძლევს აპლიკაციის მიმართულებით მარშრუტებს.

ჯაჭვი ინახავს პოლიტიკის ვალდებულებისა და მიღების შემოწმების მეტადატას. გადამწყვეტი ან Torii runtime აფასებს დამალულ პროგრამას, იბრუნებს მხოლოდ ნებადართული გამოსავალს და ამატებს ქვითარს, რომელსაც კლიენტები, მხარდაჭერის ინსტრუმენტები ან მთავრობის ინსტრუქციები შეუძლიათ შემოწმონ რეგისტრირებული პოლიტიკაზე.

დასახელება

დასახელების განცალკევება მნიშვნელოვანია:

ტერმინი	მნიშვნელობა
ram_lfe	გარე დამალული ფუნქციის აბსტრაქცია: პროგრამის პოლიტიკა, ვალდებულებები, შესრულების მიღება და მიღების შემოწმების რეჟიმი.
BFV	Brakerski/Fan-Vercauteren ჰომორფული დაშიფვრის სქემა, რომელიც გამოიყენება კოდირებული შესასვლელი RAM-LFE ბეგენდებით.
ram_fhe_profile	BFV -ის სპეციფიკური მეტა მონაცემები პროგრამირებული დაშიფრული შესრულების მანქანისთვის. ეს არ არის RAM-LFE-ის მეორე სახელი.

მონაცემთა მოდელში RamLfeProgramPolicy და RamLfeExecutionReceipt არის RAM-LFE ტიპები. BFV პარამეტრები, ციფრული ტექსტის კონვერტები და დამალული RAM-FHE პროგრამის პროფილი ეკუთვნის პოლიტიკით გამოყენებულ კოდირებულ შესრულების ფარდობას.

რა დაფიქსირდა

RAM-LFE პროგრამის პოლიტიკა გლობალურად რეგისტრირებულია program_id. პოლიტიკა შეიცავს:

• მეპატრონე ანგარიში, რომელსაც შეუძლია პოლიტიკის გააქტიურება, დეაქტივაცია ან სხვაგვარად შეცვლა;
• მომხმარებლისთვის რეკლამირებული უკანა მხარე
• მიღების შემოწმების რეჟიმი, ან signed ან proof
• ჩართულობა დამალული პროგრამის მეტა მონაცემებისა და შეფასებლის საიდუმლოების მიმართ
• რეზოლუციის საჯარო გასაღები ხელმოწერილი ქვითრებისათვის
• საჯარო დაშიფვრილი შესასვლელი მეტა მონაცემები, როგორიცაა BFV პარამეტრები და ram_fhe_profile
• active დროშა, რომელიც აკონტროლებს, შეუძლია თუ არა პოლიციას ახალი ქვითრების გაცემა

დამალული საიდუმლო, ღია ტექსტის იდენტიფიკატორის ღირებულება და დამალული პროგრამის სხეული არ ინახება მსოფლიო მდგომარეობაში. კლიენტებმა უნდა განიხილონ ვალდებულებები, არაგამჭვირვალე ჰაშები, მიღების ჰეშები, ციფრული ტექსტები და პროგრამის დიჟეტები როგორც არაგამჭრელი პროტოკოლის მნიშვნელობები.

უკანასკნელი ამბები

ამჟამინდელი RAM-LFE მხარდაჭერა ორიენტირებულია სამი უკანასკნელი იდენტიფიკატორზე:

უკანასკნელი	გამოყენება
hkdf-sha3-512-prf-v1	PRF ვალდებულების გათვალისწინებით შეფასება.
bfv-affine-sha3-256-v1	BFV მხარდაჭერილი საიდუმლო აფინის შეფასება კრიფტირებული იდენტიფიკატორი slots.
bfv-programmed-sha3-256-v1	BFV მხარდაჭერილი პროგრამული აღსრულება კოდირებული რეგისტრების და მეხსიერების ბილიკებზე.

იდენტიფიკატორის პოლიტიკისთვის, პროგრამირებული BFV უკანა კუთხე არის მნიშვნელოვანი თანამედროვე გზა. ეს საშუალებას აძლევს ქაღალდებს დაშიფვრა ნორმალიზებული შესავალი ადგილობრივად, საშუალებას აძლევთ მრეცხველს შეაფასოს გარეშე საჯარო იდენტიფექტორი ტრანზაქციაში, და უბრუნებს ქვითარს, რომელიც უკავშირდება გამომავალი ჰეშის რეგისტრირებულ პროგრამულ პოლიტიკას.

მათემატიკის

ამ განყოფილებაში აღწერილია იმპლემენტაციის დონეზე გამოყენებული ალგებრა, რომელიც გამოიყენება მიმდინარე RAM-LFE კოდში. ეს არ არის უსაფრთხოების მტკიცებულება; ეს არის დეტერმინისტური ტრანსკრიპტი და ჩიფრული შეფასების მოდელი, რომელზეც პოლიტიკა, მიღებები და კლიენტები უნდა შეთანხმდნენ.

ნოტაცია

გაშვება:

• (H(m)) იყოს Iroha Hash::new(m): Blake2b-32 over m, საბოლოო ბაიტის ყველაზე ნაკლებად მნიშვნელოვანი ბიტი იძულებული იქნება 1.
• (N(x)) უნდა იყოს კანონიკური Norito კოდირება x.
• (a \parallel b) საშუალო ბაიტური სიმბოლოების კონკეტინაცია.
• (\operatorname{le64}(i) ) იყოს 8-ბაიტიანი მცირე ენდიანული კოდირება უმოწერილი მთელი რიცხვი.
• (s) იყოს გამჭრელი საიდუმლო შენახული გარეთ სამყაროს სახელმწიფო.
• (P) უნდა იყოს საჯარო პოლიტიკის პარამეტრები.
• (A) უნდა მოითხოვოს დაკავშირებული მონაცემები.
• (x) უნდა იყოს ნორმალიზებული შესასვლელი ბაიტები ან Norito-ის კოდირებული დაშიფრული შესასვლელის ფურცელი, რაც დამოკიდებულია უკანა ბოლოზე.

RAM-LFE იყენებს დომენისგან განცალკევებულ ჰეშებს. ქვემოთ მოცემული ფორმულები დასახელებენ დომენებს მიზნით; მათი ამჟამინდელი ბაიტების სიმბოლოებია:

სიმბოლო	დომენის სტრიქონები
(D_{\mathrm{policy}})	iroha.ram_lfe.policy.hkdf_sha3_512_prf.v1
(D_{\mathrm{secret}})	iroha.ram_lfe.policy_secret.hkdf_sha3_512_prf.v1
(D_{\mathrm{salt}})	iroha.ram_lfe.hkdf_salt.hkdf_sha3_512_prf.v1
(D_{\mathrm{hkdf_opaque}})	iroha.ram_lfe.opaque_info.hkdf_sha3_512_prf.v1
(D_{\mathrm{hkdf_receipt}})	iroha.ram_lfe.receipt_info.hkdf_sha3_512_prf.v1
(D_{\mathrm{opaque}})	iroha.ram_lfe.opaque_hash.hkdf_sha3_512_prf.v1
(D_{\mathrm{receipt}})	iroha.ram_lfe.receipt_hash.hkdf_sha3_512_prf.v1
(D_{\mathrm{affine_circuit}})	iroha.ram_lfe.bfv_affine.circuit.v1
(D_{\mathrm{affine_opaque}})	iroha.ram_lfe.bfv_affine.opaque_hash.v1
(D_{\mathrm{affine_receipt}})	iroha.ram_lfe.bfv_affine.receipt_hash.v1
(D_{\mathrm{program_memory}})	iroha.ram_lfe.bfv_program.memory.v1
(D_{\mathrm{program_opaque}})	iroha.ram_lfe.bfv_program.opaque_hash.v1
(D_{\mathrm{program_receipt}})	iroha.ram_lfe.bfv_program.receipt_hash.v1
(D_{\mathrm{program_digest}})	iroha.ram_lfe.bfv_program.digest.v1
(D_{\mathrm{output}})	iroha.ram_lfe.output_hash.v1
(D_{\mathrm{id_opaque}})	iroha.ram_lfe.identifier.opaque_hash.v1
(D_{\mathrm{id_receipt}})	iroha.ram_lfe.identifier.receipt_hash.v1
(D_{\mathrm{bfv_keygen}})	iroha.crypto.fhe.bfv.keygen.v1
(D_{\mathrm{bfv_encrypt}})	iroha.crypto.fhe.bfv.encrypt.v1
(D_{\mathrm{id_keygen}})	iroha.crypto.fhe.bfv.identifier.keygen.v1
(D_{\mathrm{id_slot}})	iroha.crypto.fhe.bfv.identifier.slot.v1

პოლიტიკური ვალდებულება

პოლიტიკური ვალდებულება აკავშირებს საჯარო პარამეტრებს და დამალულ საიდუმლო მრეცხველს. პირველ რიგში, საიდუმლოს ცალკე ვაკისრებთ:

$$C_s = H(D_{\mathrm{secret}} \parallel s)$$

შემდეგ სრული პოლიტიკა გადაწერილია კოდირებით:

$$T_{\mathrm{policy}} = N(\mathrm{backend}, P, C_s)$$

და გამოქვეყნებული პოლიტიკის ჰაში არის:

$$\mathrm{policy\_hash} = H(D_{\mathrm{policy}} \parallel T_{\mathrm{policy}})$$

ჯაჭვური PolicyCommitment არის:

$$(\mathrm{backend}, \mathrm{policy\_hash}, P)$$

შეფასება აღადგენს იმავე ღირებულებას გამშვები დროის საიდუმლოებიდან. თუ გადაანგარიშებული ჰეში განსხვავდება, შეფასება არასწორია ვალდებულების შეუსაბამობის გამო.

HKDF-SHA3-512 უკან დაბრუნება

hkdf-sha3-512-prf-v1 -ის გამოსავალი არის ნორმალიზებული შესასვლელი თავად, მაგრამ არაგამჭვირვალე იდენტიფიკატორი და მიღების ჰაში არის საიდუმლო-დაკავშირებული PRF გასასვლელები.

თხოვნის ტრანსკრიპტი არის:

$$T_{\mathrm{req}} = N(\mathrm{policy\_hash}, P, A, x)$$

HKDF მარილის და ფსევდორანდომის გასაღები:

$$\mathrm{salt} = D_{\mathrm{salt}} \parallel \mathrm{policy\_hash}$$

$$\mathrm{PRK} = \operatorname{HKDF\text{-}Extract}_{\mathrm{SHA3\text{-}512}} (\mathrm{salt}, s)$$

გაფართოებული და ჰაშირებული არამკაფიო მასალა:

$$m_o = \operatorname{HKDF\text{-}Expand}_{\mathrm{SHA3\text{-}512}} (\mathrm{PRK}, D_{\mathrm{hkdf\_opaque}} \parallel T_{\mathrm{req}}, 32)$$

$$\mathrm{opaque\_id} = H(D_{\mathrm{opaque}} \parallel m_o)$$

მიღების მასალა დამატებით აკავშირებს არაგამჭვირვალე ID- ს:

$$m_r = \operatorname{HKDF\text{-}Expand}_{\mathrm{SHA3\text{-}512}} (\mathrm{PRK}, D_{\mathrm{hkdf\_receipt}} \parallel T_{\mathrm{req}} \parallel \mathrm{opaque\_id}, 32)$$

$$\mathrm{receipt\_hash} = H(D_{\mathrm{receipt}} \parallel m_r \parallel \mathrm{opaque\_id})$$

ბეიკგენდი ბრუნდება:

$$(\mathrm{output}, \mathrm{opaque\_id}, \mathrm{receipt\_hash}) = (x, \mathrm{opaque\_id}, \mathrm{receipt\_hash})$$

BFV პრიმერი

BFV არის ჯიხურზე დაფუძნებული ჰომომორფული კოდირების სქემა. "ჰომორფური" ნიშნავს იმას, რომ პროგრამას შეუძლია დაამატოს და გაამრავლოს კოდირებული მნიშვნელობები და დეკრიპაციის შემდეგ მიიღოს იგივე შედეგი, როგორც თუ იგი განახორციელებდა დამატებას და გამრავლებას უბრალო ტექსტის მნიშვნელობებზე.

RAM-LFE, BFV გამოიყენება კოდირებული შესვლის მექანიზმით:

1. საფულე ნორმალიზებს კერძო ღირებულებას, მაგალითად ტელეფონის ნომერს ან ელ.ფოსტის მისამართს.
2. საფულე ბაიტებს პატარა მთლიანი რიცხვებით აქცევს.
3. თითოეული სლოტი დაშიფრულია გადამწყვეტის საჯარო გასაღების BFV.
4. მრეზოლუტორის გამშვები დრო იმ ფარული პროგრამას აფასებს ამ კიფერტექსტების მიხედვით.
5. დრანტაიმ მხოლოდ ფარული პროგრამის გამონადენი და სიგნელები დეკრიფტავს ან ადასტურებს მიღებას.

BFV ეს არის ზუსტი მთლიანი რიცხვის არითმეტიკა და არა მიახლოებითი არითმეტიკა. სწორედ ამიტომ ის უფრო შესაფერისია საიდენტიფიკაციო ბაიტები და მცირე მოდულური გამოთვლები, ვიდრე მცურავი წერტილის მოდელი inference. Iroha ჟაჟა. BFV გამოყენება, თითოეული კოდირებული slot ატარებს ერთი scalar ღირებულება modulo (t), ჩვეულებრივ ბაიტი ან ბაიტის სიგრძის ველი. თავად ციფრული ტექსტი ცხოვრობს modulo ბევრად უფრო დიდი მთლიანი რიცხვი (q). სხვაობა შორის (q) და (t) აძლევს დეკრიპტაციის სივრცეს იმ ხმაურისთვის, რომელიც ჩიფრულებისა და ჰომომორფიული ოპერაციების შედეგად შეიქმნება.

BFV ციფრული ტექსტს აქვს ორი პოლინომური კომპონენტი:

$$c=(c_0,c_1)$$

საიდუმლო გასაღები არის კიდევ ერთი მრავალმხრივი (s_k). დეკრიფტირება აერთიანებს კომპონენტებს:

$$v = c_0 + c_1s_k$$

თუ ჩიფრული ტექსტი სწორად ჩამოყალიბდა და ხმაური ჯერ კიდევ საკმარისად მცირეა, (v) ახლოსაა გაზომილ წვრილმანი ტექსტთან. მრგვალება აღადგენს წვრილმან ტექსტის კოეფიციენტს modulo (t). სასარგებლო თვისებაა ის, რომ ჩიფრების ტექსტის ოპერაციები ამ სტრუქტურას ინარჩუნებენ:

მარტივი ოპერაცია	ციფრული ტექსტის ოპერაცია
(m+n)	დაამატეთ ჩიფრული ტექსტის კომპონენტები.
(m+\alpha)	დაამატეთ (c_0) მასშტაბური ჩვეულებრივი ტექსტის მუდმივი.
(\alpha m)	ორივე ციფრული ტექსტის კომპონენტების გაზომვა (\alpha).
(mn)	გაამრავლეთ ციფრული ტექსტის პოლინომიალები, გადაიზომეთ მასშტაბი და შემდეგ განახორციელოთ რელინეარიზაცია.

გამრავლება ძვირადღირებული ოპერაციაა. ორი ორკომპონენტის ციფრული ტექსტის პროდუქტი ბუნებრივად ქმნის სამკომპონენტიან ციფრულ ტექსტს, რომელიც (1), (s_k) და (s_k^2)-ით დეკრიფტდება. რელინერიზაცია იყენებს გამოქვეყნებულ შეფასების საკიდს (s_k^2) ტერმინის დასაბრუნებლად ჩვეულებრივ ორკომპონენტურ ციფრულ ტექსტში. ეს ინარჩუნებს მოგვიანებით დამატებებს და გამრავლებებს იმავე ციფრული ტექსტის ფორმით.

BFV ასევე არის "ლევიზირებული": თითოეული დაშიფრული ოპერაცია მოიხმარს გარკვეულ ხმაურის ბიუჯეტს. ეს განხორციელება არ აწყობს ციფრულ ტექსტებს ამ ბიუჯეტის განახლებისთვის. ამის ნაცვლად, RAM-LFE აქვეყნებს პატარა ram_fhe_profile და იღებს მხოლოდ შეზღუდული ფარული პროგრამის ფორმას. ეს შეინარჩუნებს შეფასებას პარამეტრების კომპლექტის მხარდაჭერილი სიღრმის ფარგლებში. მიმდინარე პროგრამული პროფილი საშუალებას იძლევა ფიქსირებული რეესტრის რაოდენობა, ფიქსირებულ მეხსიერების ზოლზე და მაქსიმუმ ერთი ციფრული ტექსტი-ციფრული ტექსი გამრავლება თითოეული პროგრამული ნაბიჯით.

ამ RAM-LFE დიზაინში, BFV მალავს კლიენტის შეყვანას საჯარო ლეჯერის მონაცემებიდან და დამკვირვებლებისგან, რომლებიც ხედავენ მხოლოდ ტრანზაქციას ან მარშრუტის სასარგებლო ტვირთს. ეს არ ნიშნავს იმას, რომ ჯაჭვმა თვითონ განახორციელოს თვითნებურად ჩიფრული პროგრამები. Torii Resolver runtime კვლავ ფლობს BFV საიდუმლო მასალას, აფასებს კონფიგურირებულ დამალულ პროგრამას, დეკრიფტებს ნებადართული გამოსავალს და ადასტურებს შედეგს. ლიდერი შემდეგ შემოწმებს ატესტაციას ქსელზე პოლიტიკის ვალდებულების წინააღმდეგ და გადაწყვეტს საჯარო გასაღები ან მტკიცებულების მეტა მონაცემებს.

იდენტიფიკატორის გამოყენების შემთხვევა მიზანმიმართულად ირჩევს მარტივ წარმოდგენას. ნორმალიზებული სტრიკი კოდირებულია, როგორც:

[length, byte_0, byte_1, ..., byte_n, 0, 0, ...]

თითოეული ელემენტი დაშიფრულია როგორც საკუთარი BFV სკალარული ციფრული ტექსტი. ეს ფორმა ხელს უწყობს ნორმალიზებას და კონვერტის ვალიდაციას, საშუალებას აძლევს საფულეებს შექმნან დაშიფრებული მოთხოვნები საჯარო პარამეტრებისგან და საშუალებას აძლევს მრეგულირებელს განახორციელოს ეკვივალენტური დაშიფრული შესვლის კანონიზაცია სტაბილურ მიღების ტრანსკრიპტში.

BFV ბეჭდების მოდელი

BFV backends იყენებს negacyclic polynomial ring:

$$R_q = \mathbb{Z}_q[X] / (X^n + 1)$$

და ჩვეულებრივი ტექსტის ბეჭედი:

$$R_t = \mathbb{Z}_t[X] / (X^n + 1)$$

სადაც:

• (n) არის polynomial_degree, ორი სიმძლავრე
• (q) არის ciphertext_modulus
• (t) არის plaintext_modulus
• (q > t) და (t \mid q)
• (\Delta = q/t)
• (B = 2^{\mathrm{decomposition_base_log}})

ჩვეულებრივი ტექსტის კოეფიციენტების ვექტორები კოდირდება თითოეული კოეფიცენტის მასშტაბით:

$$\operatorname{EncPlain}(m)_i = \Delta m_i \bmod q$$

დეკრიპტაციის ცენტრალური ლიფტი თითოეული კოეფიციენტის:

$$v = c_0 + c_1 s_k \in R_q$$

შემდეგ ის კვლავ (R_t) -ში გადაიტანება:

$$\operatorname{Dec}(c)_i = \left\lfloor \frac{t \cdot \operatorname{center}_q(v_i)}{q} \right\rceil \bmod t$$

აქ (s_k) არის BFV საიდუმლო საკვანძო პოლინომია, და არა გარე RAM-LFE გადამწყვეტის საიდუმლოს (s).

BFV ძირითადი თაობა

კოდირებული იდენტიფიკატორის შესასვლელისათვის, BFV საკვანძო მასალა დეტერმინისტურია თითოეული გამჭრილის საიდუმლო და დაკავშირებული მონაცემების მიხედვით:

$$\sigma_{\mathrm{id}} = H(D_{\mathrm{id\_keygen}} \parallel A \parallel s)$$

BFV RNG იყვება შემდეგი სახით:

$$\operatorname{ChaCha20Rng}(H(D_{\mathrm{bfv\_keygen}} \parallel \sigma_{\mathrm{id}}))$$

ძირითადი გენერატორის ნიმუშები:

• (s_k \in {-1,0,1}^n), წარმოდგენილია modulo (q)
• (a \leftarrow R_q) ერთნაირად
• (e \in {-1,0,1}^n)

საჯარო გასაღები არის:

$$\mathrm{pk}=(b,a),\qquad b = -a s_k - e \pmod q$$

რელინეარიზაციისათვის (s_k^2) უნდა იყოს ბეჭდის პროდუქტი (R_q). თითოეული ბაზის-(B) ციფრისთვის (j), ნიმუში (a_j) ერთნაირად და (e_j) მცირე დისტრიბუციისგან, შემდეგ გამოაქვეყნეთ:

$$\mathrm{rlk}_j=(b_j,a_j),\qquad b_j = -a_j s_k - e_j + B^j s_k^2 \pmod q$$

საჯარო BFV პოლიტიკის მეტა მონაცემები შეიცავს (((n,q,t,B)), საჯარო გასაღები და max_input_bytes. საიდუმლო გასაღები BFV და relinearization გასაღები დარჩება გადამწყვეტის runtime.

BFV კოდირება და ოპერაციები

ცალკე ტექსტის პოლინომის (m) დაშიფვრის მიზნით, დანერგვა სხვა ChaCha20 RNG თესლს იშლება შემდეგში:

$$H(D_{\mathrm{bfv\_encrypt}} \parallel \mathrm{seed})$$

მასში შედის ნიმუშები (u,e_1,e_2 \in {-1,0,1}^n) და ითვლება:

$$c_0 = b u + e_1 + \operatorname{EncPlain}(m) \pmod q$$

$$c_1 = a u + e_2 \pmod q$$

ჩიფრული ტექსტი არის (c=(c_0,c_1)).

ჰომორფული დამატება არის კომპონენტური:

$$c+d=(c_0+d_0,\ c_1+d_1)\pmod q$$

მკაფიო ტექსტის სკალარის (\alpha) დამატება კოეფიციენტის ნული ცვლილებების მხოლოდ (c_0):

$$c+\alpha = (c_0 + \Delta\alpha,\ c_1)\pmod q$$

ორ კომპონენტს გაუმრავლება უბრალო ტექსტის მასშტაბით (\alpha) ამაღლებს:

$$\alpha c = (\alpha c_0,\ \alpha c_1)\pmod q$$

ორი ციფრული ტექსტის (c=(c_0,c_1)) და (d=(d_0,d _1)), ციფრულ ტექსტის გამრავლება პირველ რიგში ითვლის სამ ზომის ციფრულ ტექსტს და თითოეული კოეფიციენტი უკან (t/q):

$$\tilde c_0 = \left\lfloor \frac{t(c_0 d_0)}{q} \right\rceil \bmod q$$

$$\tilde c_1 = \left\lfloor \frac{t(c_0 d_1 + c_1 d_0)}{q} \right\rceil \bmod q$$

$$\tilde c_2 = \left\lfloor \frac{t(c_1 d_1)}{q} \right\rceil \bmod q$$

ყველა ზემოთ ჩამოთვლილი პროდუქტი არის ნეგაციკლური ბეჭდების პროდუქტები (R_q). შემდეგ (\tilde c_2) დაშლულია ბაზა-(B) პოლინომებად:

$$\tilde c_2 = \sum_j B^j u_j$$

და განლაგებული:

$$c'_0 = \tilde c_0 + \sum_j u_j b_j \pmod q$$

$$c'_1 = \tilde c_1 + \sum_j u_j a_j \pmod q$$

შედეგი კვლავ არის ორკომპონენტიანი BFV ციფრული ტექსტი.

იდენტიფიკატორი ციფრული ტექსტის კონვერტი

იდენტიფიკატორის შესასვლელი ბაიტის სტრიკი:

$$x=(x_0,\ldots,x_{\ell-1})$$

არის კოდირებული სკალარულ სივრცეებში:

$$m_0 = \ell$$

$$m_{i+1}=x_i,\qquad 0 \le i < \ell$$

და ყველა დარჩენილი სლოტი არის ნულოვანი max_input_bytes + 1. თითოეული სკალარული სლოტი ჩიფრდება როგორც კოეფიციენტი-ნულოვანი უბრალო ტექსტის პოლინომიალი ([m_i]). ერთ სლოტზე ჩიფრების თესლი არის:

$$\sigma_i = H(D_{\mathrm{id\_slot}} \parallel \mathrm{seed} \parallel \operatorname{le64}(i))$$

კოდირებული იდენტიფიკატორის კონვერტი არის:

$$(\operatorname{BFV.Enc}_{\mathrm{pk}}([m_0];\sigma_0),\ldots, \operatorname{BFV.Enc}_{\mathrm{pk}}([m_M];\sigma_M))$$

სადაც (M=\mathrm{max_input_bytes}).

BFV აფინი Backend

დაწვრილებით bfv-affine-sha3-256-v1, გაშვების დრო პირველად იღებს BFV ძირითადი მასალა (s) და (A). მიღებული საჯარო პარამეტრები ზუსტად უნდა შეესაბამებოდეს ჯაჭვზე დადებული საჯარო პარამეტრებს.

აფინური ციკლის თესლი არის:

$$\sigma_{\mathrm{affine}} = H(D_{\mathrm{affine\_circuit}} \parallel s \parallel \mathrm{policy\_hash} \parallel A)$$

ამ მარცვლისგან მოდულო (t), 32 რიგის ავფინური ციკლი:

$$y_j = b_j + \sum_i w_{j,i} m_i \pmod t, \qquad 0 \le j < 32$$

სადაც (m_i) არის დეკრიფირებული იდენტიფიკატორული სივრცეები. ჰომომორფურად, იგი ამავე ღირებულებას ითვლის ციფრულ ტექსტებზე:

$$C_j = b_j + \sum_i w_{j,i} C_i$$

გადამწყვეტი თითოეულ (C_j)-ს დეკრიფტებს, მოითხოვს ყველა შემდგომი ნულოვანი ტექსტის კოეფიციენტის ნულოვანობას, გარდაქმნის კოეფიცენტის ნულო ღირებულებებს ბაიტებად და ფორმირებს:

$$O=(y_0,\ldots,y_{31})$$

შემდეგ:

$$\mathrm{opaque\_id} = H(D_{\mathrm{affine\_opaque}} \parallel \mathrm{policy\_hash} \parallel O)$$

$$\mathrm{receipt\_hash} = H(D_{\mathrm{affine\_receipt}} \parallel \mathrm{policy\_hash} \parallel O \parallel \mathrm{opaque\_id})$$

BFV პროგრამული Backend

bfv-programmed-sha3-256-v1 საჯარო პარამეტრები მოიცავს BFV იდენტიფიკატორის ჩიფრების პარამეტრებს და ფარული პროგრამის დიგესტს:

$$\mathrm{program\_digest} = H(D_{\mathrm{program\_digest}} \parallel N(\mathrm{program}))$$

ამჟამინდელი RAM-FHE პროფილი არის:

სფერო	ღირებულება
profile_version	1
register_count	4
memory_lane_count	32
ciphertext_mul_per_step	1
encrypted_input_mode	resolver_canonicalized_envelope_v1
min_ciphertext_modulus	(2^{52})

Torii -ზე წარმოდგენილი ჩვეულებრივი ტექსტის შეყვანა განხორციელებამდე იმავე BFV კონვერტში დაშიფრულია. ამ სერვერის მხრიდან დაშიფვრის დეტერმინისტური მარცვლეობაა:

$$H( \texttt{"iroha.ram\_lfe.execute.plaintext\_bfv.v1"} \parallel N(\mathrm{program\_id}) \parallel x )$$

გარედან მიწოდებული დაშიფვრის შესასვლელად, რეზოლუციონერი დეკრიფტავს იდენტიფიკატორის კონვერტს და განახორციელებს მას ამ დეტერმინისტურ კონვერტზე, სანამ ამოქმედდება. ეს კანონიზაცია ინარჩუნებს მიღების ჰაშებს სტაბილურობას სემანტიკურად თანასწორ BFV ციფრული ტექსტებში.

საწყისი დაშიფრებული მეხსიერების ზოლები წარმოიქმნება:

$$\sigma_{\mathrm{mem}} = H(D_{\mathrm{program\_memory}} \parallel s \parallel \mathrm{policy\_hash} \parallel A \parallel \operatorname{le64}(0))$$

თითოეულ 32 ზოლზე, runtime ნიმუშები (r_j \in [0,t)) და ინახავს BFV ციფრული ტექსტის ჩიფტირება (r_j). დამალული პროგრამა შემდეგ აწარმოებს დაშიფვრილი რეესტორებისა და დაშიფრებული მეხსიერების:

ინსტრუქცია	ალგებრა
LoadInput(dst, i)	(R_{\mathrm{dst}} \leftarrow C_i)
LoadState(dst, j)	(R_{\mathrm{dst}} \leftarrow S_j)
StoreState(j, src)	(S_j \leftarrow R_{\mathrm{src}})
LoadConst(dst, a)	(R_{\mathrm{dst}} \leftarrow \operatorname{Enc}(a) )
Add(dst, a, b)	(R_{\mathrm{dst}} \leftarrow R_a + R_b)
AddPlain(dst, src, a)	(R_{\mathrm{dst}} \leftarrow R_{\mathrm{src}} + a)
SubPlain(dst, src, a)	(R_{\mathrm{dst}} \leftarrow R_{\mathrm{src}} - a)
MulPlain(dst, src, a)	(R_{\mathrm{dst}} \leftarrow aR_{\mathrm{src}})
Mul(dst, a, b)	(R_{\mathrm{dst}} \leftarrow R_aR_b), შემდეგ გადაიხადეთ
SelectEqZero(dst, cond, z, nz)	დეკრიფტი (R_{\mathrm{cond}}); აირჩიეთ (R_z), როდესაც ის ნულოვანია, წინააღმდეგ შემთხვევაში (R_{nz}).
Output(src)	დამატება (R_{\mathrm{src}}) გამოშვების რეგისტრის სიაში.

ინსტრუქციის კასტის დასრულების შემდეგ, რეზოლუციონერი დეკრიფტებს თითოეულ გამომავალი რეესტორს, გარდაქმნის კოეფიციენტ ნულოვან ბაიტს და კონკოტენირებს ამ ბაიტებს:

$$O = \operatorname{bytes}(\operatorname{Dec}(R_{o_0})_0,\ldots, \operatorname{Dec}(R_{o_k})_0)$$

ზოგადი დაპროგრამებული backend hashes არის:

$$\mathrm{opaque\_hash} = H(D_{\mathrm{program\_opaque}} \parallel \mathrm{policy\_hash} \parallel O)$$

$$\mathrm{receipt\_hash}_{\mathrm{program}} = H(D_{\mathrm{program\_receipt}} \parallel \mathrm{policy\_hash} \parallel O \parallel \mathrm{opaque\_hash})$$

წინასწარი დაპროგრამებული იდენტიფიკატორული лента აქვს 64 შესასვლელი slots. თითოეული slot (i), ის ატვირთავს შესასვლელის slot, ატვირთი მეხსიერების ბილიკი (i \bmod 32), დაამატოს ისინი, და გამოიყოფა შედეგი:

$$R_0 \leftarrow C_i,\qquad R_1 \leftarrow S_{i\bmod 32},\qquad R_2 \leftarrow R_0 + R_1,\qquad \operatorname{Output}(R_2)$$

გამოშვების ჰეშები და ქვითრები

ზოგადი RAM-LFE შესრულების მიღება არ ხელს უწერს ნედლეულის გამოსავალს. იგი ხელს უწყობს გამოსავალი ჰეშის:

$$\mathrm{output\_hash} = H(D_{\mathrm{output}} \parallel O)$$

Torii RAM-LFE შესრულების მიღებებისათვის, ასოცირებული მონაცემები წარმოადგენს კანონიკური პროგრამის იდენტიფიკატორის ბაიტებს:

$$A = N(\mathrm{program\_id})$$

$$\mathrm{associated\_data\_hash}=H(A)$$

ხელმოწერილი ქვითრის სასარგებლო ტვირთი არის:

$$R = (\mathrm{program\_id}, \mathrm{program\_digest}, \mathrm{backend}, \mathrm{verification\_mode}, \mathrm{output\_hash}, \mathrm{associated\_data\_hash}, \mathrm{executed\_at\_ms}, \mathrm{expires\_at\_ms})$$

signed რეჟიმისთვის:

$$\mathrm{attestation} = \operatorname{Sign}_{\mathrm{resolver}}(N(R))$$

შემოწმება აამოწმებს ხელმოწერას resolver_public_key და უარყოფს მიღებას, თუ ყველა ამ თანასწორობას არ აქვს:

$$R.\mathrm{program\_id} = \mathrm{policy.program\_id}$$

$$R.\mathrm{backend} = \mathrm{policy.backend}$$

$$R.\mathrm{verification\_mode} = \mathrm{policy.verification\_mode}$$

$$R.\mathrm{program\_digest} = \mathrm{policy.public\_parameters.hidden\_program\_digest}$$

$$R.\mathrm{associated\_data\_hash} = H(N(\mathrm{policy.program\_id}))$$

იმ შემთხვევაში, თუ დამრეკავმა მიაწოდებს output_hex, მამოწმებელი აგრეთვე ამოწმებს:

$$H(D_{\mathrm{output}} \parallel \operatorname{bytes}(\mathrm{output\_hex})) = R.\mathrm{output\_hash}$$

proof რეჟიმისთვის, ატესტაცია ხელმოწერის ნაცვლად შეიცავს მტკიცებულების კონვერტს. შემოწმება აამოწმებს, რომ მტკიცებულება backend, წრე id, საჯარო შესასვლელი სქემა ჰაში, დამადასტურებელი გასაღები ჰაში და გამოფენილი საჯარო ინსტანციები შეესაბამება მტკიცებულებების გადამოწმებლის მეტატანი მონაცემები და კოდირებული ქვითრების payload ჰაში. მოდით:

$$h_R = H(N(R)) = (h_0,\ldots,h_{31})$$

მოსალოდნელი საჯარო ინსტანციები არის ოთხი ერთ ელემენტის კოლონა. სვეტი (j) შეიცავს ბაიტებს (h_{8j}\ldots h_{8j+7}), რომელსაც მოჰყვება 24 ნულოვანი ბაიტი:

$$\mathrm{instance}_j = h_{8j}\parallel\cdots\parallel h_{8j+7}\parallel 0^{24}, \qquad 0 \le j < 4$$

იდენტიფიკატორის პროექცია

იდენტიფიკატორის რეზოლუცია არ იყენებს ზოგად უკანა მხარეს opaque_hash როგორც მომხმარებლის მიმართულებით არაგამჭვირვალე ანგარიშის იდენტიფექტორი. იგი პროექტირებს RAM-LFE გამომავალი ჰეშს იდენტიფრების სპეციფიკური დომენების მეშვეობით:

$$\mathrm{opaque\_id}_{\mathrm{id}} = H(D_{\mathrm{id\_opaque}} \parallel N(\mathrm{program\_id}) \parallel \mathrm{output\_hash})$$

$$\mathrm{receipt\_hash}_{\mathrm{id}} = H(D_{\mathrm{id\_receipt}} \parallel N(\mathrm{program\_id}) \parallel \mathrm{output\_hash} \parallel \mathrm{opaque\_id}_{\mathrm{id}})$$

IdentifierResolutionReceipt ხელს უწერს უფრო მაღალი დონის სასარგებლო ტვირთას:

$$I = (\mathrm{policy\_id}, R, \mathrm{opaque\_id}_{\mathrm{id}}, \mathrm{receipt\_hash}_{\mathrm{id}}, \mathrm{uaid}, \mathrm{account\_id})$$

ხელმოწერილი საიდენტიფიკაციო მოწმობის მიღებისათვის:

$$\mathrm{attestation} = \operatorname{Sign}_{\mathrm{resolver}}(N(I))$$

ClaimIdentifier იღებს მიღებას მხოლოდ მაშინ, როდესაც ხელმოწერა ან მტკიცებულება ძალაშია, ჩაშენებული RAM-LFE შესრულების სასარგებლო ტვირთი შეესაბამება მითითებულ პროგრამულ პოლიტიკას და მოთხოვნილი სავალდებულოა uaid და account_id.

განხორციელების ნაკადი

ზოგადი RAM-LFE განხორციელება შემდეგ ფორმას ასრულებს:

1. მმართველობის ან ოპერატორის რეესტრები RamLfeProgramPolicy.
2. მფლობელი ააქტიურებს პოლიციას.
3. კლიენტი კითხულობს Torii საჯარო პოლიტიკის მეტა მონაცემებს.
4. კლიენტი რეზოლუტორს ზუსტად ერთ შეყვანის ფორმას უგზავნის: უბრალო ტექსტი input_hex ან დაშიფვრილი შეყვანის კონვერტი BFV.
5. გაშვების დრო შეაფასებს დამალულ პროგრამას და აბრუნებს output_hex, output_hash, opaque_hash, receipt_hash და RamLfeExecutionReceipt.
6. კლიენტი ან უკანა მხარე ადასტურებს მიღებას გამოქვეყნებული პოლიტიკის მიხედვით, ვარიანტულად შემოწმებით, რომ დაბრუნებული output_hex ჰეშები შედის მიღების output_hash.
7. უფრო მაღალი დონის ინსტრუქციას, როგორიცაა ClaimIdentifier, შეუძლია ჩაასხოს დამოწმებული ქვითარი ნედლეულის შეყვანის ნაცვლად.

იდენტიფიკაციის პოლიტიკა

იდენტიფიკატორის პოლიტიკა არის კონკრეტული გამოყენება RAM-LFE. ისინი დაამატებენ ბიზნესის სახელების სივრცესა და ნორმალიზაციის წესი ზოგადი პროგრამის პოლიტიკის ზემოთ:

RegisterRamLfeProgramPolicy(
  program_id = "phone_team",
  owner = "<POLICY_OWNER>",
  backend = "bfv-programmed-sha3-256-v1",
  verification_mode = "signed",
  commitment = "<HIDDEN_PROGRAM_POLICY_COMMITMENT>",
  resolver_public_key = "<RESOLVER_PUBLIC_KEY>"
)
ActivateRamLfeProgramPolicy(program_id = "phone_team")

RegisterIdentifierPolicy(
  id = "phone#team",
  owner = "<POLICY_OWNER>",
  normalization = "PhoneE164",
  program_id = "phone_team",
  note = "Private phone registration for team dataspace"
)
ActivateIdentifierPolicy(policy_id = "phone#team")

საიდენტიფიკაციო ფენაში გამოიყენება RAM-LFE ქვითრის დამაკავშირებელი:

• policy_id
• ფარული ფუნქციის მიერ მიღებული არაგამჭვირვალე იდენტიფიკატორი
• დეტერმინისტური receipt_hash
• ანგარიშის UAID
• კანონიკური account_id
• გენერული RAM-LFE შესრულების სასარგებლო ტვირთი

მომხმარებლის მიმართული ჩართვისთვის, შეინახეთ ანგარიშის იდენტიფიკატები ცალკე კერძო იდენტიფექტორებისაგან. იდენტობა არის საჯარო სახელები; ტელეფონის ნომრები, ელექტრონული ფოსტის მისამართები და მსგავსი ღირებულებები უნდა გადმოედინათ იდენტიფრენის პოლიტიკასა და მიღების საშუალებით.

Torii მიმართულებები

როდესაც აპლიკაციის მიმართულებით მარშრუტის ოჯახი ჩართულია, Torii ამჟღავნებს RAM-LFE და იდენტიფიცირების დამხმარე საშუალებებს:

რუტა	მიზანი
GET /v1/ram-lfe/program-policies	ჩამონათვალი აქტიური და არააქტიური RAM-LFE პროგრამის პოლიტიკისა და საჯარო განხორციელების მეტა მონაცემების.
POST /v1/ram-lfe/programs/{program_id}/execute	განახორციელეთ ერთი პროგრამა input_hex ან encrypted_input და დაუბრუნეთ გამომავალი ჰეშები დამატებით უსახელმწიფოებრივი ქვითარი.
POST /v1/ram-lfe/receipts/verify	შეამოწმეთ RamLfeExecutionReceipt გამოქვეყნებული პოლიტიკის მიხედვით და ვარიანტულად შეადარეთ output_hex output_hash.
GET /v1/identifier-policies	ჩამოთვალეთ იდენტიფიკატორის პოლიტიკა, ნორმალიზაციის რეჟიმები, გადამწყვეტის გასაღებები და კოდირებული შეყვანილი მეტა მონაცემები.
POST /v1/accounts/{account_id}/identifiers/claim-receipt	გამოთავისუფლეთ ქვითარი, რომელსაც მომხმარებელს შეუძლია ჩასვა ClaimIdentifier.
POST /v1/identifiers/resolve	დარეგულირება ნორმალიზებული იდენტიფიკატორის შეყვანა დაკავშირებულ ანგარიშზე, როდესაც არსებობს აქტიური მოთხოვნა.
GET /v1/identifiers/receipts/{receipt_hash}	მოძებნეთ მუდმივი იდენტიფიკაციის მოთხოვნა მიღების ჰეშით აუდიტის და მხარდაჭერის ინსტრუმენტებისთვის.

ყოველთვის შეამოწმეთ სამიზნე კვანძის /openapi ან /openapi.json დოკუმენტი ამ მარშრუტების წინააღმდეგ შენობის წინ. ხელმისაწვდომობა დამოკიდებულია კვანძი და ქსელის პროფილის შექმნაზე.

კვანძის გამშვები დრო

Torii-ის მიმდინარე მუშაობის დრო RAM-LFE კონფიგურირებულია torii.ram_lfe.programs[*] ქვეშ, კლასიფიცირებულია program_id. თითოეული კონფიგურირებული პროგრამა უნდა შეესაბამებოდეს ქსელზე პოლიტიკის ვალდებულებას და აუცილებელია უზრუნველყოფენ რეცეპტების შეფასებისა და დამტკიცებისათვის საჭირო გამშვები დროის მასალას. იდენტიფიკატორის მარშრუტები ამავე გამშვებ დროს იმეორებენ; მათ არ მოითხოვენ ცალკე იდენტიფორმა-რეზოლუციის კონფიგურაციის ზედაპირს.

რეგისტრაცია პოლიტიკა ჯაჭვზე არ არის საკმარისი თავისთავად. მიზნობრივი კუთხე ასევე უნდა გამოავლინოს მარშრუტის ოჯახი და აქვს შესაბამისი runtime მასალა პროგრამები იგი მოსალოდნელია, რომ შესრულება.

საოპერაციო გვარდალები

• დარეგისტრირეთ პოლიტიკა არააქტიურია, შეამოწმეთ საჯარო მეტა მონაცემები და შემდეგ გააქტიურეთ ისინი.
• დოკუმენტებიდან, ლოგებიდან, ტრანზაქციებისა და კლიენტთა ბუნდებისგან დამალული საიდუმლოებები, გამჭრელი ხელმოწერის გასაღები და BFV საიდუმლოს მასალა.
• არ დააყენოთ ნედლეული იდენტიფიკატორები ანგარიშის საყურადღებოდ, ტრანზაქციის მეტა მონაცემებში, მოვლენებში ან მსოფლიო სახელმწიფოს ველებში.
• კლიენტის მხრიდან მიღებული ქვითრების შემოწმება უფრო მაღალი დონის ინსტრუქციების წარდგენის წინ, როდესაც SDK ამტკიცებს შემოწმებულს.
• გამოიყენეთ ვადის ამოწურვის ველები, სადაც მოძველებული ქვითრები არ უნდა დარჩეს სამუდამოდ.
• როტაცია ახალი პროგრამის ან იდენტიფიკაციის პოლიტიკის რეგისტრაციით, კლიენტების მიგრაციით და ძველი პოლიტიკის დეაქტივაციით, როგორც კი ახალი შემოსავლები მოდის.

დაკავშირებული თემები

• სპონსორის გადასახადები კერძო მონაცემთა სივრცეში
• Torii საბოლოო წერტილები
• ანონიმური ტრანზაქციები