¿Por qué mis dos claves públicas ssh tienen el mismo comienzo?

Estaba actualizando el archivo autorizado_claves en mi servidor con la clave pública para la nueva computadora portátil que obtuve y me sorprendió descubrir que las dos claves públicas comenzaron de la misma manera:

# key 1
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQ....
#
# key 2
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQ....

¿De qué trata la historia, AAAAB3...etc.? Con algunas búsquedas en línea, veo que otras teclas también comienzan igual. ¿Explica el algoritmo o la versión o algo así?

Este es en realidad un encabezado que define qué tipo de clave es esta. Si revisa la sección Algoritmo de clave pública de RFC 4253 , podemos ver eso para las claves RSA

El formato de clave "ssh-rsa" tiene la siguiente codificación específica:

 string    "ssh-rsa"
 mpint     e
 mpint     n

Aquí los parámetros 'e' y 'n' forman el blob clave de firma.

De hecho, si Base64 decodifica la cadena "B3NzaC1yc2E", verá que se traduce a ASCII como "ssh-rsa". Presumiblemente, el "AAAA" representa algún tipo de encabezado para que la aplicación pueda saber dónde exactamente en el flujo de datos comenzar a procesar la clave.

El formato de clave pública SSH está documentado en RFC 4253 , y se resume un poco aquí . Los datos codificados por PEM consisten en varios pares (longitud, datos), y el primer par codifica el nombre del algoritmo, que será algo así como ssh-rsao ssh-dsa.

Esto significa que la parte inicial de los datos de clave pública para todas las claves ssh será similar.

Hice una exageración profunda en el formato después de seguir los enlaces de Scott para divertirse. TLDR:

ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQ...
       |  "ssh-rsa"   |exponent|   modulus

RFC4231 especifica los dos tipos de datos utilizados:

• string: Cadena binaria de longitud arbitraria. Las cadenas pueden contener datos binarios arbitrarios, incluidos caracteres nulos y caracteres de 8 bits. Se almacenan como un uint32contenido de su longitud

• mpint: Representa múltiples enteros de precisión en formato de complemento a dos, almacenados como una cadena, 8 bits por byte, MSB primero. [...]

RFC4253 sec 6.6 dice que la clave está codificada como:

El formato de clave "ssh-rsa" tiene la siguiente codificación específica:

string    "ssh-rsa"
mpint     e
mpint     n

Aquí los parámetros 'e' y 'n' forman el blob clave de firma. [Ed: pero el blob también parece contener la cadena "ssh-rsa"también ...]

La firma resultante se codifica de la siguiente manera:

string    "ssh-rsa"
string    rsa_signature_blob

El valor de 'rsa_signature_blob' está codificado como una cadena que contiene s [Ed: no sé qué es s.] (Que es un número entero, sin longitudes ni relleno, sin signo y en orden de bytes de red).

"ssh-rsa"

La cadena ssh-rsase convierte en \x00\x00\x00\x07ssh-rsa, que luego se codifica AAAAB3NzaC1yc2E=, por lo que todas las claves ssh-rsa deberían comenzar con eso.

e, el exponente público

Por lo general, algo así como 3, 17, 257, 65537. Esos números se codifican de la siguiente manera (con el desplazamiento final desde arriba)

• 3 → '\x00\x00\x00\x01\x03'→AAAABAw
• 17 → '\x00\x00\x00\x01\x11'→AAAABEQ
• 257 → '\x00\x00\x00\x02\x01\x01'→AAAACAQE
• 65537 / 0x10001 → '\x00\x00\x00\x03\x01\x00\x01'→AAAADAQAB

Entonces, si ve "BAw", su exponente fue 3, o "DAQAB" = 65537

n, el módulo (producto de tus dos números primos secretos, ¡factoriza esto!)

AAABAQdespués de lo anterior significa que la longitud de su clave es de 2048 bits (y que su exponente era como DAQAB debido al relleno base64). El resto del material base64 es el exponente, no hay nada después.

Otros prefijos de módulo que pueden ser comunes:

• AAAAg 1024 bits, e = 0x10001
• AAAQI: 2048 bits, e = 3