RAM-LFE

RAM-LFE նշանակում է Random-Access Machine Laconic Function Evaluation: Iroha -ում այն սովորական թաքնված ֆունկցիայի շերտն է ծրագրերի համար, որոնց հանրային քաղաքականությունը առցանց է, բայց որի գնահատող տրամաբանությունը, գաղտնի կամ կեղծ մուտքը չպետք է գրվի համաշխարհային պետության վրա։ Այն օգտագործվում է SORA Nexus նույնականացնող հոսքերի կողմից, ինչպիսիք են անձնական հեռախոսը կամ էլփոստի որոնումը, եւ կարող է նաեւ բացահայտվել որպես ընդհանուր Torii ծրագրի գործարկման օգնական, երբ բջիջային պրոֆիլը հնարավորություն է տալիս հավելվածին ուղղված երթուղիները:

Շղթան պահպանում է քաղաքականության պարտավորությունների եւ ստացումների հաստատման մետադատա տվյալները: Resolver կամ 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- ի աջակցությամբ գաղտնի աֆինային գնահատումը կոդավորված նույնականացման տեղերի վրա:
bfv-programmed-sha3-256-v1	BFV աջակցված ծրագրային կատարումը կոդավորված ռեժիսորների եւ հիշողության երթուղիների միջոցով:

Identifier քաղաքականությունների համար, ծրագրավորված BFV backend- ը կարեւոր ժամանակակից ուղին է: Այն թույլ է տալիս դրամապանակներին տեղական կարգավորված մուտքը կոդավորել, թույլ է տալիս լուծիչին գնահատել առանց հանրային նույնականացողի տեսնելու գործարքում, եւ վերադարձնում է ստաթուղթ, որը կապում է արտադրանքի хэշը գրանցված ծրագրի քաղաքականության հետ:

Մաթեմատիկա

Այս բաժինը նկարագրում է ներկա RAM-LFE կոդի կողմից օգտագործվող իրականացման մակարդակի ալգեբրան: Դա անվտանգության ապացույց չէ, դա դետերմինիստական տրանսկրիպտ եւ գաղտնագրված գնահատման մոդելն է, որի վրա պետք է համաձայնվեն քաղաքականությունները, ստացումները եւ հաճախորդները:

Նշում

Թույլ տվեք:

• (H(m)) լինել Iroha Hash::new(m): Blake2b-32 over m, վերջին բայթի ամենացածր նշանակալի հատվածը հարկադրվել է 1:
• (N(x)) պետք է լինի Norito քանոնիկ կոդավորման x
• (a \parallel b) միջին բայթային հորիզոնականի շղթանավորում:
• (\operatorname{le64}(i) ) լինել 8-բայթային փոքր ENDIAN կոդավորման աննշված ամբողջ թիվ.
• (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})$$

Backend- ը վերադարձնում է.

$$(\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. Resolver Runtime-ը գնահատում է թաքնված ծրագիրը այդ կոդավորվող տեքստների վրա:
5. Գործընթացային ժամանակը միայն գաղտնաբառում է թաքնված ծրագրի արտադրանքը եւ նշաններ կամ ապացուցում ստուգման համար:

BFV է ճշգրիտ ամբողջական թվային հաշվետվություն, ոչ թե մոտավոր հաշվետվությունը: Ահա թե ինչու այն ավելի հարմար է ճանաչող բայտների եւ փոքր մոդուլային Հաշվարկները, քան բողոքային կետի մոդելի եզրակացությունը: Iroha current-ը BFV օգտագործման, յուրաքանչյուր կոդավորված slot կրում է մեկ skalar արժեքի modulo (t), սովորաբար բայթ կամ բայտ երկարության դաշտ. Ինքը կոդավորվող տեքստը ապրում է շատ ավելի մեծ ամբողջական թվով (q). Միջնորդների միջեւ (q) եւ (t) ապահովում է գաղտնաբառման եւ հոմոմորմֆային գործողությունների կողմից առաջացած աղմուկի համար դեկոդավորման տարածք:

BFV կոդավորվող տեքստը ունի երկու բազմաբնույթ բաղադրիչներ.

$$c=(c_0,c_1)$$

Գաղտնի բանալին եւս մեկ բազմաբնույթ է (s_k): Բացահայտումը միավորում է բաղադրիչները.

$$v = c_0 + c_1s_k$$

Եթե կոդագրված տեքստը ձեւավորվել է ճիշտ, եւ աղմուկը դեռ բավականաչափ փոքր է, (v) մոտ է սկանալացված պարզ տեքստին: Գլխավորումը վերականգնում է պարզ տեքստի koeficient modulo (t): Օգտակար հատկությունն այն է, որ կոդագրման տեքստի գործողությունները պահպանում են այս կառուցվածքը.

Պարզ գործողություն	Կոդավորման տեքստի գործառույթ
(m+n)	Ավելացնել կոդավորվող տեքստի բաղադրիչներ:
(m+\alpha)	(c_0) -ին ավելացրեք ստուգված պարզ տեքստային հաստատուն:
(\alpha m)	Երկու կոդային տեքստի բաղադրիչների չափը (\alpha).
(mn)	Բազմապատկեք կոդային տեքստի բազմաբնույթները, վերանորոգեք դրանք, ապա վերաուղղակիացրեք:

Բազմապատկումը թանկ գործողություն է: Երկու բաղադրիչային կոդավորվող տեքստերի արտադրանքը բնականաբար ստեղծում է երեք բաղադրիչի կոդավորող տեքստ, որը կոդավորվում է (1), (s_k) եւ (s_k^2): Relinearization- ը օգտագործում է հրապարակված գնահատականի բանալին ՝ (s_k^2) տերմինը վերադարձնելու համար նորմալ երկու բաղադրիչային կոդավորվող տեքստում: Դա պահպանում է հետագա ավելացումները եւ բազմապատկությունները ՝ օգտագործելով նույն կոդային տեքստի ձեւը:

BFV-ը նաեւ "երեւավորվում է": յուրաքանչյուր կոդավորված գործողություն սպառում է որոշակի աղմուկային բյուջե: Այս իրականացումը չի սկսում կոդավորվող տեքստները, որպեսզի թարմացնի այդ բյուջեն: Փոխարենը, RAM-LFE-ը հրապարակում է փոքրիկ ram_fhe_profile եւ ընդունում է միայն սահմանված թաքնված ծրագրի ձեւ: Այն պահում է գնահատումը պարամետրերի հավաքածուի աջակցվող խորության մեջ: Ներկայիս ծրագրավորված պրոֆիլը թույլ է տալիս ֆիքսված ռեգիստրային հաշիվ, հաստատված հիշողության երթեւեկության հաշիվ եւ ամենաշատը մեկ կոդագրված տեքստ-կոդագրված թեքստ բազմապատկման համար ծրագրավորվող քայլով.

Այս RAM-LFE դիզայնում, BFV թաքցնում է հաճախորդի մուտքը հանրային գրքի տվյալներից եւ դիտորդներից, ովքեր տեսնում են միայն գործարքը կամ երթուղու օգտակար բեռը: Դա չի նշանակում, որ շղթան ինքնուրույն կատարում է կամայական կոդավորված ծրագրեր: Torii Resolver Runtime- ը դեռեւս պատկանում է BFV գաղտնի նյութին, գնահատում է կոնֆիգուրացված թաքնված ծրագիրը, ապականացնում թույլատրվող արտադրանքը եւ վկայում է արդյունքը: Գլխավոր գրքում այնուհետեւ ստուգվում է հավաստագրումը առցանց քաղաքականության պարտավորությունների դեմ եւ լուծում է հանրային բանալին կամ ապացուցման մետակետները:

Identifier օգտագործման դեպքը նպատակային կերպով ընտրում է պարզ ներկայացումը: Նորմալացված շղթան կոդավորվում է որպես.

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

Յուրաքանչյուր տարր կոդավորվում է որպես իր սեփական BFV skalar ciphertext: Այդ ձեւը բացատրում է նորմալացումը եւ փաթեթների հավաստագրումը, թույլ է տալիս դրամապանակներին ստեղծել հանրային պարամետրերից կոդավորված պահանջներ, եւ թույլ է տալիս լուծիչին կոնոնիկացնել համապատասխան կոդավորված մուտքերը կայուն ստացության տրանսկրիպտում:

BFV Աղջիկի մոդել

BFV հետադարձները օգտագործում են նեգասիկլիկ բազմաբնույթ օղակը.

$$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 գաղտնի բանալին polynomial, ոչ թե արտաքին 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 բանալին մնում են լուծման գործնական ժամանակ.

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 կոդավորված տեքստ է:

Տեղեկիչի կոդային տեքստ

Identifier input byte string:

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

կոդավորված է skalar slots:

$$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)$$

Այս սերմից վազման ժամանակի նմուշները, modulo (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), պահանջում է, որ բոլոր հետագա պարզ տեքստային կոեֆիցիոնները լինեն զրոյական, փոխակերպում է կոեficiente-zero արժեքները բայթներով եւ ձեւավորում է.

$$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 երթուղիների յուրաքանչյուրի համար, վազման ժամանակի նմուշները (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}} \leftrow \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 hash-ները հետեւյալն են.

$$\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 մուտքային փաթեթ: Յուրաքանչյուր փաթեթի համար (i), այն բեռնում է մուտքի փաթետը, բեռնում է հիշողության գոտին (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 ռեժիմի համար հավաստագրումը ստորագրության փոխարեն կրում է ապացույցի փաթեթ: Փորձաքննությունը ստուգում է, որ ապացուցման հետագա վերջը, շրջանային ID- ը, հանրային մուտքի սխեմայի շիշը, ստուգող բանալինների շիշը եւ բացահայտված հանրային առատները համապատասխանում են ապացուցիչի ստուգողի մետադատային տվյալներին եւ կոդավորված վիտակետ-վճարային բեռի շշին: Թույլ տվեք.

$$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$$

Հայտարարիչի կանխատեսում

Identifier Resolution- ը չի օգտագործում ընդհանուր backend- ը 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. Runtime- ը գնահատում է թաքնված ծրագիրը եւ վերադարձնում է output_hex, output_hash, opaque_hash, receipt_hash եւ RamLfeExecutionReceipt
6. Հաճախորդը կամ հետագա վերջն ստուգում է ստուգումը հրապարակված քաղաքականության համեմատ, ընտրական կերպով ստուգելով, որ վերադարձված output_hex հաշինգը համապատասխանում է ստուգման output_hash-ին:
7. Ավելի բարձր մակարդակի հրահանգները, ինչպիսիք են ClaimIdentifier, կարող են ներմուծել վկայակոչված ստուգումը' նախնական մուտքի փոխարեն:

Հայտարարման քաղաքականություն

Identifier քաղաքականությունները կոնկրետ օգտագործում են 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")

Identifier layer-ում օգտագործվում է 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 եւ վերադարձնել արտադրանքի hashes գումարած անպետական վոմենտ.
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. Յուրաքանչյուր կոնֆիգուրացված ծրագիր պետք է համապատասխանի առցանց քաղաքականության պարտավորությանը եւ պետք է ապահովի վազման ժամանակի նյութը , որը անհրաժեշտ է գնահատելու եւ վավերացնում են ստացումները: Identifier երթուղիները կրկնօրինակում են նույն գործնական ժամկետը, նրանք չեն պահանջում առանձին identifikator-resolver կոնֆiguration մակերես:

Քաղաքականության գրանցումը շղթայի վրա ինքնուրույն բավարար չէ: Նպատակային հանգույցը պետք է նաեւ բացահայտի երթուղիների ընտանիքը եւ ունենա համապատասխան վազման ժամանակի նյութ այն ծրագրերի համար, որոնք ակնկալվում են կատարվել:

Օպերացիոն պահապաններ

• Գրանցեք քաղաքականությունը անակտիվ, ստուգեք հանրային մետադատաները, ապա ակտիվացրեք դրանք:
• Պահեք թաքնված գնահատողի գաղտնիքները, լուծման ստորագրման բանալիները եւ BFV գաղտնի նյութը փաստաթղթերից, օրագրերից, գործարքներից եւ հաճախորդների փաթեթներից:
• Հաշվեի գաղտնաբառերի, գործարքի մետադատա տվյալների, իրադարձությունների կամ համաշխարհային պետության դաշտերի մեջ չեն տեղադրվում կաթվածային ճանաչողներ:
• Հաճախորդի կողմից ստուգեք վիչքները, նախքան բարձր մակարդակի հրահանգներ ուղարկելը, երբ SDK -ը բացահայտում է ստուգողին:
• Օգտագործեք ժամկետային դաշտեր, որտեղ հնացած ստացումները չպետք է մնում են հավիտենական:
• Շրջեք ՝ գրանցելով նոր ծրագիր կամ նույնականացնող քաղաքականություն, տեղափոխելով հաճախորդներ եւ անջատելով հին քաղաքականությունը, երբ նոր ստացումներ են:

Կապակցված թեմաներ

• Հատուկ տվյալների տարածքի համար հովանավորների վճարներ
• Torii Վերջնական կետեր
• Անանուն գործարքներ