Skip to content
← Todas las publicaciones
· Delta1 Labs Strong NamingGlass

Qué demuestra realmente una firma de nombre seguro

Un PublicKeyToken en una referencia de ensamblado parece un sello contra manipulaciones y un timbre del editor, pero no es ninguna de las dos cosas. Esto es exactamente lo que Glass.NET lee de la tabla Assembly y del heap #Blob para mostrarte la clave pública, derivar el token de 8 bytes y distinguir un ensamblado totalmente firmado de uno con firma diferida, y por qué, en el .NET moderno, la firma nunca se comprueba en la carga.

Abres un ensamblado en Glass.NET y la línea de identidad dice MyLib, Version=1.0.0.0, Culture=neutral, PublicKeyToken=a5b2c8d4e6f70819. Es fácil leer ese token como dos garantías a la vez: que los bytes no se han alterado desde que el editor los compiló, y que el editor es quien dice ser. Un nombre seguro no es ninguna de esas cosas. Es una etiqueta de identidad con forma criptográfica, y entender qué afirma exactamente —y qué no— es un breve recorrido por la tabla Assembly, el heap #Blob y un único hash SHA-1.

La verdadera pregunta

Detrás de ese único token se esconden dos hechos distintos. El primero es la derivación: ¿de dónde salen esos ocho bytes y de qué son una huella? El segundo es la aplicación: cuando el runtime carga este ensamblado, ¿algo comprueba realmente una firma contra esos bytes? La mayor parte de la confusión sobre los nombres seguros viene de suponer que la respuesta a la segunda pregunta es «sí, siempre». En el .NET moderno es «no, nunca». Glass responde a ambas preguntas solo con los metadatos, y tiene cuidado de no exagerar la segunda.

De dónde viene el token

Un ensamblado con nombre seguro almacena su clave pública completa en el manifiesto. En sintaxis estilo ILDASM, el ensamblado que la define se ve así:

.assembly MyLib
{
  .publickey = (00 24 00 00 04 80 00 00 94 00 00 00 06 02 00 00
                00 24 00 00 52 53 41 31 00 04 00 00 01 00 01 00 ... )
  .hash algorithm 0x00008004
  .ver 1:0:0:0
}

Ese blob .publickey es la clave real: una estructura de clave pública SNK que empieza con una cabecera y la etiqueta ASCII RSA1. Vive en el heap #Blob y la apunta la columna PublicKey de la tabla Assembly de una sola fila. Un ensamblado que referencia a MyLib no repite la clave entera; almacena solo el token de 8 bytes:

.assembly extern MyLib
{
  .publickeytoken = (A5 B2 C8 D4 E6 F7 08 19)
  .ver 1:0:0:0
}

El token es un hash de la clave, calculado igual en todas partes:

using System.Security.Cryptography;

static string PublicKeyToken(byte[] fullPublicKey)
{
    byte[] hash  = SHA1.HashData(fullPublicKey); // 20 bytes
    byte[] token = hash[^8..];                   // last 8 bytes
    Array.Reverse(token);                        // stored little-endian, shown reversed
    return Convert.ToHexString(token).ToLowerInvariant();
}

Toma el SHA-1 de todo el blob de la clave pública, conserva los últimos ocho bytes, invíertelos e imprímelos en hexadecimal. Ese es el algoritmo entero. Significa que el token es una huella truncada: fija un ensamblado a una clave pública de forma compacta, para que una referencia pueda nombrar la clave exacta con la que debió compilarse una dependencia sin cargar con 160 bytes de módulo RSA. Cuando el runtime enlaza MyLib, recalcula el token de la clave pública del candidato y lo compara con el de la referencia. Esa comparación es correspondencia de identidad, nada más.

Identidad: de dónde viene el tokenblob .publickeyclave RSA1 completa, heap #BlobSHA-1hash de 20 bytesúltimos 8 bytes, invertidosPublicKeyToken=a5b2c8d4e6f70819El enlace compara tokens → misma clave del editor. Solo identidad.Integridad: ¿se comprueba alguna vez la firma?StrongNameSignaturefirma RSA sobre el hash de la imagen.NET Frameworkverificada en la carga(plena confianza puede omitir).NET 5+ / .NET CoreNO verificada en la cargasolo enlace de identidadNO demuestraautenticidad del editor(sin CA; clave autogenerada)integridad en el .NET moderno
El token es una huella SHA-1 de la clave pública usada para el enlace de identidad; la firma, aparte, solo se verifica en .NET Framework, así que un nombre seguro no demuestra ni autenticidad ni, en el .NET moderno, integridad.

Qué lee Glass y qué se niega a afirmar

Cuando cargas un ensamblado, Glass lee la fila de la tabla Assembly, extrae el blob PublicKey de #Blob y ejecuta exactamente el hash de arriba para mostrarte el token en la línea de identidad: no confía en el token que una referencia afirma, lo deriva de la clave que está realmente presente. Expande el nodo Assembly y ahí está la clave pública completa en la vista de metadatos, etiquetada RSA1, con el valor AssemblyFlags al lado para que veas el bit PublicKey (0x0001) que marca el blob como una clave real y no como un token.

La parte sobre la que Glass calla deliberadamente es la verificación. Hay un segundo artefacto en el PE que la gente confunde con la clave: la firma de nombre seguro, una firma RSA sobre un hash de la imagen, almacenada en una región reservada a la que apunta el directorio de datos StrongNameSignature de la cabecera CLI. Glass te mostrará que la región existe y cuánto mide. No te dirá que la firma es «válida» como si eso fuera un veredicto de confianza, porque en el runtime que a la mayoría de los lectores les importa, esa pregunta nunca se plantea.

Lo que un nombre seguro no demuestra

Dos lagunas independientes, y Glass expone la evidencia de ambas.

No demuestra quién es el editor. Una clave de nombre seguro es autogenerada —sn -k produce una en un segundo—, sin autoridad de certificación, sin identidad y sin revocación. Cualquiera puede acuñar una clave y ponerle un nombre seguro a un ensamblado con ella. El token te dice que dos ensamblados se firmaron con la misma clave; no te dice nada sobre de quién es esa clave. (Authenticode, que vincula una firma a un certificado X.509 emitido a una organización con nombre, es el artefacto que porta la identidad del editor: una firma aparte que Glass informa por separado.)

En el .NET moderno, no demuestra integridad. .NET Framework verificaba la firma de nombre seguro al cargar un ensamblado desde fuera del GAC, aunque un host de plena confianza podía desactivar incluso eso mediante la omisión de nombre seguro. .NET Core y .NET 5+ eliminaron por completo la verificación en la carga: el nombre seguro se usa solo para calcular la identidad y enlazar referencias. Un atacante que quite la firma, edite el IL y deje la clave pública en su sitio produce un ensamblado que se carga igual y sigue informando del token original, porque nada recalcula la firma. Por eso Glass etiqueta el token como identidad y deja la integridad a Authenticode y a tu propio hashing de archivos.

Los ensamblados con firma diferida parecen firmados pero no lo están

Hay un tercer estado que vale la pena reconocer, y es donde empieza la mayor parte de la confusión sobre «¿está firmado esto?». Un ensamblado con firma diferida lleva la clave pública real —así que tiene token e informa de una identidad completa— pero su región de firma está reservada y en ceros, para que la rellene más tarde quien posea la clave privada:

# Developer builds with the public key only; signature space is reserved
csc /delaysign+ /keyfile:public-only.snk MyLib.cs
# Later, the release gatekeeper completes it with the private key
sn -R MyLib.dll full-keypair.snk

Glass lee el directorio StrongNameSignature, ve una clave pública no vacía junto a un blob de firma todo en ceros e informa del ensamblado como de firma diferida en lugar de firmado. Esa distinción importa: un ensamblado con firma diferida en .NET Framework fallaría la verificación (o necesitaría un registro de omisión de verificación), mientras que en el .NET moderno se carga sin problemas precisamente porque nada comprueba, una demostración vívida de que «tiene un token» y «tiene una firma verificada» son hechos sin relación.

Advertencias

La derivación del token está fijada en SHA-1 sin importar con qué firmaste; una clave RSA de 2048 bits y las claves más nuevas de estilo ECMA se reducen ambas a un token SHA-1 de 8 bytes, así que la resistencia a colisiones del token no es la de la clave. Glass calcula y compara tokens, no intenta verificar criptográficamente el blob de la firma, porque un resultado de «firma válida» implicaría una garantía en la carga que los runtimes modernos no ofrecen y sería engañoso imprimirlo. Y una coincidencia de token durante el enlace solo se aplica cuando la referencia realmente registró un token: una referencia compilada contra un MyLib sin firmar registra un PublicKeyToken vacío, y Glass muestra esa identidad vacía en lugar de inventar una.

Conclusión

Un token de clave pública de nombre seguro es una huella SHA-1 de una clave pública autogenerada, almacenada entera en el ensamblado que la posee y como ocho bytes en todo lo que la referencia. Vincula referencias a una clave, lo cual es una garantía de identidad real y útil. No es un certificado de editor y, en .NET Core y .NET 5+, no es un sello contra manipulaciones: la firma que implica nunca se comprueba en la carga. Glass.NET lee la clave, deriva el token con honestidad, distingue firmado de firma diferida y se detiene justo donde terminan las garantías de los metadatos, para que leas la identidad por lo que es y recurras a Authenticode y a tu propio hashing para la integridad que nunca estuvo pensada para portar.

Prueba Nebula.NET

Endurece tu código .NET en minutos — empieza con la edición gratuita.