ACE Encrypt

${\displaystyle \mathbb {Z} }$— El conjunto de los números enteros. ${\displaystyle F_{2}[T]}$— El conjunto de polinomios univariados con coeficientes en el campo finito${\displaystyle F_{2}}$de cardinalidad 2. ${\displaystyle A\operatorname {rem} n}$— entero${\displaystyle r\in \left\{0,\dots ,n-1\right\}}$de tal manera que${\displaystyle A\equiv r{\pmod {n}}}$para entero${\displaystyle n>0}$y${\displaystyle A\in \mathbb {Z} }$. ${\displaystyle A\operatorname {rem} f}$— polinomio${\displaystyle r\in F_{2}[T]}$con${\displaystyle \deg(r)<\deg(f)}$de tal manera que${\displaystyle A\equiv r{\pmod {f}}}$con${\displaystyle A,f\in F_{2}[T],f\neq 0}$.

${\displaystyle A^{\ast }}$— El conjunto de todas las cuerdas. ${\displaystyle A^{n}}$— El conjunto de todas las cadenas con longitud n. Para${\displaystyle x\in A^{\ast }L(x)}$— longitud de la cuerda${\displaystyle x}$La cadena de longitud cero se denota${\displaystyle \lambda _{A}}$. Para${\displaystyle x,y\in A^{\ast }}$${\displaystyle x\|y}$— el resultado de${\displaystyle x}$y${\displaystyle y}$concatenación.

${\displaystyle b{\overset {\text{def}}{{}={}}}\left\{0,1\right\}}$— El conjunto de bits. Tomemos todos los conjuntos de forma${\displaystyle b,b^{n_{1}},(b^{n_{1}})^{n_{2}},...}$Para un conjunto A de este tipo, definimos el "elemento cero":

${\displaystyle 0_{b}{\stackrel {\mathrm {def} }{=}}0\in b}$;${\displaystyle 0_{A^{n}}{\stackrel {\mathrm {def} }{=}}(0_{A},...,0_{A})\in A^{n}}$para${\displaystyle n>0}$.

Nosotros definimos${\displaystyle B{\stackrel {\mathrm {def} }{{}={}}}b^{8}}$como un conjunto de bytes, y${\displaystyle W{\stackrel {\mathrm {def} }{{}={}}}b^{32}}$como un conjunto de palabras.

Para${\displaystyle x\in A^{\ast }}$con${\displaystyle A\in \left\{b,B,W\right\}}$y${\displaystyle l>0}$Definimos un operador de relleno:

${\displaystyle pad_{l}(x){\stackrel {\mathrm {def} }{=}}{\begin{cases}x,&L(x)\geq l\\x||0_{A^{lL(x)}},&L(x)<l\end{cases}}}$.

Operador de conversión${\displaystyle I_{src}^{dst}:src\to dst}$realiza una conversión entre elementos${\displaystyle Z,F_{2}[T],b^{\ast },B^{\ast },W^{\ast }}$.

El esquema de cifrado emplea dos tipos de clave: clave pública ACE:${\displaystyle (P,q,g_{1},g_{2},c,d,h_{1},h_{2},k_{1},k_{2})}$ Clave privada ACE :${\displaystyle (w,x,y,z_{1},z_{2})}$Para un parámetro de tamaño dado${\displaystyle m}$, de tal manera que${\displaystyle 1024\leq m\leq 16384}$Los componentes clave se definen como: ${\displaystyle q}$— un número primo de 256 bits. ${\displaystyle P}$— un número primo de m bits, tal que${\displaystyle P\equiv 1{\pmod {q}}}$. ${\displaystyle g_{1},g_{2},c,d,h_{1},h_{2}}$— elementos${\displaystyle \left\{1,\dots ,P-1\right\}}$(cuyo orden multiplicativo módulo${\displaystyle P}$divide${\displaystyle q}$). ${\displaystyle w,x,y,z_{1},z_{2}}$— elementos${\displaystyle \left\{0,\dots ,q-1\right\}}$. ${\displaystyle k_{1},k_{2}}$— elementos${\displaystyle B^{\ast }}$con${\displaystyle L(k_{1})=20l'+64}$y${\displaystyle L(k_{2})=32\left\lceil l/16\right\rceil +40}$, dónde${\displaystyle l=\left\lceil m/8\right\rceil }$y${\displaystyle l'=L_{b}(\left\lceil (2\left\lceil l/4\right\rceil +4)/16\right\rceil )}$.

Algoritmo. Generación de claves para el esquema de cifrado ACE. Entrada: un parámetro de tamaño.${\displaystyle m}$, de tal manera que${\displaystyle 1024\leq m\leq 16384}$Salida : un par de claves pública/privada.

1. Genera un número primo aleatorio${\displaystyle q}$, de tal manera que${\displaystyle 2^{255}<q<2^{256}}$.
2. Genera un número primo aleatorio${\displaystyle P}$,${\displaystyle 2^{m-1}<P<2^{m}}$, de tal manera que${\displaystyle P\equiv 1(modq)}$.
3. Generar un número entero aleatorio${\displaystyle g_{1}\in \left\{2,...,P-1\right\}}$, de tal manera que${\displaystyle g_{1}^{q}\equiv 1(modP)}$.
4. Generar números enteros aleatorios${\displaystyle w\in \left\{1,...,q-1\right\}}$y${\displaystyle x,y,z_{1},z_{2}\in \left\{0,...,q-1\right\}}$
5. Calcula los siguientes números enteros en${\displaystyle \left\{1,...,P-1\right\}}$:
   ${\displaystyle g_{2}\leftarrow g_{1}^{w}remP}$,${\displaystyle c\leftarrow g_{1}^{x}remP}$,${\displaystyle d\leftarrow g_{1}^{y}remP}$,${\displaystyle h_{1}\leftarrow g_{1}^{z_{1}}remP}$,${\displaystyle h_{2}\leftarrow g_{1}^{z_{2}}remP}$.
6. Generar cadenas de bytes aleatorias${\displaystyle k_{1}\in B^{20l'+64}}$y${\displaystyle k_{2}\in B^{2\left\lceil l/16\right\rceil +40}}$, dónde${\displaystyle l=L_{B}(P)}$y${\displaystyle l'=L_{B}(\left\lceil (2\left\lceil l/4\right\rceil +4)/16\right\rceil )}$.
7. Devuelve el par clave pública/clave privada.
   ${\displaystyle ((P,q,g_{1},g_{2},c,d,h_{1},h_{2},k_{1},k_{2}),(w,x,y,z_{1},z_{2}))}$

Un texto cifrado del esquema de cifrado ACE tiene la forma

${\displaystyle (s,u_{1},u_{2},v,e)}$,

donde los componentes se definen como: ${\displaystyle u_{1},u_{2},v}$— números enteros de${\displaystyle \left\{1,...,P-1\right\}}$(cuyo orden multiplicativo módulo${\displaystyle P}$divide${\displaystyle q}$). ${\displaystyle s}$- elemento${\displaystyle W^{4}}$. ${\displaystyle e}$- elemento${\displaystyle B^{\ast }}$. ${\displaystyle s,u_{1},u_{2},v}$llamamos preámbulo y${\displaystyle e}$— el criptograma . Si un texto plano es una cadena que consta de${\displaystyle l}$байт, entonces la longitud de${\displaystyle e}$es igual a${\displaystyle l+16\left\lceil l/1024\right\rceil }$Necesitamos introducir la función${\displaystyle CEncode}$, que asigna un texto cifrado a su cadena de bytes

representación y la función inversa correspondiente${\displaystyle CDecode}$Para el entero${\displaystyle l>0}$, cadena de palabras${\displaystyle s\in W^{4}}$, números enteros${\displaystyle 0\leq u_{1},u_{2},v<256^{l}}$y cadena de bytes${\displaystyle e\in B^{\ast }}$,

${\displaystyle CEncode(l,s,u_{1},u_{2},v,e){\stackrel {\mathrm {def} }{=}}I_{W^{\ast }}^{B^{\ast }}(s)||pad_{l}(I_{Z}^{B^{\ast }}(u_{1}))||pad_{l}(I_{Z}^{B^{\ast }}(u_{2}))||pad_{l}(I_{Z}^{B^{\ast }}(v))||e\in B^{\ast }}$.

Para entero${\displaystyle l>0}$, cadena de bytes${\displaystyle \psi \in B^{\ast }}$, de tal manera que${\displaystyle L(\psi )\geq 3l+16}$,

${\displaystyle CDecode(l,\psi ){\stackrel {\mathrm {def} }{=}}(I_{B^{\ast }}^{W^{\ast }}({\Bigl [}\psi {\Bigr ]}_{0}^{16}),I_{B^{\ast }}^{Z}({\Bigl [}\psi {\Bigr ]}_{16}^{16+l}),I_{B^{\ast }}^{Z}({\Bigl [}\psi {\Bigr ]}_{16+l}^{16+2l}),I_{B^{\ast }}^{Z}({\Bigl [}\psi {\Bigr ]}_{16+2l}^{16+3l}),{\Bigl [}\psi {\Bigr ]}_{16+3l}^{L(\psi )})\in W^{4}\times Z\times Z\times Z\times B^{\ast }}$.

Algoritmo. Operación de cifrado asimétrico ACE. Entrada: clave pública${\displaystyle (P,q,g_{1},g_{2},c,d,h_{1},h_{2},k_{1},k_{2})}$y cadena de bytes${\displaystyle M\in B^{\ast }}$Salida : cadena de bytes — texto cifrado${\displaystyle \psi \ }$de${\displaystyle M}$.

1. Generar${\displaystyle r\in \left\{0,...,q-1\right\}}$al azar.
2. Generar el preámbulo del texto cifrado:
   1. Generar${\displaystyle s\in W^{4}}$al azar.
   2. Calcular${\displaystyle u_{1}\leftarrow g_{1}^{r}remP}$,${\displaystyle u_{2}\leftarrow g_{2}^{r}remP}$.
   3. Calcular${\displaystyle \alpha \ \leftarrow UOWHash^{\prime }(k_{1},L_{B}(P),s,u_{1},u_{2})\in Z}$; tenga en cuenta que${\displaystyle 0<\alpha \ <2^{160}}$.
   4. Calcular${\displaystyle v\leftarrow c^{r}d^{\alpha \ r}remP}$.
3. Calcula la clave para la operación de cifrado simétrico:
   1. ${\displaystyle {\tilde {h_{1}}}\leftarrow h_{1}^{r}remP}$,${\displaystyle {\tilde {h_{2}}}\leftarrow h_{2}^{r}remP}$.
   2. Calcular${\displaystyle k\leftarrow ESHash(k,L_{B}(P),s,u_{1},u_{2},{\tilde {h_{1}}},{\tilde {h_{2}}})\in W^{8}}$.
4. Calcular criptograma${\displaystyle e\leftarrow SEnc(k,s,1024,M)}$.
5. Codifique el texto cifrado:
   ${\displaystyle \psi \ \leftarrow CEncode(L_{B}(P),s,u_{1},u_{2},v,e)}$.
6. Devolver${\displaystyle \psi \ }$.

Antes de iniciar el proceso de cifrado simétrico, el mensaje de entrada${\displaystyle M\in B^{\ast }}$está dividido en bloques${\displaystyle M_{1},...,M_{t}}$donde cada uno de los bloques, posiblemente excepto el último, tiene 1024 bytes. Cada bloque está cifrado mediante el cifrado de flujo. Para cada bloque cifrado${\displaystyle E_{i}}$Se calcula el código de autenticación de mensaje de 16 bytes. Obtenemos el criptograma.

${\displaystyle e=E_{1}||C_{1}||...||E_{t}||C_{t}}$.${\displaystyle L(e)=L(M)+16\left\lceil L(M)/m\right\rceil }$.

Tenga en cuenta que si${\displaystyle L(M)=0}$, entonces${\displaystyle L(e)=0}$.

Algoritmo. Proceso de cifrado asimétrico ACE. Entrada:${\displaystyle (k,s,M,m)\in W^{8}\times W^{4}\times Z\times B^{\ast }}$${\displaystyle m>0}$ Producción:${\displaystyle e\in B^{l}}$,${\displaystyle l=L(M)+16\left\lceil L(N)/m\right\rceil }$.

1. Si${\displaystyle M=\lambda _{B}}$, luego regresar${\displaystyle \lambda _{B}}$.
2. Inicializar un estado de generador pseudoaleatorio:
   ${\displaystyle genState\leftarrow InitGen(k,s)\in GenState}$
3. Generar la clave${\displaystyle k_{AXU}AXUHash}$:
   ${\displaystyle (k_{AXU},genState)\leftarrow GenWords((5L_{b}(\left\lceil m/64\right\rceil )+24),genState).}$.
4. ${\displaystyle e\leftarrow \lambda _{B},i\leftarrow 0}$.
5. Mientras${\displaystyle i<L(M)}$, haga lo siguiente:
   1. ${\displaystyle r\leftarrow min(L(M)-i,m)}$.
   2. Generar valores de máscara para el cifrado y el MAC:
      1. ${\displaystyle (mask_{m},genState)\leftarrow GenWords(4,genState)}$.
      2. ${\displaystyle (mask_{e},genState)\leftarrow GenWords(r,genState)}$.
   3. Encriptar el texto plano:${\displaystyle enc\leftarrow {\Bigl [}M{\Bigr ]}_{i}^{i+r}\oplus mask_{e}}$.
   4. Generar el código de autenticación del mensaje:
      1. Si${\displaystyle i+r=L(M)}$, entonces${\displaystyle lastBlock\leftarrow 1}$; demás${\displaystyle lastBlock\leftarrow 0}$.
      2. ${\displaystyle mac\leftarrow AXUHash(k_{AXU},lastBlock,enc)\in W^{4}}$.
   5. Actualizar el texto cifrado:${\displaystyle e\leftarrow e||enc||I_{W^{\ast }}^{B^{\ast }}(mac\oplus mask_{m})}$.
   6. ${\displaystyle i\leftarrow i+r}$.
6. Devolver${\displaystyle e}$.

Algoritmo. Proceso de descifrado ACE. Entrada: clave pública${\displaystyle (P,q,g_{1},g_{2},c,d,h_{1},h_{2},k_{1},k_{2})}$y la clave privada correspondiente${\displaystyle (w,x,y,z_{1},z_{2})}$, cadena de bytes${\displaystyle \psi \in B^{\ast }}$Salida : Mensaje descifrado${\displaystyle M\in B^{\ast }\cup {Reject}}$.

1. Descifra el texto cifrado:
   1. Si${\displaystyle L(\psi )<3L_{B}(P)+16}$, luego regresar${\displaystyle Reject}$.
   2. Calcular:
      ${\displaystyle (s,u_{1},u_{2},v,e)\leftarrow CDecode(L_{B}(P),\psi )\in W^{4}\times Z\times Z\times Z\times B^{\ast }}$;
      tenga en cuenta que${\displaystyle 0\leq u_{1},u_{2},v<256^{l}}$, dónde${\displaystyle l=L_{B}(P)}$.
2. Verifique el preámbulo del texto cifrado:
   1. Si${\displaystyle u_{1}\geq P}$o${\displaystyle u_{2}\geq P}$o${\displaystyle v\geq P}$, luego regresar${\displaystyle Reject}$.
   2. Si${\displaystyle u_{1}^{q}\neq 1remP}$, luego regresar${\displaystyle Reject}$.
   3. ${\displaystyle reject\leftarrow 0}$.
   4. Si${\displaystyle u_{2}\neq u_{1}^{w}remP}$, entonces${\displaystyle reject\leftarrow 1}$.
   5. Calcular${\displaystyle \alpha \leftarrow UOWHash^{\prime }(k_{1},L_{B}(P),s,u_{1},u_{2})\in Z}$; tenga en cuenta que${\displaystyle 0\leq \alpha \leq 2^{160}}$.
   6. Si${\displaystyle v\neq u_{1}^{x+{\alpha }y}remP}$, entonces${\displaystyle reject\leftarrow 1}$.
   7. Si${\displaystyle reject=1}$, luego regresar${\displaystyle Reject}$.
3. Calcula la clave para la operación de descifrado simétrico:
   1. ${\displaystyle {\tilde {h_{1}}}\leftarrow u_{1}^{z_{1}}remP}$,${\displaystyle {\tilde {h_{2}}}\leftarrow u_{1}^{z_{2}}remP}$.
   2. Calcular${\displaystyle k\leftarrow ESHash(k_{2},L_{B}(P),s,u_{1},{\tilde {h_{1}}},{\tilde {h_{2}}})\in W^{8}}$.
4. Calcular${\displaystyle M\leftarrow SDec(k,s,1024,e)}$;tenga en cuenta que${\displaystyle SDec}$puede regresar${\displaystyle Reject}$.
5. Devolver${\displaystyle M}$.

Algoritmo. Operación de descifrado.${\displaystyle SDec}$. Aporte:${\displaystyle (k,s,m,e)\in W^{8}\times W^{4}\times Z\times B^{\ast }}$${\displaystyle m>0}$ Salida: Mensaje descifrado${\displaystyle M\in B^{\ast }\cup {Reject}}$.

1. Si${\displaystyle e=\lambda _{B}}$, luego regresar${\displaystyle \lambda _{B}}$.
2. Inicializar un estado de generador pseudoaleatorio:
   ${\displaystyle genState\leftarrow InitGen(k,s)\in GenState}$
3. Generar la clave${\displaystyle k_{AXU}AXUHash}$:
   ${\displaystyle (k_{AXU},genState^{\prime })\leftarrow GenWords((5L_{b}(\left\lceil m/64\right\rceil )+24),genState).}$.
4. ${\displaystyle M\leftarrow \lambda _{B},i\leftarrow 0}$.
5. Mientras${\displaystyle i<L(e)}$, haga lo siguiente:
   1. ${\displaystyle r\leftarrow min(L(e)-i,m+16)-16}$.
   2. Si${\displaystyle r\leq 0}$, luego regresar${\displaystyle Reject}$.
   3. Generar valores de máscara para el cifrado y el MAC:
      1. ${\displaystyle (mask_{m},genState)\leftarrow GenWords(4,genState)}$.
      2. ${\displaystyle (mask_{e},genState)\leftarrow GenWords(r,genState)}$.
   4. Verifique el código de autenticación del mensaje:
      1. Si${\displaystyle i+r+16=L(M)}$, entonces${\displaystyle lastblock\leftarrow 1}$; demás${\displaystyle lastblock\leftarrow 0}$.
      2. ${\displaystyle mac\leftarrow AXUHash(k_{AXU},lastBlock,{\Bigl [}e{\Bigr ]}_{i}^{i+r})\in W^{4}}$.
      3. Si${\displaystyle {\Bigl [}e{\Big ]}r_{i+r}^{i+r+16}\neq I_{W^{\ast }}^{B^{\ast }}(mac\oplus mask_{m})}$, luego regresar${\displaystyle Reject}$.
   5. Actualizar el texto plano:${\displaystyle M\leftarrow M||({\Bigl [}e{\Bigr ]}_{i}^{i+r})\oplus mask_{e})}$.
   6. ${\displaystyle i\leftarrow i+r+16}$.
6. Devolver${\displaystyle M}$.

Algoritmo. Generación de claves para el esquema de firma de clave pública ACE. Entrada: parámetro de tamaño.${\displaystyle m}$, de tal manera que${\displaystyle 1024\leq m\leq 16384}$Salida : par de claves pública/privada.

1. Generar números primos aleatorios${\displaystyle p,q}$, de tal manera que${\displaystyle (p-1)/2}$y${\displaystyle (q-1)/2}$— también es un número primo, y
   ${\displaystyle 2^{m_{1}-1}<p<2^{m_{1}}}$,${\displaystyle 2^{m_{2}-1}<q<2^{m_{2}}}$, y${\displaystyle p\neq q}$, dónde
   ${\displaystyle m_{1}=\left\lfloor m/2\right\rfloor }$y${\displaystyle m_{1}=\left\lceil m/2\right\rceil }$.
2. Colocar${\displaystyle N\leftarrow pq}$.
3. Generar un número primo aleatorio${\displaystyle e'}$, donde${\displaystyle 2^{160}\leq e'\leq 2^{161}}$.
4. Generar aleatorio${\displaystyle h'\in \left\{1,...,N-1\right\}}$, teniendo en cuenta${\displaystyle gcd(h',N)=1}$y${\displaystyle gcd(h'\pm 1,N)=1}$y calcular${\displaystyle h\leftarrow (h')^{-2}remN}$.
5. Generar aleatorio${\displaystyle a\in \left\{0,...,(p-1)(q-1)/4-1\right\}}$y calcular${\displaystyle x\leftarrow h^{a}remN}$.
6. Generar cadenas de bytes aleatorias${\displaystyle k'\in B^{184}}$, y${\displaystyle s\in B^{32}}$.
7. Devuelve el par de clave pública/clave privada.
   ${\displaystyle ((N,h,x,e',k',s),(p,q,a))}$.

La firma en el esquema de firma ACE tiene la forma${\displaystyle (d,w,y,y',{\tilde {k}})}$donde los componentes se definen de la siguiente manera: ${\displaystyle d}$- elemento${\displaystyle B^{64}}$. ${\displaystyle w}$— entero, tal que${\displaystyle 2^{160}\leq w\leq 2^{161}}$. ${\displaystyle y,y'}$— elementos${\displaystyle \left\{1,...,N-1\right\}}$. ${\displaystyle {\tilde {k}}}$- elemento${\displaystyle B^{\ast }}$;tenga en cuenta que${\displaystyle L({\tilde {k}})=64+20L_{B}(\left\lceil (L(M)+8)/64\right\rceil )}$, dónde${\displaystyle M}$— mensaje que se está firmando.

Necesitamos presentar el${\displaystyle SEncode}$función, que asigna una firma a su representación de cadena de bytes, y la función inversa correspondiente.${\displaystyle SDecode}$Para enteros${\displaystyle l>0}$, cadena de bytes${\displaystyle d\in B^{64}}$, números enteros${\displaystyle 0\leq w\leq 256^{21}}$y${\displaystyle 0\leq y,y'<256^{l}}$y cadena de bytes${\displaystyle {\tilde {k}}\in B^{\ast }}$,

${\displaystyle SEncode(l,d,w,y,y',{\tilde {k}}){\stackrel {\mathrm {def} }{=}}d||pad_{21}(I_{Z}^{B^{\ast }}(w))||pad_{l}(I_{Z}^{B^{\ast }}(y))||pad_{l}(I_{Z}^{B^{\ast }}(y'))||{\tilde {k}}\in B^{\ast }}$.

Para entero${\displaystyle l>0}$, cadena de bytes${\displaystyle \sigma \in B^{\ast }}$, dónde${\displaystyle L(\sigma )\geq 2l+53}$,

${\displaystyle CSecode(l,\sigma ){\stackrel {\mathrm {def} }{=}}({\Bigl [}\sigma {\Bigr ]}_{0}^{64},I_{B^{\ast }}^{Z}({\Bigl [}\sigma {\Bigr ]}_{64}^{85}),I_{B^{\ast }}^{Z}({\Bigl [}\sigma {\Bigr ]}_{85}^{85+l}),I_{B^{\ast }}^{Z}({\Bigl [}\sigma {\Bigr ]}_{85+l}^{85+2l}),{\Bigl [}\sigma {\Bigr ]}_{85+2l}^{L(\sigma )})\in B^{64}\times Z\times Z\times Z\times B^{\ast }}$.

Algoritmo. Proceso de generación de firma ACE. Entrada: clave pública${\displaystyle (N,h,x,e',k',s)}$y la clave privada correspondiente${\displaystyle (p,q,a)}$y cadena de bytes${\displaystyle M\in B^{\ast }}$,${\displaystyle 0\leq L(M)\leq 2^{64}}$Salida : cadena de bytes — firma digital${\displaystyle \sigma \in B^{\ast }}$.

1. Realice los siguientes pasos para aplicar el hash a los datos de entrada:
   1. Generar una clave hash${\displaystyle {\tilde {k}}\in B^{20m+64}}$al azar, de tal manera que${\displaystyle m=L_{b}(\left\lceil (L(M)+8)/64\right\rceil )}$.
   2. Calcular${\displaystyle m_{h}\leftarrow I_{W^{\ast }}^{Z}(UOWHash^{\prime \prime }({\tilde {k}},M))}$.
2. Seleccionar${\displaystyle {\tilde {y}}\in \left\{1,...,N-1\right\}}$al azar y calcular${\displaystyle y'\leftarrow {\tilde {y}}^{2}remN}$.
3. Calcular${\displaystyle x'\leftarrow (y')^{r'}h^{m_{h}}remN}$.
4. Genera un número primo aleatorio${\displaystyle e}$,${\displaystyle 2^{160}\leq e\leq 2^{161}}$y su certificado de exactitud${\displaystyle (w,d)}$:${\displaystyle (e,w,d)\leftarrow GenCertPrime(s)}$. Repita este paso hasta${\displaystyle e\neq e'}$.
5. Colocar${\displaystyle r\leftarrow UOWHash^{\prime \prime \prime }(k',L_{B}(N),x',{\tilde {k}})\in Z}$; tenga en cuenta que${\displaystyle 0\leq r<2^{160}}$.
6. Calcular${\displaystyle y\leftarrow h^{b}remN}$, dónde
   ${\displaystyle b\leftarrow e^{-1}(a-r)rem(p'q')}$,
   y dónde${\displaystyle p'=(p-1)/2}$y${\displaystyle q'=(q-1)/2}$.
7. Codifique la firma:
   ${\displaystyle \sigma \leftarrow SEncode(L_{B}(N),d,w,y,y',{\tilde {k}})}$.
8. Devolver${\displaystyle \sigma }$