Skip to content
← Todas las publicaciones
· Delta1 Labs DecompiladorGlass.NET.NETNuGet

Resolver referencias desde un lockfile de NuGet en Glass.NET

Un decompilador solo es tan preciso como las referencias que puede resolver. Apunta Glass.NET a tu packages.lock.json y cargará las versiones exactas fijadas — así los tipos, clases base y sobrecargas se resuelven con lo que realmente se restauró, no con una suposición.

Un decompilador se gana tu confianza referencia a referencia. Abre un ensamblado que se sostiene por sí solo y el C# vuelve limpio. Abre uno real — un servicio que se apoya en una docena de paquetes NuGet — y la calidad de la reconstrucción de pronto depende de algo externo al archivo que abriste: ¿puede el decompilador encontrar los ensamblados referenciados, y las versiones correctas de ellos?

Cuando no puede, los síntomas son conocidos. Un método devuelve JToken pero el decompilador no expande el tipo ni lo sigue hasta su base. Una sobrecarga que se diferencia solo por el tipo de un parámetro de una dependencia se resuelve como // unresolved o como el candidato equivocado. Ir a la definición sobre un símbolo externo no lleva a ningún sitio. Nada de esto es que Glass adivine mal — es Glass siendo honesto sobre que una referencia que no puede cargar es una referencia a través de la que no puede ver.

Glass.NET — el decompilador de .NET gratuito y estrictamente estático — cierra esa brecha leyendo tu packages.lock.json. El lockfile es el único artefacto que dice, de forma autoritativa, qué versiones exactas de paquete restauró tu proyecto. Entrégaselo a Glass y cada referencia externa se resuelve al ensamblado que realmente se distribuyó, no a una aproximación.

Por qué un nombre no basta

Un ensamblado compilado no incrusta sus dependencias. Incrusta referencias a ellas. Dos tablas de metadatos cargan toda la historia:

  • AssemblyRef — una fila por ensamblado referenciado: su nombre, versión, cultura y token de clave pública.
  • TypeRef — una fila por cada tipo externo que el código toca: el nombre y espacio de nombres del tipo, y un puntero de vuelta a la fila de AssemblyRef que lo posee.

Eso basta para nombrar un tipo en un punto de llamada. No basta para entenderlo. La clase base, la lista de interfaces, los miembros, los valores constantes, los reenvíos de tipo — todo eso vive en los propios metadatos TypeDef del ensamblado referenciado, que el ensamblado que referencia nunca copia. Así que un decompilador con solo el TypeRef puede imprimir Newtonsoft.Json.Linq.JObject pero no puede saber que JObject : JContainer : JToken, no puede listar sus miembros y no puede resolver qué conversión op_Explicit seleccionó un cast. Para ver a través de la referencia tiene que cargar el ensamblado real.

Considera este método diminuto, compilado contra Newtonsoft.Json:

using Newtonsoft.Json.Linq;

public static class Config
{
    public static string? ReadName(string json)
    {
        JObject root = JObject.Parse(json);
        return (string?)root["name"];
    }
}

Su IL es inequívoco sobre qué llama — cada miembro externo es un token totalmente cualificado:

.method public hidebysig static string ReadName(string json) cil managed
{
  .maxstack  2
  .locals init (class [Newtonsoft.Json]Newtonsoft.Json.Linq.JObject V_0)
  ldarg.0
  call       class [Newtonsoft.Json]Newtonsoft.Json.Linq.JObject
             [Newtonsoft.Json]Newtonsoft.Json.Linq.JObject::Parse(string)
  stloc.0
  ldloc.0
  ldstr      "name"
  callvirt   instance class [Newtonsoft.Json]Newtonsoft.Json.Linq.JToken
             [Newtonsoft.Json]Newtonsoft.Json.Linq.JToken::get_Item(object)
  call       string [Newtonsoft.Json]Newtonsoft.Json.Linq.JToken::
             op_Explicit(class [Newtonsoft.Json]Newtonsoft.Json.Linq.JToken)
  ret
}

Lee los tokens y fíjate en lo que ya está en tu ensamblado y lo que no. El prefijo [Newtonsoft.Json] es un AssemblyRef. get_Item está declarado en JToken, pero se llama a través de JObject — el IL solo funciona porque JObject lo hereda, y esa herencia está registrada en Newtonsoft.Json, no aquí. El op_Explicit final es una de varias conversiones explícitas de JToken; la firma del token nombra la que devuelve string, pero para presentarlo como un cast (string?) limpio y para dejarte entrar en él, Glass necesita la definición del tipo. Sin el ensamblado, Glass muestra la forma que puede probar a partir de los tokens y marca el resto como externo. Con él, el cast, la herencia y la lista de miembros se completan.

La trampa de la versión: lo que dice el AssemblyRef frente a lo que se restauró

Podrías pensar que la versión del AssemblyRef resuelve el problema de “cuál”. Normalmente no. Las bibliotecas .NET mantienen deliberadamente estable su versión de ensamblado entre versiones de parche — Newtonsoft.Json ha arrastrado la versión de ensamblado 13.0.0.0 a lo largo de muchas versiones 13.0.x de NuGet — así que el número grabado en tu AssemblyRef no es la versión de paquete que se restauró. Añade una referencia flotante como <PackageReference Include="Newtonsoft.Json" Version="13.*" /> y la brecha se amplía: el proyecto compiló contra la 13.0.x que fuera la actual, el AssemblyRef sigue diciendo 13.0.0.0, y un sondeo que solo busca “un Newtonsoft.Json llamado 13.0.0.0” en tu caché podría enlazar cualquiera de varias carpetas.

packages.lock.json es el artefacto que elimina la ambigüedad. Cuando RestorePackagesWithLockFile está activado, NuGet escribe la versión resuelta exacta y un hash de contenido para cada paquete — directo y transitivo:

{
  "version": 1,
  "dependencies": {
    "net8.0": {
      "Newtonsoft.Json": {
        "type": "Direct",
        "requested": "[13.*, )",
        "resolved": "13.0.3",
        "contentHash": "HrC5BXdl00IP9zeV+0Z848QWPAoCr9P3bDEZguI+gkLcBKAOxix/tLEAAHC+UvDNPv4a2d18lAReUcg2cFTjaQ=="
      }
    }
  }
}

"resolved": "13.0.3" es el hecho que Glass quiere. Se mapea directamente a ~/.nuget/packages/newtonsoft.json/13.0.3/ en tu caché local, así que Glass carga ese ensamblado — el que tu compilación realmente usó — y no un vecino cercano.

AssemblyRefNewtonsoft.Json 13.0.0.0caché: 13.0.1caché: 13.0.2caché: 13.0.3caché: 13.0.3-beta¿cuál?packages.lock.jsonresolved: 13.0.3coincidencia exacta

Apunta Glass al lockfile

Desde la CLI

El comando decompile de Glass toma un lockfile y resuelve cada referencia desde él antes de reconstruir una sola línea:

glass decompile ./bin/Release/net8.0/Billing.dll \
      --lockfile ./packages.lock.json \
      --out ./recovered

Glass lee el lockfile, recorre cada entrada resolved hasta la carpeta ~/.nuget/packages/<id>/<version>/lib/<tfm>/ coincidente y carga esos ensamblados como el conjunto de referencias. Si un paquete arrastra sus propias dependencias transitivas fijadas por el lockfile, también están en el archivo, así que el cierre se resuelve en una sola pasada — sin restauración de red, sin ejecución. Cualquier cosa que el lockfile no pueda cubrir (una referencia de framework, una salida de proyecto local junto a la DLL) todavía se resuelve mediante el sondeo normal de Glass: el directorio de la aplicación, y luego los paquetes de referencia del framework compartido para el TFM objetivo.

Puedes confirmar lo que se resolvió antes de confiar en la salida. glass sbom lee las mismas entradas e imprime el conjunto de referencias fusionado con las versiones exactas que Glass enlazó, así que puedes comparar “lo que decía el lockfile” con “lo que Glass cargó” y detectar un hueco — un paquete ausente de la caché, por ejemplo — en lugar de descubrirlo como un tipo sin resolver tres archivos más adentro.

En la interfaz

Abre Billing.dll de la manera habitual — arrástralo sobre la ventana, o File ▸ Open Assembly. Cuando un packages.lock.json está junto al binario en el árbol del proyecto, Glass lo nota y ofrece Resolve references from lockfile en el menú contextual del ensamblado (y en la franja de notificación). Acéptalo y el nodo references se repuebla: las entradas que estaban en cursiva-y-sin-resolver pasan a sólidas, cada una etiquetada con la versión exacta del lockfile. Ahora el beneficio aparece en todas partes donde la interfaz toca un tipo externo:

  • Go to Definition (F12) sobre JObject abre el tipo real de 13.0.3, con su cadena de bases y sus miembros, en lugar de detenerse en un stub externo.
  • El C# decompilado de ReadName presenta un (string?)root["name"] limpio porque el indexador y la conversión explícita se resolvieron contra el tipo cargado.
  • Find All References y la jerarquía de llamadas pueden seguir llamadas a través del límite hacia la dependencia, así que “¿dónde se valida realmente este valor?” son unos pocos clics en lugar de una conjetura.

Si alguna vez necesitas saber si un detalle concreto vino del ensamblado real o de que Glass infiriera la forma solo a partir de los tokens, baja el miembro a la vista IL. Los tokens ahí son la verdad base sobre la que se construye la resolución, y se leen igual se haya cargado o no la referencia — que es exactamente por lo que son aquello a lo que recurrir.

Cuándo el lockfile se gana su sitio

  • Auditar una DLL de terceros distribuida. Tienes el .dll del proveedor y, junto a él, el packages.lock.json de su compilación. Resolver contra el lockfile te da su grafo de dependencias exacto, así que tu lectura de su código coincide con los ensamblados que realmente enlazaron — sin deriva por lo que casualmente haya en tu caché.
  • Recuperar una biblioteca cuyo código fuente se perdió. Cuando exportas un ensamblado decompilado a un proyecto compilable, las referencias precisas son lo que hace que el resultado realmente compile. Resolver primero desde el lockfile significa que el proyecto recuperado apunta a las mismas versiones de paquete que el original.
  • Reproducir un bug específico de una versión. Un defecto que solo aparece con un parche de una dependencia es invisible si tu decompilador enlazó un parche distinto. Fijar a la versión resolved del lockfile hace que el código que lees sea el código que falló.

El hilo conductor es el mismo que recorre cada flujo de trabajo de Glass: lee, nunca ejecuta. Resolver referencias desde un lockfile sigue siendo análisis estático puro — Glass lee el lockfile, lee los metadatos del paquete en caché y reconstruye C#. Nada se restaura desde la red, nada se ejecuta. Solo obtienes una decompilación honesta sobre lo único que un .dll solitario nunca puede decirte por sí mismo: contra cuál dependencia se compiló realmente.

Glass.NET es gratuito — sin licencia, sin asientos, sin registro. Apúntalo a tus propios binarios, a dependencias que tienes derecho a inspeccionar, o a código del que estás aprendiendo el compilador, y deja que el lockfile haga exactas las referencias.

Prueba Nebula.NET

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