{"id":2627,"date":"2023-02-09T10:03:38","date_gmt":"2023-02-09T10:03:38","guid":{"rendered":"https:\/\/harpocrates-project.eu\/cose-la-crittografia-ibrida-omomorfa-e-le-sue-applicazioni\/"},"modified":"2023-09-12T09:24:30","modified_gmt":"2023-09-12T09:24:30","slug":"cose-la-crittografia-ibrida-omomorfa-e-le-sue-applicazioni","status":"publish","type":"post","link":"https:\/\/harpocrates-project.eu\/it\/cose-la-crittografia-ibrida-omomorfa-e-le-sue-applicazioni\/","title":{"rendered":"Cos&#8217;\u00e8 la crittografia ibrida omomorfa e le sue applicazioni"},"content":{"rendered":"<p>[et_pb_section fb_built=&#8221;1&#8243; custom_padding_last_edited=&#8221;on|phone&#8221; _builder_version=&#8221;4.19.1&#8243; _module_preset=&#8221;default&#8221; background_color=&#8221;#1f2437&#8243; background_enable_image=&#8221;off&#8221; background_position=&#8221;center_left&#8221; custom_padding=&#8221;0rem|1rem|0rem|1rem|true|false&#8221; custom_padding_tablet=&#8221;|2rem|1rem|2rem|false|false&#8221; custom_padding_phone=&#8221;|1rem||1rem|false|false&#8221; global_colors_info=&#8221;{}&#8221;][et_pb_row custom_padding_last_edited=&#8221;on|phone&#8221; _builder_version=&#8221;4.19.1&#8243; _module_preset=&#8221;default&#8221; width=&#8221;100%&#8221; max_width=&#8221;1540px&#8221; custom_padding=&#8221;||||false|false&#8221; custom_padding_tablet=&#8221;||||false|false&#8221; custom_padding_phone=&#8221;1rem||1rem||false|false&#8221; global_colors_info=&#8221;{}&#8221;][et_pb_column type=&#8221;4_4&#8243; _builder_version=&#8221;4.19.1&#8243; _module_preset=&#8221;default&#8221; global_colors_info=&#8221;{}&#8221;][lwp_divi_breadcrumbs link_color=&#8221;#FFFFFF&#8221; separator_color=&#8221;#FFFFFF&#8221; _builder_version=&#8221;4.19.1&#8243; _module_preset=&#8221;default&#8221; custom_padding_tablet=&#8221;1rem||1rem||false|false&#8221; custom_padding_phone=&#8221;1rem||1rem||false|false&#8221; custom_padding_last_edited=&#8221;on|phone&#8221; global_colors_info=&#8221;{}&#8221;][\/lwp_divi_breadcrumbs][\/et_pb_column][\/et_pb_row][\/et_pb_section][et_pb_section fb_built=&#8221;1&#8243; custom_padding_last_edited=&#8221;on|phone&#8221; _builder_version=&#8221;4.19.1&#8243; _module_preset=&#8221;default&#8221; custom_padding=&#8221;|1rem||1rem|false|true&#8221; custom_padding_tablet=&#8221;|2rem||2rem|false|true&#8221; custom_padding_phone=&#8221;|1rem||1rem|false|true&#8221; global_colors_info=&#8221;{}&#8221;][et_pb_row column_structure=&#8221;2_3,1_3&#8243; _builder_version=&#8221;4.19.1&#8243; _module_preset=&#8221;default&#8221; width=&#8221;100%&#8221; max_width=&#8221;1540px&#8221; global_colors_info=&#8221;{}&#8221;][et_pb_column type=&#8221;2_3&#8243; _builder_version=&#8221;4.19.1&#8243; _module_preset=&#8221;default&#8221; border_color_right=&#8221;#9b9b9b&#8221; global_colors_info=&#8221;{}&#8221;][et_pb_text _builder_version=&#8221;4.19.1&#8243; _module_preset=&#8221;default&#8221; header_font=&#8221;Montserrat|700|||||||&#8221; header_text_color=&#8221;#1f2437&#8243; header_font_size=&#8221;24px&#8221; global_colors_info=&#8221;{}&#8221;]<\/p>\n<h1 id=\"0938\" class=\"pw-post-title ip iq ir gx b is it iu iv iw ix iy iz ja jb jc jd je jf jg jh ji jj jk jl jm fa\" data-selectable-paragraph=\"\">Cos&#8217;\u00e8 la crittografia ibrida omomorfa e le sue applicazioni<\/h1>\n<p><b><span>9.2.2023 10:03<\/span><\/b><\/p>\n<p>&nbsp;<\/p>\n<p>[\/et_pb_text][et_pb_text _builder_version=&#8221;4.19.1&#8243; _module_preset=&#8221;default&#8221; hover_enabled=&#8221;0&#8243; global_colors_info=&#8221;{}&#8221; sticky_enabled=&#8221;0&#8243;]<\/p>\n<h1 id=\"da1f\" class=\"lb lc ir gx ld le lf lg lh li lj lk ll lm ln lo lp lq lr ls lt lu lv lw lx ly fa\" data-selectable-paragraph=\"\">TL;DR<\/h1>\n<p id=\"bff2\" class=\"pw-post-body-paragraph jn jo ir gx b jp lz jr js jt ma jv jw jx mb jz ka kb mc kd ke kf md kh ki kj ik fa\" data-selectable-paragraph=\"\">Introdurre il concetto di crittografia omomorfa ibrida, i suoi casi d&#8217;uso, una breve formulazione e un<a class=\"ae la\" href=\"https:\/\/github.com\/khoaguin\/priv-sec-ai-blog\/tree\/main\/what-is-hhe\" rel=\"noopener ugc nofollow\" target=\"_blank\">codice dimostrativo<\/a><span> <\/span><a class=\"ae la\" href=\"https:\/\/github.com\/khoaguin\/priv-sec-ai-blog\/tree\/main\/what-is-hhe\" rel=\"noopener ugc nofollow\" target=\"_blank\">in C++<\/a>.<\/p>\n<h1 id=\"e512\" class=\"lb lc ir gx ld le lf lg lh li lj lk ll lm ln lo lp lq lr ls lt lu lv lw lx ly fa\" data-selectable-paragraph=\"\">Introduzione<\/h1>\n<p id=\"5472\" class=\"pw-post-body-paragraph jn jo ir gx b jp lz jr js jt ma jv jw jx mb jz ka kb mc kd ke kf md kh ki kj ik fa\" data-selectable-paragraph=\"\">Le applicazioni che preservano la privacy sono diventate un argomento importante al giorno d&#8217;oggi a causa delle crescenti preoccupazioni delle persone sulla privacy dei loro dati, della prevalenza di applicazioni di apprendimento automatico che richiedono l&#8217;accesso a una vasta quantit\u00e0 di dati e di nuove normative come il Regolamento generale sulla protezione dei dati (GDPR), per non parlare di altre preoccupazioni etiche e finanziarie. Oggi conosceremo una nuova tecnica di miglioramento della privacy chiamata Hybrid Homomorphic Encryption (HHE), che \u00e8 un&#8217;espansione della crittografia omomorfa (HE).<\/p>\n<p id=\"4dd8\" class=\"pw-post-body-paragraph jn jo ir gx b jp jq jr js jt ju jv jw jx jy jz ka kb kc kd ke kf kg kh ki kj ik fa\" data-selectable-paragraph=\"\">HE \u00e8 una tecnica di crittografia che ci permette di eseguire calcoli su dati criptati. Tuttavia, uno dei problemi di HE \u00e8 che i testi cifrati sono di diversi ordini di grandezza pi\u00f9 grandi dei corrispondenti testi in chiaro. HHE mira a risolvere questo problema combinando i cifrari simmetrici con HE per ridurre le dimensioni dei cifrari e le risorse computazionali necessarie per la parte che cripta e invia i dati (ad esempio, un cliente\/proprietario dei dati) al costo di calcoli pi\u00f9 costosi per la parte che esegue calcoli sui dati crittografati (ad esempio, un server, un Cloud Service Provider o CSP). Pertanto, HHE pu\u00f2 essere pi\u00f9 adatto di HE quando si tratta del modello client-server di calcoli crittografati, soprattutto quando il client dispone di risorse computazionali e larghezza di banda Internet limitate, ad esempio telefoni, dispositivi IoT, ecc.<\/p>\n<h2 id=\"bc0e\" class=\"me lc ir gx ld mf mg dt lh mh mi dv ll jx mj mk lp kb ml mm lt kf mn mo lx mp fa\" data-selectable-paragraph=\"\">Vantaggi:<\/h2>\n<ul class=\"\">\n<li id=\"c993\" class=\"mq mr ir gx b jp lz jt ma jx ms kb mt kf mu kj mv mw mx my fa\" data-selectable-paragraph=\"\">Consentire calcoli su dati crittografati e quindi analisi e applicazioni di dati che rispettano la privacy.<\/li>\n<li id=\"ce2a\" class=\"mq mr ir gx b jp mz jt na jx nb kb nc kf nd kj mv mw mx my fa\" data-selectable-paragraph=\"\">Ridurre le dimensioni del testo cifrato, quindi ridurre le risorse di calcolo e di banda necessarie per chi possiede, cripta e invia i dati.<\/li>\n<\/ul>\n<h2 id=\"4390\" class=\"me lc ir gx ld mf mg dt lh mh mi dv ll jx mj mk lp kb ml mm lt kf mn mo lx mp fa\" data-selectable-paragraph=\"\">Svantaggi:<\/h2>\n<ul class=\"\">\n<li id=\"c5ed\" class=\"mq mr ir gx b jp lz jt ma jx ms kb mt kf mu kj mv mw mx my fa\" data-selectable-paragraph=\"\">Pi\u00f9 costoso dal punto di vista computazionale sul dominio di calcolo criptato<\/li>\n<li id=\"11a6\" class=\"mq mr ir gx b jp mz jt na jx nb kb nc kf nd kj mv mw mx my fa\" data-selectable-paragraph=\"\">Attualmente \u00e8 ancora limitato ad alcuni tipi di dati e calcoli.<\/li>\n<\/ul>\n<h1 id=\"c277\" class=\"lb lc ir gx ld le lf lg lh li lj lk ll lm ln lo lp lq lr ls lt lu lv lw lx ly fa\" data-selectable-paragraph=\"\">Casi d&#8217;uso<\/h1>\n<p id=\"1a4b\" class=\"pw-post-body-paragraph jn jo ir gx b jp lz jr js jt ma jv jw jx mb jz ka kb mc kd ke kf md kh ki kj ik fa\" data-selectable-paragraph=\"\">Come l&#8217;HE, l&#8217;HHE pu\u00f2 supportare applicazioni in settori in cui la privacy dei dati \u00e8 una preoccupazione importante, come la finanza, la sanit\u00e0, le normative, ecc. Inoltre, HHE pu\u00f2 potenziare le applicazioni su dispositivi con potenza di calcolo, memoria e larghezza di banda di rete limitate, come i dispositivi embedded e IoT.<\/p>\n<p id=\"586a\" class=\"pw-post-body-paragraph jn jo ir gx b jp jq jr js jt ju jv jw jx jy jz ka kb kc kd ke kf kg kh ki kj ik fa\" data-selectable-paragraph=\"\">Esempio di applicazione: Un&#8217;applicazione di sorveglianza domestica per l&#8217;assistenza sanitaria, in cui i dispositivi IoT installati in una casa scattano foto (o altri segnali), le criptano e inviano i segnali criptati al server. Il server esegue un algoritmo di intelligenza artificiale sui dati criptati ricevuti e rileva occasioni come la presenza di persone colpite da ictus, quindi invia i risultati criptati al dispositivo della famiglia, che ha il compito di decifrare il risultato e di lanciare un allarme solo quando il risultato decifrato \u00e8 positivo, ad esempio se ci sono persone colpite da ictus. In questo modo, la famiglia pu\u00f2 utilizzare il servizio del server, mentre il fornitore del servizio non vede le immagini o i dati sensibili della famiglia.<\/p>\n<h1 id=\"e860\" class=\"lb lc ir gx ld le lf lg lh li lj lk ll lm ln lo lp lq lr ls lt lu lv lw lx ly fa\" data-selectable-paragraph=\"\">Entriamo nel merito della matematica<\/h1>\n<p id=\"80bc\" class=\"pw-post-body-paragraph jn jo ir gx b jp lz jr js jt ma jv jw jx mb jz ka kb mc kd ke kf md kh ki kj ik fa\" data-selectable-paragraph=\"\">Di seguito sono riportate alcune brevi formulazioni di HE e HHE.<\/p>\n<h2 id=\"04f4\" class=\"me lc ir gx ld mf mg dt lh mh mi dv ll jx mj mk lp kb ml mm lt kf mn mo lx mp fa\" data-selectable-paragraph=\"\">Crittografia omomorfa<\/h2>\n<p id=\"c1f6\" class=\"pw-post-body-paragraph jn jo ir gx b jp lz jr js jt ma jv jw jx mb jz ka kb mc kd ke kf md kh ki kj ik fa\" data-selectable-paragraph=\"\">Prima di arrivare a HHE, dobbiamo prima capire HE. Con HE, possiamo crittografare i dati ed eseguire operazioni sui dati crittografati. Il risultato della decrittazione sar\u00e0 equivalente a quello ottenuto eseguendo operazioni simili sui dati in chiaro corrispondenti. Per capire meglio HE, vi rimando a questo articolo<span> <\/span><a class=\"ae la\" href=\"https:\/\/blog.openmined.org\/what-is-homomorphic-encryption\/\" rel=\"noopener ugc nofollow\" target=\"_blank\">post sul blog<\/a><span> <\/span>da OpenMined.<\/p>\n<p id=\"d2ce\" class=\"pw-post-body-paragraph jn jo ir gx b jp jq jr js jt ju jv jw jx jy jz ka kb kc kd ke kf kg kh ki kj ik fa\" data-selectable-paragraph=\"\">Vediamo la definizione di schema di crittografia a chiave pubblica omomorfa, tratta da [1] e composta da 4 algoritmi:<\/p>\n<ol class=\"\">\n<li id=\"0783\" class=\"mq mr ir gx b jp jq jt ju jx ne kb nf kf ng kj nh mw mx my fa\" data-selectable-paragraph=\"\"><strong class=\"gx ni\">HE.KeyGen<\/strong>(1<em class=\"nj\">\u207f)<\/em> \u2192<span> <\/span><strong class=\"gx ni\">(pk, sk, evk):<span> <\/span><\/strong>L&#8217;algoritmo di generazione delle chiavi.<strong class=\"gx ni\"><span> <\/span><\/strong>Qui,<span> <\/span><em class=\"nj\">n<\/em><span> <\/span>\u00e8 un parametro di sicurezza;<span> <\/span><strong class=\"gx ni\">pk<\/strong>,<span> <\/span><strong class=\"gx ni\">sk<\/strong><span> <\/span>e<span> <\/span><strong class=\"gx ni\">evk<\/strong><span> <\/span>sono rispettivamente la chiave pubblica, la chiave segreta e la chiave di valutazione. Utilizziamo<span> <\/span><strong class=\"gx ni\">pk<\/strong><span> <\/span>per criptare i dati,<span> <\/span><strong class=\"gx ni\">sk<\/strong><span> <\/span>per decifrare i dati criptati e<span> <\/span><strong class=\"gx ni\">evk<\/strong><span> <\/span>per eseguire calcoli su dati crittografati<\/li>\n<li id=\"e104\" class=\"mq mr ir gx b jp mz jt na jx nb kb nc kf nd kj nh mw mx my fa\" data-selectable-paragraph=\"\"><strong class=\"gx ni\">HE.Enc(pk,<span> <\/span><\/strong> m<strong class=\"gx ni\">) \u2192<span> <\/span><\/strong> c<em class=\"nj\">:<span> <\/span><\/em>L&#8217;algoritmo di cifratura HE dove<span> <\/span> m<span> <\/span>\u00e8 il dato in chiaro e<span> <\/span> c<span> <\/span>\u00e8 il dato cifrato HE<\/li>\n<li id=\"b1b3\" class=\"mq mr ir gx b jp mz jt na jx nb kb nc kf nd kj nh mw mx my fa\" data-selectable-paragraph=\"\"><strong class=\"gx ni\">HE.Eval(evk,<span> <\/span><\/strong> f<em class=\"nj\">, c\u2081, c\u2082, &#8230; c\u1d62) \u2192 c&#8217;:<span> <\/span><\/em>L&#8217;algoritmo di valutazione<em class=\"nj\"><span> <\/span><\/em>dove<span> <\/span><em class=\"nj\">f<span> <\/span><\/em>\u00e8 una funzione come l&#8217;addizione o la moltiplicazione, e<span> <\/span><em class=\"nj\">c<\/em>&#8216; <em class=\"nj\"><span> <\/span> \u00e8 il risultato criptato HE.<\/em> Dovremmo avere<span> <\/span><strong class=\"gx ni\">HE.Dec(sk,<span> <\/span><\/strong><em class=\"nj\">c&#8217;<\/em><strong class=\"gx ni\">) =<span> <\/span><\/strong><em class=\"nj\">f(m\u2081, m\u2082, &#8230;, m\u1d62)<\/em><\/li>\n<li id=\"6224\" class=\"mq mr ir gx b jp mz jt na jx nb kb nc kf nd kj nh mw mx my fa\" data-selectable-paragraph=\"\"><strong class=\"gx ni\">HE.Dec(sk,<span> <\/span><\/strong> c<strong class=\"gx ni\">) \u2192<span> <\/span><\/strong> m<em class=\"nj\">:<span> <\/span><\/em>L&#8217;algoritmo di decrittazione HE<em class=\"nj\"><span> <\/span><\/em>che prende<span> <\/span><strong class=\"gx ni\">sk<\/strong><span> <\/span>e il testo cifrato<span> <\/span><em class=\"nj\">c<\/em><span> <\/span>per creare il messaggio in chiaro<span> <\/span><em class=\"nj\">m<\/em><\/li>\n<\/ol>\n<h2 id=\"595f\" class=\"me lc ir gx ld mf mg dt lh mh mi dv ll jx mj mk lp kb ml mm lt kf mn mo lx mp fa\" data-selectable-paragraph=\"\">Crittografia ibrida omomorfa<\/h2>\n<p id=\"1477\" class=\"pw-post-body-paragraph jn jo ir gx b jp lz jr js jt ma jv jw jx mb jz ka kb mc kd ke kf md kh ki kj ik fa\" data-selectable-paragraph=\"\">Invece di criptare i dati con uno schema HE che produce un testo cifrato molto grande (espansione di ordine multiplo rispetto al testo in chiaro), HHE li cripta con un cifrario simmetrico con fattore di espansione pari a 1 e invia i testi cifrati simmetrici al server. Inoltre, il cliente deve inviare una versione crittografata in modo omomorfico della propria chiave simmetrica. Alla ricezione, il server esegue l&#8217;algoritmo di decrittazione simmetrica in modo omomorfico per trasformare il testo cifrato simmetrico in un testo cifrato omomorfico. Successivamente, il server pu\u00f2 eseguire calcoli sui dati criptati HE. Pi\u00f9 formalmente, possiamo definire uno schema HHE (secondo [2]) che consiste in 5 algoritmi come segue<\/p>\n<ol class=\"\">\n<li id=\"ad3b\" class=\"mq mr ir gx b jp jq jt ju jx ne kb nf kf ng kj nh mw mx my fa\" data-selectable-paragraph=\"\"><strong class=\"gx ni\">HHE.KeyGen<\/strong>(1<em class=\"nj\">\u207f)<\/em> \u2192<strong class=\"gx ni\">(pk<\/strong>,<span> <\/span><strong class=\"gx ni\">sk<\/strong>,<span> <\/span><strong class=\"gx ni\">evk<\/strong>): \u00c8 semplicemente l&#8217;algoritmo<span> <\/span><strong class=\"gx ni\">HE.KeyGen<span> <\/span><\/strong>che produce la chiave pubblica HE<strong class=\"gx ni\">(pk<\/strong>), la chiave segreta<strong class=\"gx ni\">(sk<\/strong>) e la chiave di valutazione<strong class=\"gx ni\">(evk<\/strong>).<\/li>\n<li id=\"d00e\" class=\"mq mr ir gx b jp mz jt na jx nb kb nc kf nd kj nh mw mx my fa\" data-selectable-paragraph=\"\"><strong class=\"gx ni\">HHE.Enc<\/strong>(1<em class=\"nj\">\u207f,<\/em><span> <\/span><strong class=\"gx ni\">pk<\/strong>,<span> <\/span><em class=\"nj\">m<\/em>): L&#8217;algoritmo di crittografia HHE.<br \/>Innanzitutto, crea una chiave simmetrica:<span> <\/span><strong class=\"gx ni\">SYM.KGen<\/strong>(1<em class=\"nj\">\u207f)<\/em> \u2192<span> <\/span><strong class=\"gx ni\">k<\/strong><br \/>Quindi, utilizzando questa chiave simmetrica, cripta il messaggio di testo in chiaro<span> <\/span><em class=\"nj\">m:<\/em><span> <\/span><strong class=\"gx ni\">SYM.Enc<\/strong><strong class=\"gx ni\">(k<\/strong>,<span> <\/span><em class=\"nj\">m<\/em>) \u2192<span> <\/span><em class=\"nj\">c\u209b.<span> <\/span><\/em>Qui,<span> <\/span><em class=\"nj\">c\u209b<\/em><span> <\/span>\u00e8 il testo cifrato simmetrico che verr\u00e0 inviato al server. Si noti che<span> <\/span><em class=\"nj\">c\u209b<\/em><span> <\/span>ha la stessa dimensione rispetto a<span> <\/span><em class=\"nj\">m.<\/em><em class=\"nj\"><br \/><\/em>Inoltre,<span> <\/span><strong class=\"gx ni\">HHE.Enc<\/strong><span> <\/span>cripta in modo omomorfico anche la chiave simmetrica<span> <\/span><strong class=\"gx ni\">k<span> <\/span><\/strong>utilizzando<strong class=\"gx ni\"><span> <\/span>HE.Enc<\/strong><strong class=\"gx ni\">(pk<\/strong>,<span> <\/span><strong class=\"gx ni\">k<\/strong>) \u2192<span> <\/span><strong class=\"gx ni\">c\u2096.<\/strong> Quindi,<strong class=\"gx ni\"><span> <\/span>c\u2096<\/strong><strong class=\"gx ni\"><span> <\/span> \u00e8 il testo cifrato HE della chiave simmetrica<\/strong><span> <\/span><strong class=\"gx ni\">k<\/strong>, e sar\u00e0 anche inviato al server insieme a<span> <\/span><em class=\"nj\">c\u209b<\/em><\/li>\n<li id=\"2d69\" class=\"mq mr ir gx b jp mz jt na jx nb kb nc kf nd kj nh mw mx my fa\" data-selectable-paragraph=\"\"><strong class=\"gx ni\">HHE.Decomp<\/strong><strong class=\"gx ni\">(evk<\/strong>,<span> <\/span><strong class=\"gx ni\">c\u2096,<\/strong><span> <\/span><em class=\"nj\">c\u209b)<\/em> \u2192<span> <\/span><em class=\"nj\">c<\/em>: L&#8217;algoritmo di decomposizione HHE che trasforma il testo cifrato simmetrico<span> <\/span><em class=\"nj\">c\u209b<\/em><span> <\/span>nel testo cifrato HE<span> <\/span><em class=\"nj\">c<\/em><span> <\/span>valutando in modo omomorfico l&#8217;algoritmo di decrittazione simmetrica usando<span> <\/span><strong class=\"gx ni\">c\u2096<span> <\/span><\/strong>e<span> <\/span><em class=\"nj\">c\u209b:<\/em><span> <\/span><strong class=\"gx ni\">HE.Eval<\/strong><strong class=\"gx ni\">(evk,<span> <\/span><\/strong> f=SYM<strong class=\"gx ni\">.Dec<\/strong>,<span> <\/span><strong class=\"gx ni\">c\u2096,<span> <\/span><\/strong> c<em class=\"nj\">\u209b)<\/em> \u2192<span> <\/span><em class=\"nj\">c<\/em><\/li>\n<li id=\"4b5d\" class=\"mq mr ir gx b jp mz jt na jx nb kb nc kf nd kj nh mw mx my fa\" data-selectable-paragraph=\"\"><strong class=\"gx ni\">HHE.Eval<\/strong><strong class=\"gx ni\">(evk<\/strong>,<span> <\/span> f,<span> <\/span> c<em class=\"nj\">\u2081, . . . , c\u1d62)<\/em><span> <\/span><em class=\"nj\">\u2192 c&#8217;:<\/em> L&#8217;algoritmo di valutazione HHE che restituisce semplicemente<span> <\/span><strong class=\"gx ni\">HE.Eval<\/strong><strong class=\"gx ni\">(evk<\/strong>,<span> <\/span> f,<span> <\/span> c<em class=\"nj\">\u2081, . . . , c\u1d62)<\/em><\/li>\n<li id=\"7b80\" class=\"mq mr ir gx b jp mz jt na jx nb kb nc kf nd kj nh mw mx my fa\" data-selectable-paragraph=\"\"><strong class=\"gx ni\">HHE.Dec<\/strong><strong class=\"gx ni\">(sk<\/strong>,<span> <\/span><em class=\"nj\">c<\/em>): L&#8217;algoritmo di decrittazione HHE. Restituisce semplicemente<span> <\/span><strong class=\"gx ni\">HE.Dec<\/strong><strong class=\"gx ni\">(sk<\/strong>,<span> <\/span><em class=\"nj\">c<\/em>)<\/li>\n<\/ol>\n<p id=\"3a6b\" class=\"pw-post-body-paragraph jn jo ir gx b jp jq jr js jt ju jv jw jx jy jz ka kb kc kd ke kf kg kh ki kj ik fa\" data-selectable-paragraph=\"\">Si noti che nel passo 2 si deve inviare<span> <\/span><strong class=\"gx ni\">c\u2096<span> <\/span><\/strong>e<span> <\/span><em class=\"nj\">c\u209b<\/em><span> <\/span>al server. Qui,<span> <\/span><strong class=\"gx ni\">c\u2096<span> <\/span><\/strong>\u00e8 il testo cifrato HE e pu\u00f2 essere di grandi dimensioni. Tuttavia, \u00e8 sufficiente inviare<span> <\/span><strong class=\"gx ni\">c\u2096<span> <\/span><\/strong>al server una volta, ad esempio in una fase di configurazione. Il server pu\u00f2 utilizzarlo ripetutamente nel file<span> <\/span><strong class=\"gx ni\">HHE.Decomp<\/strong><span> <\/span>algoritmo per trasformare i nuovi cifrari simmetrici nei corrispondenti cifrari HE. Questa \u00e8 la differenza chiave tra HHE e HE: invece di inviare ogni volta al server i testi cifrati HE, che possono richiedere molta larghezza di banda, HHE invia testi cifrati simmetrici leggeri. Questo trucco rende HHE in grado di funzionare con dispositivi a risorse limitate, poich\u00e9 i cifrari simmetrici sono anche molto leggeri da eseguire.<\/p>\n<h1 id=\"e7d1\" class=\"lb lc ir gx ld le lf lg lh li lj lk ll lm ln lo lp lq lr ls lt lu lv lw lx ly fa\" data-selectable-paragraph=\"\">Siete pronti per un po&#8217; di codice?<\/h1>\n<p id=\"3cd3\" class=\"pw-post-body-paragraph jn jo ir gx b jp lz jr js jt ma jv jw jx mb jz ka kb mc kd ke kf md kh ki kj ik fa\" data-selectable-paragraph=\"\">Prima di immergerci nel codice, rivediamo il protocollo che costruiremo: Abbiamo due parti (un client e un server) le cui azioni possono essere riassunte in 3 fasi principali:<\/p>\n<ol class=\"\">\n<li id=\"d267\" class=\"mq mr ir gx b jp jq jt ju jx ne kb nf kf ng kj nh mw mx my fa\" data-selectable-paragraph=\"\">Il client crea le chiavi con<span> <\/span> HHE<strong class=\"gx ni\">.KeyGen<\/strong>, cripta i dati con<span> <\/span> HHE<strong class=\"gx ni\">.Enc<\/strong><span> <\/span>e invia al server il testo cifrato simmetrico dei suoi dati<em class=\"nj\">(c\u209b)<\/em><em class=\"nj\">,<span> <\/span><\/em>il testo cifrato HE della sua chiave simmetrica<strong class=\"gx ni\">(c\u2096)<\/strong>, le chiavi HE tranne la chiave segreta<span> <\/span><strong class=\"gx ni\">sk<span> <\/span><\/strong>.<\/li>\n<li id=\"c987\" class=\"mq mr ir gx b jp mz jt na jx nb kb nc kf nd kj nh mw mx my fa\" data-selectable-paragraph=\"\">Il server esegue l&#8217;algoritmo<span> <\/span> HHE<strong class=\"gx ni\">.Decomp<\/strong><span> <\/span>e una trasformazione lineare sui dati crittografati HE del client utilizzando<span> <\/span> HHE<strong class=\"gx ni\">.Eval<\/strong>, ottiene il risultato crittografato e lo invia nuovamente al client.<\/li>\n<li id=\"b5a4\" class=\"mq mr ir gx b jp mz jt na jx nb kb nc kf nd kj nh mw mx my fa\" data-selectable-paragraph=\"\">Alla ricezione, il client decifra il risultato con<span> <\/span> HHE<strong class=\"gx ni\">.Dec<\/strong><span> <\/span>e ottiene l&#8217;output finale in chiaro.<\/li>\n<\/ol>\n<p id=\"1307\" class=\"pw-post-body-paragraph jn jo ir gx b jp jq jr js jt ju jv jw jx jy jz ka kb kc kd ke kf kg kh ki kj ik fa\" data-selectable-paragraph=\"\">L&#8217;intero<span> <\/span><a class=\"ae la\" href=\"https:\/\/github.com\/khoaguin\/priv-sec-ai-blog\/tree\/main\/what-is-hhe\" rel=\"noopener ugc nofollow\" target=\"_blank\">codice dimostrativo<\/a><span> <\/span>\u00e8 in C++ e si basa sul sistema<span> <\/span><a class=\"ae la\" href=\"https:\/\/github.com\/microsoft\/SEAL\" rel=\"noopener ugc nofollow\" target=\"_blank\">Il SEAL di Microsoft<\/a><span> <\/span>e<span> <\/span><a class=\"ae la\" href=\"https:\/\/github.com\/IAIK\/hybrid-HE-framework\" rel=\"noopener ugc nofollow\" target=\"_blank\">Biblioteca della PASTA<\/a>. Per prima cosa, creiamo due strutture che rappresentano il client e il server:<\/p>\n<pre class=\"kl km kn ko gr nk nl nm bn nn no bi\"><span id=\"05e4\" class=\"np lc ir nl b be nq nr l ns nt\" data-selectable-paragraph=\"\"><span class=\"hljs-keyword\">struct<\/span> <span class=\"hljs-title.class\">Client<\/span>\n{\n    <span class=\"hljs-comment\">\/\/ the HE keys<\/span>\n    seal::PublicKey he_pk;  <span class=\"hljs-comment\">\/\/ HE public key<\/span>\n    seal::SecretKey he_sk;  <span class=\"hljs-comment\">\/\/ HE secret key<\/span>\n    seal::RelinKeys he_rk;  <span class=\"hljs-comment\">\/\/ HE relinearization key (you don't have to care about this)<\/span>\n    seal::GaloisKeys he_gk; <span class=\"hljs-comment\">\/\/ HE galois key (you don't have to care about this)<\/span>\n    <span class=\"hljs-comment\">\/\/ client's symmetric keys<\/span>\n    std::vector&lt;<span class=\"hljs-type\">uint64_t<\/span>&gt; k;           <span class=\"hljs-comment\">\/\/ the secret symmetric keys<\/span>\n    std::vector&lt;seal::Ciphertext&gt; c_k; <span class=\"hljs-comment\">\/\/ the HE encrypted symmetric keys<\/span>\n    <span class=\"hljs-comment\">\/\/ client's data<\/span>\n    std::vector&lt;<span class=\"hljs-type\">uint64_t<\/span>&gt; m{<span class=\"hljs-number\">0<\/span>, <span class=\"hljs-number\">5<\/span>, <span class=\"hljs-number\">255<\/span>, <span class=\"hljs-number\">100<\/span>, <span class=\"hljs-number\">255<\/span>}; <span class=\"hljs-comment\">\/\/ the client's secret data<\/span>\n    std::vector&lt;<span class=\"hljs-type\">uint64_t<\/span>&gt; c_s;                    <span class=\"hljs-comment\">\/\/ the symmetric encrypted data<\/span>\n    seal::Ciphertext c_res;                       <span class=\"hljs-comment\">\/\/ the HE encrypted result received from the server<\/span>\n};\n\n<span class=\"hljs-keyword\">struct<\/span> <span class=\"hljs-title.class\">Server<\/span>\n{\n    std::vector&lt;<span class=\"hljs-type\">int64_t<\/span>&gt; w{<span class=\"hljs-number\">-1<\/span>, <span class=\"hljs-number\">2<\/span>, <span class=\"hljs-number\">-3<\/span>, <span class=\"hljs-number\">4<\/span>, <span class=\"hljs-number\">5<\/span>};    <span class=\"hljs-comment\">\/\/ dummy weights<\/span>\n    std::vector&lt;<span class=\"hljs-type\">int64_t<\/span>&gt; b{<span class=\"hljs-number\">-5<\/span>, <span class=\"hljs-number\">-5<\/span>, <span class=\"hljs-number\">-5<\/span>, <span class=\"hljs-number\">-5<\/span>, <span class=\"hljs-number\">-5<\/span>}; <span class=\"hljs-comment\">\/\/ dummy biases<\/span>\n    std::vector&lt;seal::Ciphertext&gt; c;            <span class=\"hljs-comment\">\/\/ the HE encrypted ciphertext of client's data<\/span>\n    seal::SecretKey he_sk;                      <span class=\"hljs-comment\">\/\/ the server's HE secret key<\/span>\n    seal::Ciphertext c_res;                     <span class=\"hljs-comment\">\/\/ the HE encrypted results that will be sent to the client<\/span>\n};\n\nClient client;\nServer server;<\/span><\/pre>\n<h2 id=\"9e2b\" class=\"me lc ir gx ld mf mg dt lh mh mi dv ll jx mj mk lp kb ml mm lt kf mn mo lx mp fa\" data-selectable-paragraph=\"\">Passo 1<\/h2>\n<p id=\"52e6\" class=\"pw-post-body-paragraph jn jo ir gx b jp lz jr js jt ma jv jw jx mb jz ka kb mc kd ke kf md kh ki kj ik fa\" data-selectable-paragraph=\"\">Il client crea il contesto SEAL, responsabile della creazione delle chiavi HE e di altri oggetti SEAL per la codifica, la crittografia e la decodifica dei dati (BatchEncoder, Encryptor, Decryptor, Evaluator).<\/p>\n<pre class=\"kl km kn ko gr nk nl nm bn nn no bi\"><span id=\"afaf\" class=\"np lc ir nl b be nq nr l ns nt\" data-selectable-paragraph=\"\">std::shared_ptr&lt;seal::SEALContext&gt; context = sealhelper::<span class=\"hljs-built_in\">get_seal_context<\/span>();\nsealhelper::<span class=\"hljs-built_in\">print_parameters<\/span>(*context);\n<span class=\"hljs-function\">seal::KeyGenerator <span class=\"hljs-title\">keygen<\/span><span class=\"hljs-params\">(*context)<\/span><\/span>;\nkeygen.<span class=\"hljs-built_in\">create_public_key<\/span>(client.he_pk);\nclient.he_sk = keygen.<span class=\"hljs-built_in\">secret_key<\/span>();\nkeygen.<span class=\"hljs-built_in\">create_relin_keys<\/span>(client.he_rk);\n<span class=\"hljs-function\">seal::BatchEncoder <span class=\"hljs-title\">he_benc<\/span><span class=\"hljs-params\">(*context)<\/span><\/span>;\n<span class=\"hljs-function\">seal::Encryptor <span class=\"hljs-title\">he_enc<\/span><span class=\"hljs-params\">(*context, client.he_pk)<\/span><\/span>;\n<span class=\"hljs-function\">seal::Evaluator <span class=\"hljs-title\">he_eval<\/span><span class=\"hljs-params\">(*context)<\/span><\/span>;\n<span class=\"hljs-function\">seal::Decryptor <span class=\"hljs-title\">he_dec<\/span><span class=\"hljs-params\">(*context, client.he_sk)<\/span><\/span>;\n<span class=\"hljs-type\">bool<\/span> use_bsgs = <span class=\"hljs-literal\">false<\/span>;\nstd::vector&lt;<span class=\"hljs-type\">int<\/span>&gt; gk_indices = pastahelper::<span class=\"hljs-built_in\">add_gk_indices<\/span>(use_bsgs, he_benc);\nkeygen.<span class=\"hljs-built_in\">create_galois_keys<\/span>(gk_indices, client.he_gk);<\/span><\/pre>\n<p id=\"65fa\" class=\"pw-post-body-paragraph jn jo ir gx b jp jq jr js jt ju jv jw jx jy jz ka kb kc kd ke kf kg kh ki kj ik fa\" data-selectable-paragraph=\"\">Il client esegue quindi l&#8217;algoritmo di crittografia<strong class=\"gx ni\">(HHE.Enc<\/strong>) per creare la chiave simmetrica<em class=\"nj\">(client.k<\/em>) e il testo cifrato simmetrico<em class=\"nj\">(client.c_s<\/em>).<\/p>\n<pre class=\"kl km kn ko gr nk nl nm bn nn no bi\"><span id=\"80f9\" class=\"np lc ir nl b be nq nr l ns nt\" data-selectable-paragraph=\"\">client.k = pastahelper::<span class=\"hljs-built_in\">get_symmetric_key<\/span>();\n<span class=\"hljs-function\">pasta::PASTA <span class=\"hljs-title\">SymmetricEncryptor<\/span><span class=\"hljs-params\">(client.k, configs::plain_mod)<\/span><\/span>;\nclient.c_s = SymmetricEncryptor.<span class=\"hljs-built_in\">encrypt<\/span>(client.m);<\/span><\/pre>\n<p id=\"ec43\" class=\"pw-post-body-paragraph jn jo ir gx b jp jq jr js jt ju jv jw jx jy jz ka kb kc kd ke kf kg kh ki kj ik fa\" data-selectable-paragraph=\"\">Se stampiamo i valori di<span> <\/span><em class=\"nj\">client.c_s<\/em>, vedremo un vettore di valori casuali come [30446, 62410, 62969, 38863, 43376], in contrapposizione ai dati in chiaro del client [0, 5, 255, 100, 255]. Il client invia al server solo il vettore di valori casuali e mai i suoi dati in chiaro.<\/p>\n<p id=\"62fd\" class=\"pw-post-body-paragraph jn jo ir gx b jp jq jr js jt ju jv jw jx jy jz ka kb kc kd ke kf kg kh ki kj ik fa\" data-selectable-paragraph=\"\">Successivamente, il cliente cripta la sua chiave simmetrica<em class=\"nj\">(client.k<\/em>) utilizzando HE per creare<span> <\/span><em class=\"nj\">client.c_k.<\/em><\/p>\n<pre class=\"kl km kn ko gr nk nl nm bn nn no bi\"><span id=\"7d32\" class=\"np lc ir nl b be nq nr l ns nt\" data-selectable-paragraph=\"\">client.c_k = pastahelper::<span class=\"hljs-built_in\">encrypt_symmetric_key<\/span>(client.k,\n                                                configs::USE_BATCH,\n                                                he_benc,\n                                                he_enc);<\/span><\/pre>\n<p id=\"8b5c\" class=\"pw-post-body-paragraph jn jo ir gx b jp jq jr js jt ju jv jw jx jy jz ka kb kc kd ke kf kg kh ki kj ik fa\" data-selectable-paragraph=\"\">Successivamente, il client invia al server<span> <\/span><em class=\"nj\">client.c_k, client.c_s<\/em><span> <\/span>e le chiavi HE, ad eccezione della chiave segreta.<\/p>\n<h2 id=\"7495\" class=\"me lc ir gx ld mf mg dt lh mh mi dv ll jx mj mk lp kb ml mm lt kf mn mo lx mp fa\" data-selectable-paragraph=\"\">Passo 2<\/h2>\n<p id=\"c0a9\" class=\"pw-post-body-paragraph jn jo ir gx b jp lz jr js jt ma jv jw jx mb jz ka kb mc kd ke kf md kh ki kj ik fa\" data-selectable-paragraph=\"\">Dopo aver ricevuto il<span> <\/span><em class=\"nj\">client.c_k<\/em>, il server crea la propria chiave segreta HE, l&#8217;oggetto HHE ed esegue l&#8217;algoritmo di decomposizione che risulta in<span> <\/span><em class=\"nj\">server.c<span> <\/span><\/em>che \u00e8 il testo cifrato HE del messaggio in chiaro del cliente<span> <\/span><em class=\"nj\">m.<\/em> Si noti che il client non invia mai la sua chiave segreta<span> <\/span><strong class=\"gx ni\">he_sk<\/strong><span> <\/span>al server, in modo che il server non sia in grado di decifrare<span> <\/span><em class=\"nj\">server.c<\/em>.<\/p>\n<pre class=\"kl km kn ko gr nk nl nm bn nn no bi\"><span id=\"c73d\" class=\"np lc ir nl b be nq nr l ns nt\" data-selectable-paragraph=\"\"><span class=\"hljs-function\">seal::KeyGenerator <span class=\"hljs-title\">csp_keygen<\/span><span class=\"hljs-params\">(*context)<\/span><\/span>;\nserver.he_sk = csp_keygen.<span class=\"hljs-built_in\">secret_key<\/span>();\n<span class=\"hljs-function\">pasta::PASTA_SEAL <span class=\"hljs-title\">HHE<\/span><span class=\"hljs-params\">(context, client.he_pk, server.he_sk, client.he_rk, client.he_gk)<\/span><\/span>;\nserver.c = HHE.<span class=\"hljs-built_in\">decomposition<\/span>(client.c_s, client.c_k, configs::USE_BATCH);<\/span><\/pre>\n<p id=\"f593\" class=\"pw-post-body-paragraph jn jo ir gx b jp jq jr js jt ju jv jw jx jy jz ka kb kc kd ke kf kg kh ki kj ik fa\" data-selectable-paragraph=\"\">Il server codifica quindi i suoi pesi<span> <\/span> w<span> <\/span>e le sue polarizzazioni<span> <\/span> b<span> <\/span>ed esegue una moltiplicazione vettoriale element-wise e un&#8217;addizione sui suoi pesi e polarizzazioni in chiaro con i dati criptati HE<span> <\/span><em class=\"nj\">server.c.<\/em><\/p>\n<pre class=\"kl km kn ko gr nk nl nm bn nn no bi\"><span id=\"d4fb\" class=\"np lc ir nl b be nq nr l ns nt\" data-selectable-paragraph=\"\">seal::Plaintext plain_w, plain_b;\nhe_benc.<span class=\"hljs-built_in\">encode<\/span>(server.w, plain_w);\nhe_benc.<span class=\"hljs-built_in\">encode<\/span>(server.b, plain_b);\nserver.c_res = sealhelper::<span class=\"hljs-built_in\">he_mult<\/span>(he_eval, server.c[<span class=\"hljs-number\">0<\/span>], plain_w);\nclient.c_res = sealhelper::<span class=\"hljs-built_in\">he_add<\/span>(he_eval, server.c_res, plain_b);<\/span><\/pre>\n<p id=\"1017\" class=\"pw-post-body-paragraph jn jo ir gx b jp jq jr js jt ju jv jw jx jy jz ka kb kc kd ke kf kg kh ki kj ik fa\" data-selectable-paragraph=\"\">Si pu\u00f2 notare che il risultato finale \u00e8 client.c_res, che \u00e8 il testo cifrato SEAL che il client ricever\u00e0.<\/p>\n<h2 id=\"266c\" class=\"me lc ir gx ld mf mg dt lh mh mi dv ll jx mj mk lp kb ml mm lt kf mn mo lx mp fa\" data-selectable-paragraph=\"\">Passo 3<\/h2>\n<p id=\"21ae\" class=\"pw-post-body-paragraph jn jo ir gx b jp lz jr js jt ma jv jw jx mb jz ka kb mc kd ke kf md kh ki kj ik fa\" data-selectable-paragraph=\"\">Infine, il client decifra il suo<span> <\/span> c_res<em class=\"nj\"><span> <\/span> utilizzando la sua chiave segreta:<\/em><\/p>\n<pre class=\"kl km kn ko gr nk nl nm bn nn no bi\"><span id=\"be58\" class=\"np lc ir nl b be nq nr l ns nt\" data-selectable-paragraph=\"\">std::vector&lt;<span class=\"hljs-type\">int64_t<\/span>&gt; decrypted_res = sealhelper::<span class=\"hljs-built_in\">decrypt<\/span>(client.c_res,\n                                                         client.he_sk,\n                                                         he_benc,\n                                                         *context,\n                                                         client.m.<span class=\"hljs-built_in\">size<\/span>());<\/span><\/pre>\n<p id=\"8b98\" class=\"pw-post-body-paragraph jn jo ir gx b jp jq jr js jt ju jv jw jx jy jz ka kb kc kd ke kf kg kh ki kj ik fa\" data-selectable-paragraph=\"\">Stampando<span> <\/span><em class=\"nj\">decrypted_res<\/em>, vedremo che il risultato sar\u00e0 [-5 5 -770 395 1270], che \u00e8 corretto perch\u00e9<\/p>\n<p id=\"07a4\" class=\"pw-post-body-paragraph jn jo ir gx b jp jq jr js jt ju jv jw jx jy jz ka kb kc kd ke kf kg kh ki kj ik fa\" data-selectable-paragraph=\"\">[0, 5, 255, 100, 255]<br \/>\u2299<br \/>[-1, 2, -3, 4, 5]<br \/>\u2295<br \/>[-5, -5, -5, -5, -5]<br \/>=<br \/>[-5, 5, -770, 395, 1270]<\/p>\n<p id=\"c802\" class=\"pw-post-body-paragraph jn jo ir gx b jp jq jr js jt ju jv jw jx jy jz ka kb kc kd ke kf kg kh ki kj ik fa\" data-selectable-paragraph=\"\">dove \u2299, \u2295 sono rispettivamente la moltiplicazione e l&#8217;addizione vettoriale elementare.<\/p>\n<p id=\"9d50\" class=\"pw-post-body-paragraph jn jo ir gx b jp jq jr js jt ju jv jw jx jy jz ka kb kc kd ke kf kg kh ki kj ik fa\" data-selectable-paragraph=\"\">Il risultato dell&#8217;esecuzione del codice dimostrativo \u00e8 visibile nell&#8217;immagine seguente<\/p>\n<figure class=\"kl km kn ko gr kp gf gg paragraph-image\">\n<div role=\"button\" class=\"kq kr di ks bf kt\" tabindex=\"0\">\n<div class=\"gf gg nu\"><picture><source srcset=\"https:\/\/miro.medium.com\/max\/640\/1*ZtNNyvFRJGGrzT_vuENTKQ.webp 640w, https:\/\/miro.medium.com\/max\/720\/1*ZtNNyvFRJGGrzT_vuENTKQ.webp 720w, https:\/\/miro.medium.com\/max\/750\/1*ZtNNyvFRJGGrzT_vuENTKQ.webp 750w, https:\/\/miro.medium.com\/max\/786\/1*ZtNNyvFRJGGrzT_vuENTKQ.webp 786w, https:\/\/miro.medium.com\/max\/828\/1*ZtNNyvFRJGGrzT_vuENTKQ.webp 828w, https:\/\/miro.medium.com\/max\/1100\/1*ZtNNyvFRJGGrzT_vuENTKQ.webp 1100w, https:\/\/miro.medium.com\/max\/1400\/1*ZtNNyvFRJGGrzT_vuENTKQ.webp 1400w\" sizes=\"(min-resolution: 4dppx) and (max-width: 700px) 50vw, (-webkit-min-device-pixel-ratio: 4) and (max-width: 700px) 50vw, (min-resolution: 3dppx) and (max-width: 700px) 67vw, (-webkit-min-device-pixel-ratio: 3) and (max-width: 700px) 65vw, (min-resolution: 2.5dppx) and (max-width: 700px) 80vw, (-webkit-min-device-pixel-ratio: 2.5) and (max-width: 700px) 80vw, (min-resolution: 2dppx) and (max-width: 700px) 100vw, (-webkit-min-device-pixel-ratio: 2) and (max-width: 700px) 100vw, 700px\" type=\"image\/webp\"><\/source><source data-testid=\"og\" srcset=\"https:\/\/miro.medium.com\/max\/640\/1*ZtNNyvFRJGGrzT_vuENTKQ.png 640w, https:\/\/miro.medium.com\/max\/720\/1*ZtNNyvFRJGGrzT_vuENTKQ.png 720w, https:\/\/miro.medium.com\/max\/750\/1*ZtNNyvFRJGGrzT_vuENTKQ.png 750w, https:\/\/miro.medium.com\/max\/786\/1*ZtNNyvFRJGGrzT_vuENTKQ.png 786w, https:\/\/miro.medium.com\/max\/828\/1*ZtNNyvFRJGGrzT_vuENTKQ.png 828w, https:\/\/miro.medium.com\/max\/1100\/1*ZtNNyvFRJGGrzT_vuENTKQ.png 1100w, https:\/\/miro.medium.com\/max\/1400\/1*ZtNNyvFRJGGrzT_vuENTKQ.png 1400w\" sizes=\"(min-resolution: 4dppx) and (max-width: 700px) 50vw, (-webkit-min-device-pixel-ratio: 4) and (max-width: 700px) 50vw, (min-resolution: 3dppx) and (max-width: 700px) 67vw, (-webkit-min-device-pixel-ratio: 3) and (max-width: 700px) 65vw, (min-resolution: 2.5dppx) and (max-width: 700px) 80vw, (-webkit-min-device-pixel-ratio: 2.5) and (max-width: 700px) 80vw, (min-resolution: 2dppx) and (max-width: 700px) 100vw, (-webkit-min-device-pixel-ratio: 2) and (max-width: 700px) 100vw, 700px\"><\/source><img decoding=\"async\" alt=\"\" class=\"bf ku kv dj\" width=\"700\" height=\"313\" loading=\"lazy\" role=\"presentation\" src=\"https:\/\/miro.medium.com\/max\/700\/1*ZtNNyvFRJGGrzT_vuENTKQ.png\"><\/picture><\/div>\n<\/div>\n<\/figure>\n<h1 id=\"3043\" class=\"lb lc ir gx ld le lf lg lh li lj lk ll lm ln lo lp lq lr ls lt lu lv lw lx ly fa\" data-selectable-paragraph=\"\">Direzioni future e conclusioni<\/h1>\n<p id=\"89ab\" class=\"pw-post-body-paragraph jn jo ir gx b jp lz jr js jt ma jv jw jx mb jz ka kb mc kd ke kf md kh ki kj ik fa\" data-selectable-paragraph=\"\">In questo articolo abbiamo imparato a conoscere la crittografia omomorfa ibrida, i suoi vantaggi rispetto alla crittografia omomorfa semplice, un caso d&#8217;uso esemplificativo di HHE e abbiamo anche assistito a un protocollo dimostrativo molto semplice in C++. In pratica, questo protocollo pu\u00f2 essere esteso a 3 parti, il che \u00e8 adatto all&#8217;analisi dei dati criptati o all&#8217;apprendimento automatico. Per saperne di pi\u00f9 sul protocollo HHE a 3 parti, \u00e8 possibile consultare un documento pubblicato di recente [3] presso il nostro sito web<span> <\/span><a class=\"ae la\" href=\"https:\/\/research.tuni.fi\/nisec\/\" rel=\"noopener ugc nofollow\" target=\"_blank\">Laboratorio NISEC<\/a><span> <\/span>all&#8217;Universit\u00e0 di Tampere. Spero che questo articolo vi sia utile e che nel frattempo vi divertiate a imparare qualcosa di nuovo!<\/p>\n<h1 id=\"ff0a\" class=\"lb lc ir gx ld le lf lg lh li lj lk ll lm ln lo lp lq lr ls lt lu lv lw lx ly fa\" data-selectable-paragraph=\"\">Riconoscimento<\/h1>\n<p id=\"ac3c\" class=\"pw-post-body-paragraph jn jo ir gx b jp lz jr js jt ma jv jw jx mb jz ka kb mc kd ke kf md kh ki kj ik fa\" data-selectable-paragraph=\"\">Questo lavoro \u00e8 stato finanziato dal<a class=\"ae la\" href=\"https:\/\/harpocrates-project.eu\/it\/\" rel=\"noopener ugc nofollow\" target=\"_blank\">progetto HARPOCRATES dell&#8217;UE<\/a><span> <\/span><a class=\"ae la\" href=\"https:\/\/harpocrates-project.eu\/it\/\" rel=\"noopener ugc nofollow\" target=\"_blank\">.<\/a><\/p>\n<h1 id=\"8ca4\" class=\"ju jv hk fh jw jx jy jz ka kb kc kd ke kf kg kh ki kj kk kl km kn ko kp kq kr dt\" data-selectable-paragraph=\"\">Riferimento<\/h1>\n<p id=\"ab0f\" class=\"pw-post-body-paragraph ig ih hk fh b ii ks ik il im kt io ip iq ku is it iu kv iw ix iy kw ja jb jc hd dt\" data-selectable-paragraph=\"\">[1] Brakerski, Zvika e Vinod Vaikuntanathan. &#8220;Crittografia completamente omomorfa efficiente da LWE (standard)&#8221;.<span> <\/span><em class=\"me\">Rivista SIAM sull&#8217;informatica<\/em><span> <\/span>43.2 (2014): 831-871.<\/p>\n<p id=\"2d03\" class=\"pw-post-body-paragraph ig ih hk fh b ii ij ik il im in io ip iq ir is it iu iv iw ix iy iz ja jb jc hd dt\" data-selectable-paragraph=\"\">[2] Dobraunig, Christoph, et al. &#8220;Pasta: un caso di crittografia omomorfa ibrida&#8221;.<span> <\/span><em class=\"me\">Archivio ePrint di crittologia<\/em><span> <\/span>(2021).<\/p>\n<p id=\"dd2c\" class=\"pw-post-body-paragraph ig ih hk fh b ii ij ik il im in io ip iq ir is it iu iv iw ix iy iz ja jb jc hd dt\" data-selectable-paragraph=\"\">[3] Alexandros Bakas, Eugene Frimpong, Antonis Michalas<em class=\"me\">. &#8220;<\/em>Travestimento simmetrico: Realizzazione di servizi di crittografia omomorfica da primitivi simmetrici&#8221;. EAI SECURECOMM (2022).<\/p>\n<p class=\"pw-post-body-paragraph jn jo ir gx b jp lz jr js jt ma jv jw jx mb jz ka kb mc kd ke kf md kh ki kj ik fa\" data-selectable-paragraph=\"\">\n<p class=\"pw-post-body-paragraph jn jo ir gx b jp lz jr js jt ma jv jw jx mb jz ka kb mc kd ke kf md kh ki kj ik fa\" data-selectable-paragraph=\"\"><em>Scritto da: Khoa Nguyen, Universit\u00e0 di Tampere<\/em><\/p>\n<p>[\/et_pb_text][\/et_pb_column][et_pb_column type=&#8221;1_3&#8243; _builder_version=&#8221;4.19.1&#8243; _module_preset=&#8221;default&#8221; global_colors_info=&#8221;{}&#8221;][et_pb_sidebar _builder_version=&#8221;4.19.1&#8243; _module_preset=&#8221;default&#8221; global_colors_info=&#8221;{}&#8221;][\/et_pb_sidebar][\/et_pb_column][\/et_pb_row][\/et_pb_section]<\/p>\n","protected":false},"excerpt":{"rendered":"<p><div class=\"et_pb_module lwp_divi_breadcrumbs lwp_divi_breadcrumbs_0\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module_inner\">\n\t\t\t\t\t<div class=\"lwp-breadcrumbs\"> <span class=\"before\"><\/span> <span vocab=\"https:\/\/schema.org\/\" typeof=\"BreadcrumbList\"><span property=\"itemListElement\" typeof=\"ListItem\"><a property=\"item\" typeof=\"WebPage\" href=\"https:\/\/harpocrates-project.eu\/it\/\" class=\"home\"><span property=\"name\">Home<\/span><\/a><meta property=\"position\" content=\"1\"><\/span> <span class=\"separator et-pb-icon\">&amp;#x39;<\/span> <\/span><\/div>\n\t\t\t\t<\/div>\n\t\t\t<\/div>Cos&#8217;\u00e8 la crittografia ibrida omomorfa e le sue applicazioni 9.2.2023 10:03 &nbsp;TL;DR Introdurre il concetto di crittografia omomorfa ibrida, i suoi casi d&#8217;uso, una breve formulazione e uncodice dimostrativo in C++. Introduzione Le applicazioni che preservano la privacy sono diventate un argomento importante al giorno [&hellip;]<\/p>\n","protected":false},"author":3,"featured_media":1827,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_et_pb_use_builder":"on","_et_pb_old_content":"","_et_gb_content_width":"","footnotes":""},"categories":[40],"tags":[],"class_list":["post-2627","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-notizie"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/harpocrates-project.eu\/it\/wp-json\/wp\/v2\/posts\/2627","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/harpocrates-project.eu\/it\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/harpocrates-project.eu\/it\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/harpocrates-project.eu\/it\/wp-json\/wp\/v2\/users\/3"}],"replies":[{"embeddable":true,"href":"https:\/\/harpocrates-project.eu\/it\/wp-json\/wp\/v2\/comments?post=2627"}],"version-history":[{"count":6,"href":"https:\/\/harpocrates-project.eu\/it\/wp-json\/wp\/v2\/posts\/2627\/revisions"}],"predecessor-version":[{"id":2650,"href":"https:\/\/harpocrates-project.eu\/it\/wp-json\/wp\/v2\/posts\/2627\/revisions\/2650"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/harpocrates-project.eu\/it\/wp-json\/wp\/v2\/media\/1827"}],"wp:attachment":[{"href":"https:\/\/harpocrates-project.eu\/it\/wp-json\/wp\/v2\/media?parent=2627"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/harpocrates-project.eu\/it\/wp-json\/wp\/v2\/categories?post=2627"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/harpocrates-project.eu\/it\/wp-json\/wp\/v2\/tags?post=2627"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}