Skip to content

Blog

Novedades y notas de ingeniería

Anuncios de versiones, análisis a fondo de cómo funcionan nuestras herramientas y guías prácticas.

Interop

Cómo se descompila el P/Invoke generado por fuente

Los métodos [DllImport] clásicos no tienen cuerpo gestionado, así que un descompilador los reconstruye desde la tabla ImplMap. Un método [LibraryImport] es lo contrario: el stub de marshalling es C# compilado real, y Glass lo muestra entero.

Leer artículo →
Interop

Cómo se descompila el P/Invoke generado por fuente

Los métodos [DllImport] clásicos no tienen cuerpo gestionado, así que un descompilador los reconstruye desde la tabla ImplMap. Un método [LibraryImport] es lo contrario: el stub de marshalling es C# compilado real, y Glass lo muestra entero.

Leer →
Reflection

Por qué un nombre de tipo almacenado se rompe al renombrar

Una aplicación de plugins que resuelve "Acme.Exporters.PdfExporter, Acme.Exporters" con Type.GetType y Activator.CreateInstance funciona en depuración y falla en producción en cuanto la ofuscas. La causa es un desajuste entre un token de metadatos y una simple cadena, y la solución es un registro resistente al renombrado que no conserva ningún nombre.

Leer →
Time Zones

Mostrar la caducidad de la licencia en la zona horaria correcta

Una licencia caduca en un único instante de la línea temporal, pero "30 de noviembre" es una fecha civil que depende de dónde estés. Confunde ambas cosas y un cliente en Auckland verá "caducada" en una clave que un cliente en Los Ángeles aún muestra como válida. Este artículo construye la visualización correcta de la caducidad en .NET: almacena la caducidad como un instante en UTC, proyéctalo en la zona horaria del propio espectador con DateTimeOffset y TimeZoneInfo, etiqueta la zona y calcula los "días restantes" de modo que los cambios de horario de verano nunca hagan que un día dure 23 o 25 horas.

Leer →
NativeAOT

Lo que un descompilador ve en un binario NativeAOT

Dale a Glass una biblioteca publicada con NativeAOT y no obtienes nada: ni C#, ni IL, ni siquiera una lista de métodos. Esta es la razón a nivel de PE, qué metadatos sobreviven dentro de la imagen nativa y por qué NativeAOT no es el ofuscador que la gente supone.

Leer →
Anti-dump

Impedir que un volcado de memoria recupere tu ensamblado

El renombrado y el cifrado de cadenas se deshacen si un atacante simplemente vuelca tu proceso en ejecución a disco. Cómo el anti-dump de Nebula.NET reubica y borra los encabezados PE y de metadatos en memoria para que una imagen extraída sea inservible: con los offsets reales, C#, un SVG de la ruta de extracción y los límites honestos.

Leer →
Blazor Server

Licenciar una app Blazor Server por circuito

En Blazor Server un ámbito de DI vive durante todo el circuito SignalR, no por solicitud, así que una licencia que validas cuando una pestaña se conecta sigue siendo la respuesta tres días después, mucho después de que la lease caducara. Aquí verás cómo acotar las entitlements de Keyright al circuito, mantenerlas al día durante toda su vida y mostrar una interfaz en modo degradado cuando cambian.

Leer →
Generics

Cómo lee Glass las instanciaciones de métodos genéricos

Una llamada a un método genérico se compila en un token MethodSpec con un blob de argumentos de tipo aparte. Así es como Glass.NET lee ese blob, sustituye los marcadores !!0 y decide cuándo el C# recuperado necesita realmente argumentos de tipo explícitos.

Leer →
Control flow

Cómo los manejadores de excepciones ocultan el flujo

Un decompilador reconstruye tu if/else a partir de las instrucciones de salto que encuentra en el IL. Encaminar una decisión a través de un centinela lanzado y capturado traslada esa arista a la tabla de cláusulas de manejo de excepciones, donde la decompilación estructurada se rompe. Aquí tienes el IL real, por qué derrota a una lectura estática y el coste en tiempo de ejecución que obliga a usarlo con moderación.

Leer →
Webhooks

Verificar webhooks de facturación entrantes en .NET

Tu servidor de licencias confía en un POST de tu proveedor de pagos, hasta que un atacante envía el suyo. Cómo verificar correctamente webhooks entrantes firmados con HMAC: firma sobre los bytes crudos, comparación en tiempo constante, tolerancia de marca de tiempo y defensa contra repetición, y luego reconciliar un reembolso con la revocación de la licencia.

Leer →
Licensing

Licencia todas las versiones desde un solo par de claves

Rotar las claves de firma en cada versión mayor es la trampa: rompe las compilaciones antiguas, obliga a una migración masiva y no te da ningún control por cliente. El modelo mejor mantiene un solo par de claves durante toda la vida del producto y lleva lo que una licencia puede hacer —qué versiones ejecuta, qué funciones desbloquea, cuánto puede usar— en derechos firmados. Este artículo muestra los tres patrones con código real, cómo las concesiones permanecen a prueba de manipulaciones con y sin conexión, y cuándo recurrir a la cobertura de versiones completa.

Leer →
Decompilation

Cómo un decompilador lee los valores de atributos personalizados

La aplicación de un atributo no se almacena como código fuente. Es un blob binario en el heap #Blob: un prólogo, los argumentos posicionales serializados según la firma del constructor y luego una lista contada de valores de campos y propiedades con nombre. Aquí está la disposición exacta de los bytes y cómo Glass.NET la reconstruye como un atributo de C#.

Leer →
Decompilation

Cómo se decompila la aritmética checked en C#

Una palabra clave checked o unchecked nunca sobrevive en los metadatos. La comprobación de desbordamiento se codifica por instrucción como add.ovf, mul.ovf y conv.ovf.u1: aquí está el IL, las asimetrías y cómo Glass.NET reconstruye la región checked mínima que lo explica.

Leer →
Decompilation

Cómo se decompilan los literales de cadena raw en C#

Un literal de cadena sin formato, una cadena textual y una cadena normal compilan todos al mismo ldstr idéntico hacia el heap #US. Aquí está el IL, los bytes de cadena de usuario que hay detrás y cómo Glass.NET elige qué forma de comillas reconstruir.

Leer →
Decompilation

Cómo Glass reconstruye las expresiones with de records

Una expresión `with` no deja ninguna palabra clave en el IL: es una llamada virtual a un método oculto `<Clone>$` seguida de una serie de setters init-only. Glass.NET vuelve a leer esa forma exacta como `record with { … }`. Aquí está el viaje completo source → IL → C# reconstruido para la mutación no destructiva.

Leer →
Decompilation

Recuperar el diseñador de recursos con tipado fuerte con Glass.NET

Un `Resources.Designer.cs` es pegamento generado por máquina: un `ResourceManager` perezoso, un campo de cultura y una propiedad tipada por cada clave del `.resx` que solo llama a `GetString`. Nada de esa magia de palabras clave sobrevive a la compilación: es IL puro. Glass.NET lee la huella de atributos y la forma de `GetString` para devolverte la clase de diseñador familiar. Aquí está el recorrido completo de ida y vuelta de código fuente → IL → C# reconstruido.

Leer →
Observability

Instrumentar la verificación de licencias con OpenTelemetry

Instrumentas cada llamada a la base de datos y cada petición HTTP saliente de tu aplicación, pero la única dependencia que decide si el software puede ejecutarse —la comprobación de licencia— suele ser invisible hasta que un cliente abre un ticket. Esta guía conecta una verificación de Keyright con OpenTelemetry igual que cualquier dependencia crítica: un Meter con un contador de verificaciones, un histograma de duración y un medidor de caducidad; un span de ActivitySource alrededor del refresco que registra si la respuesta llegó en línea, desde la caché o desde la ventana de gracia; las etiquetas de baja cardinalidad que hacen un panel y las de alta cardinalidad (la clave, el titular, el id de máquina) que nunca deben ser valores de etiqueta; y el cableado OTLP y las cuatro alertas que merecen una llamada.

Leer →
Licensing

Acotar una licencia Keyright a un entorno

El mismo archivo de licencia tiende a fluir desde producción hacia staging, al portátil de un desarrollador y a través de CI, hasta que nadie sabe de qué entorno vino una validación y una clave de staging filtrada desbloquea producción sin que nadie lo note. Esta es una guía de migración: compara las tres formas en que los equipos separan los entornos —un producto por entorno, un archivo simple por entorno y un único producto con una entitlement env firmada— y después migra a la última en Keyright sin un día de corte. Cubre dónde aprende la aplicación su propio entorno (IHostEnvironment y el respaldo DOTNET_ENVIRONMENT / ASPNETCORE_ENVIRONMENT), una verificación de veinte líneas que falla en cerrado ante un entorno desconocido, un despliegue retrocompatible donde una clave heredada sin acotar sigue ejecutándose en cualquier sitio, y el límite honesto: el entorno lo declara tu propia configuración, así que esto es higiene y telemetría limpia, no un muro contra un operador que ajuste la variable.

Leer →
Deployment

Sembrar una licencia Keyright desde un instalador WiX/MSI

El software de escritorio empresarial no lo activa la persona que lo ejecuta. Se distribuye de forma silenciosa mediante directivas de grupo, Intune o SCCM con msiexec /qn, hacia máquinas cuyos usuarios nunca ven un cuadro de diálogo y a menudo no pueden alcanzar tu servicio de licencias. Esta guía práctica construye el despliegue que la mayoría de los ISV acaban necesitando: un MSI que coloca una licencia firmada a nivel de máquina bajo ProgramData para que la app ya tenga licencia en el primer arranque, además de la alternativa de pasar una clave de activación como propiedad del MSI y dejar que la app la reclame una vez en línea. Cubre la autoría en WiX v5, dónde debe residir el archivo para que todos los usuarios de Windows del equipo compartan un asiento, la acción personalizada diferida que escribe una clave que la app recogerá, las opciones del SDK que hacen que ProgramData sea autoritativo y las líneas de comando de msiexec que un administrador pega en su herramienta de despliegue.

Leer →
Licensing

Las cadenas de delegación permiten a los revendedores emitir sus propias claves

Firmas un contrato de distribución y la primera pregunta de integración es "¿cómo emiten nuestros distribuidores claves a los clientes finales?". Las dos respuestas obvias son erróneas: entregar a cada distribuidor tu clave raíz de firma y un solo portátil robado falsifica todo tu catálogo, o enrutar cada venta de distribuidor a través de una llamada en vivo a tu servicio de emisión y tus socios no pueden vender cuando tú estás caído. El diseño que aguanta es una cadena de delegación: entrega a cada distribuidor un certificado firmado que lleva su propia clave pública y un alcance que nunca puede exceder, deja que firme licencias de cliente final con la mitad privada, y haz que el cliente verifique toda la cadena sin conexión contra una única clave raíz fijada. Este artículo construye esa cadena en Keyright: el certificado de delegación y su alcance, cómo un distribuidor emite dentro de él, la verificación del SDK que recorre licencia a delegado a raíz, la regla de que el alcance solo puede estrecharse, y por qué revocar un certificado caduca en silencio cada clave que un distribuidor comprometido haya emitido jamás.

Leer →
Audit Log

Crea un registro de auditoría de licencias a prueba de manipulaciones con encadenamiento de hash

Una guía paso a paso para convertir el registro de auditoría de licencias de Keyright en un log encadenado por hash y a prueba de manipulaciones: cómo cada entrada sella a la anterior, cómo leer y verificar la cadena mediante la API de administración y la CLI, cómo anclar el hash de cabecera para que una eliminación no pueda ocultarse, y el C# que necesitas para demostrar el rastro en CI.

Leer →
Metadata

Reducir un ensamblado .NET tras la ofuscación

El renombrado deja cadenas y blobs muertos en los heaps #Strings y #Blob. Cómo Nebula compacta los heaps de metadatos y renumera los tokens, con el diseño real de metadatos, IL, configuración y mediciones antes/después.

Leer →
Obfuscation

Ocultar las operaciones enteras que controlan tu software

El renombrado oculta cómo se llama un valor; la MBA oculta qué calcula. Esta guía a fondo muestra cómo Nebula reescribe a + b como marañas equivalentes de aritmética y operaciones de bits que derrotan el plegado de constantes y la ejecución simbólica, con C# real, IL representativo, las identidades, la configuración y el coste honesto.

Leer →
Obfuscation

Ofuscar una tarea personalizada de MSBuild sin romperla

Una tarea personalizada de MSBuild es la imagen especular de un generador de código fuente. El compilador encuentra un generador por atributo, de modo que puedes renombrar toda la clase libremente; MSBuild encuentra una tarea por la cadena literal del nombre del tipo escrita en un elemento UsingTask, y lee sus parámetros a partir de los nombres de propiedades públicas, por lo que ambos son un contrato externo rígido que el renombrado no debe tocar. Este artículo examina qué refleja realmente el motor de MSBuild cuando ejecuta tu tarea, traza la línea exacta entre la pequeña superficie fijada y la lógica valiosa que se renombra sin problemas, y muestra la configuración de Nebula y la compilación de verificación que detecta el único modo de fallo que es silencioso.

Leer →
ReadyToRun

Acertar el orden de ReadyToRun y la ofuscación

Una compilación ReadyToRun es una imagen doble: tu IL más una copia nativa de él, compilada por crossgen a partir del aspecto que tenía el IL en el momento de la publicación. Ofusca después de crossgen y esa copia nativa es un registro limpio e independiente de cualquier decompilador de tu lógica original; además invalida la imagen R2R, así que el runtime vuelve silenciosamente al JIT. Esto es por qué el orden lo decide todo, y cómo conectar Nebula para que crossgen compile IL protegido.

Leer →
Obfuscation

¿Puede la ofuscación ocultar una cadena de conexión en .NET?

Una cadena de conexión, una clave de API o un secreto de firma que se distribuye dentro de tu aplicación .NET es recuperable en principio: el proceso tiene que usarlo, así que el proceso tiene que retenerlo. Esta es una comparación honesta de los tres lugares donde se esconde un secreto en un ensamblado distribuido, qué cambia exactamente el cifrado de cadenas y de recursos de Nebula.NET en cada uno, dónde está el techo y la estratificación que de verdad mantiene un secreto fuera del alcance de un atacante.

Leer →
Obfuscation

Por qué el anti-ILDASM protege menos de lo que crees

Por qué el atributo [SuppressIldasm] detiene a una sola herramienta — y es ignorado por completo en el .NET moderno — además de lo que hace el endurecimiento real de metadatos y cadenas, con C#, IL y configuración de Nebula.

Leer →
Glass.NET

Cómo se decompila allows ref struct en .NET

La anti-restricción allows ref struct de C# 13 no produce IL en el cuerpo del método. Vive por completo en un bit de GenericParameterAttributes (AllowByRefLike, 0x20) sobre un parámetro genérico — mira cómo lo lee de vuelta Glass.NET.

Leer →
FieldKeyword

Cómo se decompila la palabra clave field de C# 14

La palabra clave field reutiliza el mismo <Name>k__BackingField que emite una propiedad automática, así que los metadatos son idénticos. La decisión de representar field vive por completo en el IL del descriptor de acceso. Así lo lee Glass.NET.

Leer →
FileLocalTypes

Recuperar el modificador file al decompilar

El modificador file de C# 11 no tiene atributo ni marca. El compilador lo codifica mutilando el nombre del tipo en una forma impronunciable <File>F0__Type y emitiendo el tipo como interno de ensamblado. Un decompilador que imprima ese nombre tal cual produce código que no compila. Así es como Glass.NET lee la mutilación de vuelta a file class.

Leer →
OverloadResolution

Qué congela OverloadResolutionPriority en una llamada

El atributo OverloadResolutionPriority dirige la resolución de sobrecargas, pero marca solo la definición del método, nunca la llamada. Así lo lee Glass.NET en ambos lados.

Leer →
UnsafeAccessor

Cómo se decompila UnsafeAccessor en .NET

Un método UnsafeAccessor no tiene ningún cuerpo IL: el miembro privado al que accede vive solo como una cadena en el blob de un atributo personalizado, vinculado por el JIT. Así lo reconstruye Glass.NET.

Leer →
Decompilation

Cómo se decompilan los parámetros ref readonly

ref readonly e in compilan a metadatos de parámetro idénticos byte a byte: el mismo flag [in], el mismo modreq(InAttribute). La única diferencia es un atributo personalizado. Esto es lo que lee Glass.NET.

Leer →
Decompilation

Cómo se decompilan los literales de cadena UTF-8 en C#

Un literal "abc"u8 no es una cadena ni un array de bytes: es un ReadOnlySpan<byte> sobre un campo de datos RVA estático. Aquí está el IL, el terminador nulo oculto y lo que reconstruye Glass.NET.

Leer →
Decompilador

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.

Leer →
Licensing

Aprovisionamiento masivo de licencias con la API de administración de Keyright

Dar de alta un acuerdo empresarial de 2000 puestos con un POST a la vez es lento y te deja adivinando cuando un lote muere a la mitad. Así se aprovisiona en masa y se reejecuta con seguridad.

Leer →
Reliability

Bloqueo optimista para la activación concurrente de licencias

Dos máquinas reclaman el asiento final en el mismo milisegundo. Un ingenuo leer-contar-escribir deja entrar a las dos y sobrevende la licencia. Así es como la concurrencia optimista convierte el reclamo de asiento en un compare-and-swap, y cómo el SDK maneja el 409.

Leer →
Licensing

Controlar funciones en tiempo de compilación con un generador Roslyn

Deja de esparcir comprobaciones de entitlements escritas a mano. Un generador de código Roslyn emite las guardas por ti, valida los nombres de entitlement contra un manifiesto y hace fallar la compilación ante una errata.

Leer →
Caching

Refresco condicional de licencia con ETag

Un cliente de Keyright refresca su lease en caché con un temporizador, y la inmensa mayoría de esos refrescos responden la misma pregunta con la misma respuesta: nada cambió. Volver a descargar el lease firmado completo cada vez desperdicia ancho de banda y repite una verificación de firma sin motivo. HTTP ya tiene la herramienta adecuada para «¿ha cambiado este recurso desde la última vez que lo vi?»: el ETag y el GET condicional. Este artículo muestra cómo el servicio emisor etiqueta cada respuesta de licencia con un validador fuerte, cómo el SDK envía If-None-Match para convertir un refresco en un económico 304 Not Modified, y las reglas de corrección que impiden que un 304 oculte jamás una revocación.

Leer →
Entitlements

Comparar derechos requeridos y concedidos al actualizar

Cuando una versión nueva necesita derechos que la licencia del cliente nunca concedió, un simple "función bloqueada" es un callejón sin salida. Así se comparan requeridos y concedidos para decirle exactamente qué comprar.

Leer →
Licensing

Evitar una estampida de revalidación de licencias con jitter

Cuando miles de clientes comparten un TTL de validación en caché o se reconectan todos tras una caída, sus llamadas de refresco se sincronizan en una avalancha. Así se aplica jitter a la revalidación en segundo plano del SDK para no hacer DDoS a tu propio servicio emisor.

Leer →
Licensing

Asientos por usuario nombrado frente a por dispositivo en Keyright

Un asiento puede significar una máquina o una persona, y cada uno se cuenta distinto. Así se enlazan, se aplican y se reconcilian los asientos por dispositivo y por usuario nombrado en Keyright sin sobrevender ni bloquear a usuarios que pagan.

Leer →
Activation

Activar una app de escritorio escaneando un código QR

Teclear una clave de licencia de 29 caracteres en un kiosco, un TV-box o una estación bloqueada es propenso a errores y hostil. Así se construye un flujo de activación por emparejamiento de dispositivos para una app de escritorio .NET con Keyright: la app muestra un QR, el usuario aprueba en su teléfono y el escritorio sondea una activación firmada que cachea y valida sin conexión.

Leer →
Obfuscation

Cómo los predicados opacos frustran a los desofuscadores automáticos

Por qué los predicados siempre-verdaderos y las ramas basura derrotan a herramientas tipo de4dot — con C# real, IL representativo, el equilibrio rendimiento/tamaño y qué nivel de Nebula lo hace.

Leer →
Obfuscation

El coste en ejecución del cifrado de cadenas en un bucle caliente

Los literales de cadena cifrados se descifran en el punto de uso. En un bucle ajustado eso se acumula. Aquí tienes cómo medir el coste con BenchmarkDotNet y acotar el cifrado de cadenas en nebula.config.json.

Leer →
Obfuscation

Ofuscar un contrato JSON polimórfico de forma segura

La serialización polimórfica pone la identidad del tipo en el cable. TypeNameHandling de Newtonsoft incrusta el nombre del tipo CLR, que la ofuscación renombra, rompiendo cada documento persistido. [JsonDerivedType] de System.Text.Json usa un discriminador de cadena desacoplado del tipo, así que se renombra sin problemas. Aquí está exactamente por qué, y cómo ofuscar la jerarquía de forma segura.

Leer →
Obfuscation

Ofuscar una Minimal API sin romper el enlace de parámetros

Las Minimal API de ASP.NET Core enlazan valores de ruta y de query a los parámetros del handler por su nombre reflejado. Elimina o renombra esos nombres y el enlace falla en silencio: id llega como 0. Esta es la solución.

Leer →
Obfuscation

Ofuscar grains de Orleans sin romper el enrutamiento del clúster

Orleans enruta cada llamada a un grain mediante cadenas del manifiesto del clúster: un GrainInterfaceType y un GrainType derivados por defecto de los nombres de tus tipos .NET. Renombra un grain y la identidad se mueve, dejando huérfano el estado persistido y rompiendo las llamadas entre silos. Así se desacopla la identidad con [Alias]/[GrainType] y aun así se ofusca de forma agresiva.

Leer →
Obfuscation

Ofuscar una aplicación Quartz.NET sin romper el JobStore

Un JobStore persistente de Quartz.NET escribe en la base de datos el nombre cualificado por ensamblado de cada tipo IJob y lo carga de vuelta por reflexión cuando dispara un trigger, a menudo en un despliegue posterior. Renombra ese tipo y el planificador lanza JobPersistenceException. Esta es la keep-list que lo arregla.

Leer →
SemanticKernel

Ofuscar un plugin de Semantic Kernel de forma segura

Un plugin [KernelFunction] es un contrato descubierto por reflexión que se envía al LLM como esquema de herramientas. El nombre de la función, los nombres de los parámetros y las descripciones son portadores; el cuerpo del método es tu PI. Fija los nombres con atributos para que los identificadores se renombren libremente y deja que Nebula blinde la implementación.

Leer →
Decompilation

Reconstruir restricciones genéricas y varianza desde los metadatos

Las restricciones de parámetros de tipo genérico y la varianza son, igual que el diseño de estructuras, rasgos que un descompilador no puede recuperar a partir de la forma del código: viven por completo en los metadatos. Cada parámetro genérico lleva una dirección de varianza y marcas de restricción especial en la tabla GenericParam, y la tabla GenericParamConstraint enumera el tipo base y las interfaces a los que está ligado un parámetro. La covarianza (out) y la contravarianza (in) son bits de marca; las restricciones class / struct / new() también son bits; pero notnull y unmanaged se codifican de forma indirecta, mediante un modreq y un atributo en lugar de una marca cruda. Pierde la varianza y una interfaz deja de ser asignable como lo era; vuelve a emitir las restricciones en el orden equivocado y la salida no compila en absoluto. Este artículo muestra dónde viven los datos, cómo Glass.NET lee las tablas GenericParam y GenericParamConstraint, cómo ordena las restricciones en el orden exacto que exige C#, y un ejemplo trabajado con una interfaz covariante y un método con varias restricciones.

Leer →
Decompilation

Cómo Glass sigue el reenvío de tipos y la tabla ExportedType

Cuando un tipo se traslada de mscorlib a System.Runtime, el ensamblado antiguo conserva un reenviador: una fila ExportedType con el indicador de reenviador que apunta a un nuevo AssemblyRef. Un reenviador no tiene miembros, así que un descompilador no debe representarlo como un tipo: tiene que seguir el reenvío hasta la definición real. Este artículo recorre dónde vive el reenvío en los metadatos, cómo Glass.NET resuelve una cadena de reenvíos, cómo se degrada con elegancia cuando falta el ensamblado destino y cómo vuelve a emitir [assembly: TypeForwardedTo(...)] cuando descompilas la propia fachada.

Leer →
WinForms

Reconstruir el diseñador de WinForms al decompilar

Una app WinForms compilada no tiene .Designer.cs ni .resx: el código del diseñador se fusionó en un único tipo como InitializeComponent(), y los textos e imágenes de la interfaz viven en un stream .resources incrustado. Así reconstruye Glass.NET un InitializeComponent() fiel a partir del binario, muestra los valores del ComponentResourceManager y te deja exportar los recursos incrustados: todo estático, todo gratis.

Leer →
IL

Leer la vista IL y navegar por los tokens de metadatos en Glass

Una explicación a fondo sobre cómo cambiar a la vista IL en Glass, decodificar tokens de metadatos (0x06 MethodDef, 0x0A MemberRef, 0x70 UserString), leer la cabecera del cuerpo de un método y hacer clic en un token para saltar a su definición.

Leer →
PDB

Recuperar nombres de variables y números de línea desde los PDB

Un descompilador reconstruye C# a partir del IL y los metadatos, pero nombres como V_0 y V_1 se han perdido. Así es como Glass lee los PDB portables (incrustados, adyacentes u obtenidos vía Source Link) para restaurar los nombres reales de variables locales y parámetros, anotar el código descompilado con el archivo fuente y la línea originales, y recuperar el código fuente real, y cómo se degrada con elegancia cuando no hay símbolos.

Leer →
Licensing

Aplicar los derechos de licencia en servicios gRPC

Un servicio gRPC no tiene el pipeline de filtros de MVC ni un atributo [Authorize] del que colgar la comprobación de licencia: el único punto que ve todas las llamadas es el Interceptor del servidor. Este artículo escribe un LicensingInterceptor que valida una licencia de Keyright una sola vez, mapea cada método gRPC a un derecho requerido y falla cerrado con el estado correcto: FailedPrecondition cuando no hay licencia válida, PermissionDenied cuando la licencia carece del derecho, ResourceExhausted cuando se agota un límite numérico. Además, una ruta caliente en caché que nunca viaja al servicio emisor, el registro por DI con AddGrpc y las variantes de streaming.

Leer →
Node-locking

Node-locking de activaciones y sobrevivir a la deriva de huella

Una licencia node-locked vincula un asiento a una máquina. El vínculo es una huella de máquina: un hash estable y salteado derivado de señales de hardware y del sistema operativo, nunca de identificadores de hardware en crudo. Este análisis muestra cómo el SDK de Keyright calcula la huella y la envía en ActivateAsync, cómo el servicio de emisión cuenta huellas distintas como dispositivos activos y el problema operativo real de la deriva de huella: un clon de VM, un disco reimaginado, una NIC cambiada o una ampliación de RAM alteran la huella, la máquina parece nueva y los asientos se agotan. Cubrimos huellas multiseñal ponderadas, coincidencia por tolerancia, desactivación y expiración de arrendamiento para recuperar asientos, y la verificación que falla en cerrado.

Leer →
Revocation

Revocar una clave de licencia filtrada en todos los clientes

Una clave se compartió, apareció en un sitio de pastes o se está activando desde tres continentes a la vez. Aquí tienes el manual práctico: cómo la revocas en Keyright, qué significa la revocación en el servidor y —la parte que la mayoría de los equipos equivoca— cómo los clientes SDK desplegados se enteran de verdad y dejan de funcionar.

Leer →
Licensing

Integrar el SDK de Keyright en ASP.NET Core con resiliencia

Los equipos que instancian el cliente de Keyright a mano caen en uno de los dos fallos clásicos de HttpClient: agotamiento de sockets por crear un cliente por llamada, o DNS obsoleto por mantener un único cliente estático para siempre. Este artículo registra el cliente de Keyright a través de IHttpClientFactory como un cliente tipado para que los message handlers se agrupen y se roten correctamente, elige los lifetimes de DI adecuados y añade un pipeline de resiliencia — timeout, reintento con jitter y un circuit breaker ajustado para una llamada de licencia — de modo que un breve hipo del servicio emisor degrade con elegancia en lugar de fallar en seco.

Leer →
Entitlements

Actualizar una licencia in situ, de prueba a pago

Cuando un cliente convierte una prueba en pago o pasa de Standard a Pro, la cadena de la clave que ya activó no debería cambiar. Así se actualiza una licencia en el servidor con Keyright — quitando la marca de prueba, extendiendo la expiración, añadiendo entitlements — para que la app desplegada con el SDK adopte la nueva concesión en su próximo ValidateAsync, sin fricción de reactivación, además de cómo ajustar los tiempos de revalidación, mantener idempotente la llamada de actualización y auditar cada cambio de entitlements.

Leer →
Obfuscation

Ofuscar una capa Dapper sin romper el mapeo de columnas

Dapper empareja los nombres de columna del conjunto de resultados con los miembros públicos de tu POCO por nombre, sin distinguir mayúsculas, en el momento de la materialización. Renombra esos miembros con un ofuscador y Dapper deja de emparejar en silencio: sin excepción, solo una propiedad que queda en null o 0. Aquí tienes el panorama completo: cómo enlaza exactamente una columna a un miembro el controlador de tipos por defecto de Dapper, por qué tu texto SQL suele ser seguro pero los miembros de tu POCO son frágiles, las vías de escape con mapas personalizados y la keep-list precisa de nebula.config.json que fija los POCO de resultado mientras renombra el resto de la capa de datos.

Leer →
Obfuscation

Ofuscar una aplicación MassTransit sin romper el enrutamiento

MassTransit deriva la identidad de un mensaje —su MessageUrn, como urn:message:Contoso.Ordering.Contracts:OrderSubmitted— del espacio de nombres y el nombre del tipo de contrato .NET, y luego la usa para nombrar el exchange o topic del broker y la estampa en la cabecera messageType del envoltorio. El productor y los consumidores, a menudo desplegados por separado, deben coincidir en ella. Si ofuscas después de compilar, renombrar el tipo de contrato o su espacio de nombres cambia el URN, de modo que el productor publica en un exchange distinto y estampa un messageType distinto, y los consumidores existentes dejan de recibir en silencio. Este artículo explica exactamente cómo se construye el URN a partir del tipo, por qué el ensamblado de contratos de mensajes es la superficie frágil, y cómo fijar los espacios de nombres, nombres y propiedades de los contratos con una keep-list de Nebula.NET renombrando consumidores, sagas e internos.

Leer →
Protobuf

Por qué protobuf-net sobrevive al renombrado

protobuf-net serializa por las etiquetas numéricas de [ProtoMember(N)], no por los nombres de miembro, así que renombrar un DTO de protobuf-net es seguro en el cable, a diferencia de System.Text.Json o DataContract, donde los nombres SON el contrato. Aquí explicamos por qué el renombrado de propiedades es prácticamente gratis con protobuf-net y los cuatro casos que aún se rompen: numeración implícita de campos, nombres de tipo en ProtoInclude/AsReference, modelos por reflexión construidos por nombre de miembro y nombres de ProtoEnum.

Leer →
Refit

Ofuscar un cliente REST de Refit sin romperlo

Refit construye un cliente HTTP a partir de una interfaz de C#, pero la forma del cable proviene de los atributos — [Get("/users/{id}")], [Header], [Body], [Query] — no del nombre del tipo ni de los métodos de la interfaz. Así que el nombre de la interfaz, sus métodos y la implementación generada se pueden renombrar libremente. El único peligro real son los nombres de los parámetros, que se enlazan por nombre a las claves de ruta y de query; [AliasAs] los desacopla para que Nebula pueda renombrarlo todo.

Leer →
WCF

Ofuscar un servicio WCF sin romper el contrato del cable

Nebula renombra y cifra las partes internas de tu servicio WCF mientras una lista de conservación fija cada [ServiceContract], [DataContract] y [DataMember] por nombre, de modo que los nombres de los elementos SOAP, el WSDL y los clientes existentes siguen siendo compatibles byte a byte.

Leer →
Decompilation

Qué incrusta CallerArgumentExpression en tus llamadas

Cuando llamas a ArgumentNullException.ThrowIfNull(x) o a un Guard.Against(x) propio, pasas un argumento. El IL compilado empuja dos: tu valor y un literal de cadena con el texto fuente exacto de tu primer argumento, porque el parámetro lleva [CallerArgumentExpression]. El atributo vive en los metadatos del parámetro; el texto capturado vive como un simple ldstr en cada llamada. Un descompilador ingenuo te devuelve el segundo argumento redundante. Este artículo lee el IL y el blob del atributo, explica por qué está ahí el literal y recorre cómo Glass.NET detecta el atributo, compara el literal con la expresión reconstruida, suprime el argumento sintetizado y reconstruye la declaración del método con el atributo intacto.

Leer →
Decompilation

Cómo los enums Flags se decompilan a valores con nombre

Una combinación de banderas como Read | Write se pliega a un único literal entero antes de llegar al IL, así que el | que escribiste desaparece. Este análisis lee el IL real del código de banderas, explica las señales de metadatos de FlagsAttribute y de las constantes con nombre que permiten a un decompilador descomponer un entero en una suma de miembros con nombre, y muestra cómo Glass.NET reconstruye los patrones | & ~ y HasFlag en lugar de dejarte (Permissions)3.

Leer →
Decompilation

Cómo se decompilan el diseño explícito de structs y las uniones

La disposición explícita de structs es una de las pocas características de C# que un decompilador no puede recuperar a partir de las formas del código, porque no deja código: vive por completo en los metadatos. El LayoutKind (Sequential/Explicit/Auto) es un flag en la definición del tipo, Pack y Size están en la tabla ClassLayout, y el desplazamiento en bytes de cada campo está en la tabla FieldLayout. Cuando dos campos comparten un desplazamiento tienes una unión al estilo C: bytes aliasados, un int que ve los mismos cuatro bytes que un float. Equivócate en un solo desplazamiento y el struct decompilado corrompe en silencio cada llamada de interop y de marshalling que lo toca. Este artículo muestra dónde viven los datos de disposición, cómo Glass.NET lee las tablas ClassLayout y FieldLayout y vuelve a emitir [StructLayout(LayoutKind.Explicit, Pack = ..., Size = ...)] en el tipo y [FieldOffset(n)] en cada campo, cómo reconoce una unión a partir de desplazamientos solapados, y por qué preservar los desplazamientos exactos no es negociable.

Leer →
Decompilation

Cómo se decompilan los inicializadores de módulo en .NET

Un método marcado con [ModuleInitializer] se ejecuta antes que cualquier otra cosa del ensamblado, pero no es el atributo lo que invoca el runtime. El compilador de C# emite un constructor estático en el pseudotipo especial <Module> que llama a cada inicializador por turno. Aquí está el IL exacto que genera el compilador, las señales de metadatos que marcan el cctor de <Module> y lo distinguen de un inicializador de tipo normal, y cómo Glass.NET lo reconstruye hasta los métodos [ModuleInitializer] que escribiste.

Leer →
Decompilation

Cómo se decompilan los operadores de rango e índice de C#

Los operadores ^ y .. son puro azúcar del compilador. a[^1] se reduce a aritmética contra la longitud de la colección, a[1..^1] construye un System.Range a partir de dos valores System.Index y llama a RuntimeHelpers.GetSubArray, un rango de span se convierte en Span<T>.Slice, y un rango de cadena se convierte en String.Substring. Un decompilador ingenuo muestra las llamadas a constructores en bruto y la aritmética Longitud menos n; Glass.NET reconoce estos patrones y los pliega de vuelta a ^ y .. — incluyendo el caso sutil en el que span.Slice(1, 2) y span[1..3] emiten IL idéntico byte a byte, así que Glass tiene que elegir la lectura que hace round-trip.

Leer →
Decompilation

Cómo Glass reconstruye una instrucción switch de C# a partir de una tabla de saltos de IL

Un switch de C# sobre un rango denso de enteros no compila a una cadena de comparaciones: compila a un único opcode switch de IL que lleva una tabla de destinos de salto, indexada por el valor del switch. Esto recorre cómo es esa tabla de saltos, cómo el compilador normaliza el valor restando el caso mínimo, por qué los switch dispersos se convierten en cadenas if/else de búsqueda binaria, y cómo Glass.NET convierte la maraña de gotos resultante en un switch (x) { case 10: ... } limpio.

Leer →
Licensing

Derechos de licencia frente a feature flags

Un feature flag es un interruptor operativo que tú controlas; un derecho de licencia es una concesión comercial firmada por la que el cliente pagó. Si los confundes, un cliente activa un flag y desbloquea lo que nunca compró. Este artículo traza la línea, muestra los fallos de usar la herramienta equivocada, ofrece una tabla de decisión y conecta la arquitectura combinada de Keyright: los derechos como la barrera dura y los feature flags por encima para el despliegue dentro de lo que el cliente tiene derecho.

Leer →
Licensing

Licenciar por uso simultáneo con asientos flotantes

La activación por nodo fija una licencia a una máquina. La licencia flotante la fija al uso simultáneo: compras 25 asientos y cualquier 25 de tus 400 instalaciones pueden ejecutarse a la vez. El mecanismo es una concesión (lease): un cliente reserva un asiento, envía latidos para conservarlo y lo devuelve al salir. Un cliente que se bloquea nunca lo devuelve, así que su concesión simplemente expira y el asiento vuelve al grupo. Así se construye la licencia de asientos concurrentes en una instancia autoalojada de Keyright con reserva por concesión, conteo en el servidor, recuperación por TTL y una gestión elegante del caso «todos los asientos en uso».

Leer →
Reliability

Claves de idempotencia para operaciones de licencia seguras ante reintentos

Una escritura de licencia que agota el tiempo de espera te deja a ciegas: ¿se consumió el asiento o no? Si reintentas, arriesgas cobrar dos veces a un grupo de créditos o quemar un asiento dos veces; si te rindes, puedes haber vendido una licencia que nunca entregaste. Este es el problema de la respuesta perdida que afecta a todo cliente de licencias en red, y la solución es una clave de idempotencia que convierte un transporte de al-menos-una-vez en efectos de exactamente-una-vez. Así se mantienen correctas la activación, la medición, la emisión y la desactivación ante reintentos contra tu instancia autoalojada de Keyright.

Leer →
Licensing

Licenciar una app .NET con identidad de máquina efímera

La activación por nodo vincula una licencia a una huella de máquina estable, pero los contenedores obtienen una identidad nueva en cada reinicio, así que la vinculación ingenua agota activaciones. Así se licencia una app .NET en contenedor con Keyright: inyectando una identidad de despliegue estable, o arrendando asientos concurrentes para réplicas escaladas, y fallando en cerrado de forma limpia al arrancar.

Leer →
Webhooks

Webhooks de eventos de licencia salientes de Keyright

Deja de sondear la API de licencias para enterarte de lo que cambió. Así es como Keyright envía eventos de ciclo de vida firmados — activada, revocada, renovada, por vencer — a tu propio endpoint, y cómo verificar la firma, sobrevivir a la entrega al-menos-una-vez y rechazar repeticiones en el lado receptor.

Leer →
Licensing

Ventanas de gracia para una caída transitoria del servidor de licencias

Una comprobación de licencia en línea que falla en seco en cuanto tu servicio emisor de Keyright está brevemente inalcanzable convierte un parpadeo de DNS o un despliegue rutinario en una caída que ven tus clientes. Este artículo muestra cómo capear caídas transitorias con una ventana de gracia configurable sobre un resultado de validación firmado y en caché: distinguiendo «servicio inalcanzable» (transitorio, sigue funcionando) de «licencia revocada» (definitivo, falla cerrado ya), acotando la gracia con las marcas de tiempo firmadas por el propio servicio para que nadie la alargue desconectando la red, registrando cada ejecución en caché y fallando cerrado de forma limpia cuando se agota la ventana.

Leer →
Obfuscation

Ofuscar una función AWS Lambda de .NET sin romper el handler

El runtime gestionado de .NET en AWS Lambda localiza tu código mediante una cadena de handler con la forma Assembly::Namespace.Type::Method, que resuelve por reflexión en cada arranque en frío. Si ofuscas después de compilar, el renombrado saca al tipo o al método del handler de debajo de esa cadena: el ensamblado es válido, pero Lambda no logra resolver el punto de entrada y la invocación falla antes de que se ejecute tu código. Este artículo explica dónde vive la cadena del handler, qué símbolos resuelven por nombre el runtime gestionado y el serializador de Lambda, cómo fijar exactamente esos con una keep-list de Nebula.NET renombrando todo lo demás, y cómo integrar nebula protect en dotnet lambda package.

Leer →
Azure Functions

Ofuscar una app de Azure Functions sin romper el descubrimiento

El worker aislado de .NET encuentra tus funciones a través de un proveedor de metadatos generado por código fuente que incrusta el punto de entrada de cada función en el ensamblado como una cadena literal —"Namespace.Class.Method"— en tiempo de compilación. Si ofuscas después, el renombrado mueve el método fuera del alcance de esa cadena, de modo que el host de Functions carga tu app y luego no encuentra ni una sola función. Esta entrada explica exactamente qué nombres resuelve el modelo aislado en tiempo de ejecución, cómo mantener en una keep-list los métodos de trigger y los DTOs de binding con Nebula.NET, y cómo cifrar cadenas y virtualizar la lógica de negocio que es la razón misma de existir de la función.

Leer →
Guide

Ofuscar una herramienta global de .NET sin romper los comandos

Una dotnet tool es un paquete NuGet contra el que nadie compila, así que puedes renombrar mucho más agresivamente que en una biblioteca. Aquí te mostramos cómo proteger la DLL dentro del paquete manteniendo intactos el punto de entrada, los nombres de los comandos y `dotnet tool install`, con Nebula.NET.

Leer →
Obfuscation

Ofuscar una aplicación Hangfire sin romper los trabajos

Hangfire serializa en su almacenamiento cada trabajo encolado, programado o recurrente como el nombre de tipo totalmente cualificado, el nombre del método y los tipos de parámetro, y luego lo resuelve de vuelta a un MethodInfo por reflexión cuando un worker lo ejecuta, posiblemente en un despliegue posterior. Si ofuscas después de compilar, el renombrado saca la clase del trabajo o su método de debajo de esas cadenas almacenadas, de modo que todos los trabajos en curso y recurrentes fallan al deserializarse con un error de tipo no encontrado. Este artículo explica exactamente qué escribe Hangfire en su almacenamiento, por qué los trabajos recurrentes y los diferidos largos son el filo más afilado, y cómo fijar las clases de trabajo, los métodos invocados y sus tipos de parámetro con una keep-list de Nebula.NET renombrando todo lo demás.

Leer →
Obfuscation

Ofuscar configuración fuertemente tipada sin romper el enlace

El enlazador de configuración asigna las claves de appsettings.json y de las variables de entorno a los nombres de las propiedades públicas de tu POCO de opciones mediante reflexión. Renombra esas propiedades en un paso de ofuscación y los valores enlazados pasan silenciosamente a ser null o el valor por defecto en tiempo de ejecución: sin error de compilación, sin excepción, solo comportamiento incorrecto. Este artículo explica cómo `services.Configure<T>` resuelve las claves a los setters de las propiedades, qué cambia el enlazador generado por fuente de .NET 8+ y qué no, cómo construir una keep-list en nebula.config.json que fije los nombres de las propiedades públicas y el constructor sin parámetros de tus clases de opciones mientras renombra todo lo demás, y cómo confirmar en Glass.NET que la superficie de opciones sobrevivió.

Leer →
Obfuscation

Ofuscar una app SignalR sin romper los métodos de hub

SignalR despacha cada mensaje en tiempo real haciendo coincidir una cadena con un método. Un cliente llama a `connection.InvokeAsync("SendMessage", ...)` y registra `hubConnection.On("ReceiveMessage", ...)`, y el servidor resuelve esas cadenas a métodos de hub por nombre en tiempo de ejecución. Si renombras un método público de hub o un miembro de una interfaz de cliente fuertemente tipada, el despacho falla en silencio: la conexión sigue viva, pero el mensaje nunca llega. Este artículo analiza cómo el despachador de SignalR asigna la cadena objetivo de la invocación a tu método de hub, por qué `[HubMethodName]` y `Hub<T>` cambian qué nombres son críticos, cómo construir una lista de conservación en nebula.config.json que fije exactamente la superficie de métodos visible en el cable mientras renombra los cuerpos del hub, los servicios internos y los detalles internos de los DTO, y cómo confirmar en Glass.NET que solo sobrevivieron los nombres previstos.

Leer →
Boxing

Cómo se decompilan el boxing y el unboxing en C#

Una conversión implícita de int a object es invisible en C#, pero asigna en el heap, y el IL lo deja claro con un opcode box. Esto recorre de dónde salen box, unbox.any y el prefijo constrained., por qué el código genérico usa constrained. para esquivar una asignación por boxing, y cómo Glass.NET reconstruye C# legible mientras el IL revela la asignación que el código fuente oculta.

Leer →
Glass.NET

Leer las instrucciones de nivel superior en C# decompilado

Un archivo de instrucciones de nivel superior no tiene ninguna clase visible ni ningún Main visible, pero el ensamblado sí. El compilador de C# envuelve tus instrucciones en una clase interna llamada Program y en un método de entrada con el nombre impronunciable <Main>$, marcado con la directiva .entrypoint. Esto es exactamente lo que emite el compilador en los casos síncrono y async, por qué el punto de entrada es el método que nunca puedes escribir a mano, adónde fueron a parar tus global usings y cómo Glass.NET lo lee de vuelta como el programa de nivel superior que escribiste.

Leer →
CLI

Decompila .NET desde la línea de comandos o un asistente de IA

Glass.NET 1.3.0 incorpora una CLI headless y un servidor MCP. Reconstruye un proyecto C# compilable o un solo miembro con glass export, genera un SBOM, comprueba la autenticidad de un paquete NuGet, compara dos compilaciones y deja que un asistente de IA lea C# decompilado a través de un servidor Model Context Protocol con glass mcp — todo análisis estático, todo gratis.

Leer →
Metering

Medir el uso por función con varias bolsas de créditos

Los productos reales miden más de una cosa — tokens de IA, minutos de render, exportaciones — y juntarlo todo en una sola bolsa de créditos oculta el coste y bloquea funciones sin relación cuando una se agota. Así se modelan varias bolsas de créditos independientes en una misma licencia de Keyright: la forma de una bolsa, el consumo idempotente por bolsa que falla cerrado de forma aislada, el orden de consumo desde la cuota incluida hasta la recarga prepago, los consumos atómicos sobre varias bolsas para una operación que gasta dos medidores a la vez, y la reconciliación por bolsa que sigue funcionando sin conexión.

Leer →
Licensing

Ejecuta para siempre las versiones que pagaste

Una licencia perpetua con ventana de mantenimiento permite a un cliente ejecutar para siempre todas las versiones publicadas mientras sus actualizaciones estaban activas, pero no las versiones que publicas después de que caduquen. Aquí se explica cómo modelarlo en una única licencia Keyright firmada: una reclamación maintenance-through, la fecha de publicación de la compilación incrustada en tu ensamblado y la única comparación que nunca debe fallar en cerrado.

Leer →
AI Licensing

Licenciar funciones de IA y agentes autónomos

Keyright 2.9.0 añade entitlements de IA y de agentes de primera clase: nombre los modelos, endpoints y herramientas que un cliente puede invocar, limite un agente autónomo con un presupuesto de créditos y un lease, y aplíquelo todo fail-closed y offline desde una licencia firmada, con un POST /v1/consume medido para el uso en curso. Aquí está la forma del entitlement, el JSON firmado, los helpers del SDK en C#, Node, Python y Java, y un escenario concreto de denegar-el-modelo-no-licenciado.

Leer →
Localización

Ofuscar una aplicación .NET localizada sin romper los recursos

Una aplicación localizada resuelve sus traducciones por nombre en tiempo de ejecución, y ese es justo el tipo de búsqueda que la ofuscación puede romper en silencio. La sorpresa es que los dos estilos de localización más habituales se comportan de forma opuesta al renombrar: un accesor .resx clásico generado por el diseñador es seguro porque el nombre base de su ResourceManager es un literal de cadena ya incrustado, mientras que IStringLocalizer<T> es frágil porque la fábrica deriva el nombre base del nombre completo del tipo marcador: renombra ese tipo y la búsqueda falla, el ensamblado satélite nunca se consulta y el localizador devuelve en silencio la clave del recurso en lugar de la traducción. Este artículo lee lo que emite cada estilo, muestra por qué uno sobrevive y el otro no, y da las reglas de conservación precisas de Nebula.NET para que tus traducciones sigan cargándose en todas las culturas.

Leer →
Nebula.NET

Ofuscar una aplicación WinUI 3 sin romper el XAML

WinUI 3 compila {x:Bind} a una clase de enlace generada dentro de tu propio ensamblado —una llamada tipada al getter por token de metadatos más una comparación literal de PropertyName—, así que todo el view model se renombra sin problemas. Los fallos que quedan son los tres lugares donde WinUI, o tu propio código, todavía pasa por una cadena: una ruta de {Binding} clásico resuelta por reflexión, una página localizada con Type.GetType a partir de un nombre construido, y un tipo que el Package.appxmanifest activa por su nombre literal. Esta entrada lee el código de enlace generado, muestra por qué {x:Bind} sobrevive a un renombrado completo mientras que {Binding} vuelve vacío, explica qué nombres de propiedades de dependencia personalizadas son realmente críticos, y da la configuración de Nebula que aplana la aplicación sin tocar la superficie que se resuelve por cadenas.

Leer →
Obfuscation

Verificar tu ofuscación .NET en CI

Una compilación en verde no prueba que tu ensamblado .NET esté protegido. Nebula.NET 2.2.0 emite un informe de protección estable y versionado en cada compilación e incluye `nebula verify`, una barrera de CI que falla la compilación con un código de salida dedicado cuando el renombrado, el cifrado de cadenas, el control de flujo o la virtualización que pediste no se aplicaron de forma silenciosa.

Leer →
Descompilación

Cómo se decompila una app Blazor WebAssembly

Una app Blazor WebAssembly envía tus ensamblados .NET al navegador — empaquetados como webcil, pero con el IL completo. Esto es cómo sacarlos de _framework, leerlos en un descompilador y por qué tu C# del lado cliente está tan expuesto como JavaScript.

Leer →
Decompilación

Leer ensamblados compilados con F# en un decompilador de C#

F# compila al mismo IL que C#, así que un decompilador de C# muestra los ensamblados de F# como C#. Aquí tienes cómo aparecen las uniones discriminadas, los records, los módulos y las funciones currificadas, y qué te dicen los metadatos de CompilationMapping.

Leer →
Descompilación

Cómo se decompilan P/Invoke y DllImport

Las declaraciones P/Invoke se compilan a métodos pinvokeimpl con un ImplMap. Así reconstruye un descompilador [DllImport], MarshalAs y las convenciones de llamada — y así lees exactamente qué funciones nativas invoca un ensamblado desconocido.

Leer →
Descompilación

Por qué los ensamblados ReadyToRun aún se decompilan sin problemas

Las imágenes ReadyToRun llevan código nativo precompilado y, aun así, se descompilan a C# con la misma facilidad que cualquier ensamblado, porque el IL sigue ahí. Esto es lo que R2R guarda realmente, cómo reconocerlo y por qué un descompilador ignora la parte nativa.

Leer →
Licenciamiento

Mantener la activación de licencia tras las actualizaciones automáticas de escritorio

Los autoactualizadores que instalan cada versión en una carpeta nueva pierden sin avisar tu activación en caché, forzando una reactivación en cada actualización. Esto es dónde guardar la licencia firmada para que sobreviva, según el actualizador.

Leer →
Licenciamiento

Licenciar software en agentes de compilación efímeros de CI y nube

El licenciamiento atado por nodo asume máquinas estables. Los runners de CI y los agentes autoescalados nacen y se destruyen constantemente, así que cada ejecución parece una máquina nueva y consume una plaza. Así se licencia cómputo efímero sin agotar tu recuento de plazas.

Leer →
Ofuscación

Ofuscar una app desplegada con ClickOnce sin impedir que arranque

Los manifiestos de ClickOnce guardan un hash de cada archivo. Si ofuscas después de generarlos, la app se niega a arrancar con un error de validación. Este es el orden de compilación exacto que hace convivir la ofuscación y ClickOnce.

Leer →
Ofuscación

Ofuscar código que genera código en tiempo de ejecución

Cuando tu aplicación emite IL en tiempo de ejecución — DynamicMethod, TypeBuilder, Expression.Compile — el renombrado puede romperla de formas que el compilador nunca advierte. Esto es exactamente qué patrones de generación de código sobreviven a la ofuscación y cuáles necesitan reglas de conservación.

Leer →
Ofuscación

Ofuscar los ensamblados de un juego Unity de forma segura

Cómo ofuscar el C# de un juego Unity sin romper escenas, prefabs ni el inspector: qué protege cada backend, Mono e IL2CPP, y las keep-rules exactas que exigen la serialización y la reflexión de Unity.

Leer →
Licenciamiento

Dejar que los socios emitan claves de licencia de forma segura

Vender a través de OEM y revendedores significa que los socios emiten claves a sus clientes, pero no puedes repartir tus credenciales de administrador. Así funciona el aprovisionamiento con alcance, atribución y tope, y cómo mantener cada clave emitida por un socio rastreable y revocable.

Leer →
Licenciamiento

Licenciamiento por núcleo para software de servidor .NET

El licenciamiento por núcleo vive o muere según se cuenten bien los núcleos. Aquí tienes por qué Environment.ProcessorCount engaña, cómo leer los núcleos físicos y las cuotas de CPU de un contenedor en .NET, y cómo vincular un derecho de recuento de núcleos a una licencia firmada.

Leer →
Ofuscación

Impedir que un atacante vuelque tu ensamblado .NET

La ofuscación en disco no sirve una vez que tu ensamblado está cargado y sus cadenas descifradas en RAM — un volcado de memoria lo captura. Así corrompe la protección anti-dump el PE en memoria para que un volcado no sea un ensamblado utilizable.

Leer →
Nebula.NET

Depurar una build .NET protegida en producción

En cuanto ofuscas, la depuración normal se complica: frames renombrados, nada de paso a paso útil, PDB que no te atreves a distribuir. Pero una build protegida no tiene por qué ser una caja negra. Esta es la guía de operaciones: por qué no deberías distribuir los PDB completos, cómo mapear un stack trace de producción renombrado con el mapa sembrado que conservaste, por qué el diagnóstico va primero por logs, y cómo mantener útiles los mensajes de excepción y la telemetría sin filtrar internos.

Leer →
Glass.NET

Decompila una app .NET de archivo único o autocontenida con Glass.NET

Publicaste una app .NET, arrastras el .exe a un decompilador y no sale nada legible. El problema no es el decompilador — es que dotnet publish tiene varios formatos y la mayoría no te entrega un ensamblado gestionado donde lo esperas. Aquí tienes dónde vive realmente tu IL en una compilación autocontenida, de archivo único, ReadyToRun o Native AOT, y cómo abrirlo en Glass.NET.

Leer →
Glass.NET

Extrae y lee recursos embebidos de un ensamblado .NET con Glass.NET

Una DLL lleva más que código. Horneados en el mismo archivo hay recursos .resources y cadenas ResX embebidas, cadenas localizadas de ensamblados satélite, archivos enteros como config, JSON, SQL y certificados, y constantes de cadena y de bytes. Así se encuentra y se lee todo en Glass.NET — el decompilador gratuito y de solo análisis estático que nunca ejecuta el ensamblado — y se exporta a disco para inspeccionarlo fuera de la herramienta.

Leer →
Glass.NET

Mira de qué depende y qué llama un ensamblado .NET con Glass.NET

Antes de distribuir una DLL de terceros quieres conocer su superficie externa: qué ensamblados y paquetes referencia, para qué framework está compilada, qué bibliotecas nativas invoca por P/Invoke y dónde se conecta a la red, al sistema de archivos o a otro proceso. Así se audita todo eso de forma estática en Glass.NET — el decompilador gratuito que lee el binario y nunca lo ejecuta.

Leer →
Glass.NET

Entiende código .NET de terceros desconocido con Glass.NET

Dependes de una DLL de la que no tienes código fuente — un paquete abandonado, una biblioteca interna cuyo autor se fue, un SDK de proveedor con documentación escasa — y necesitas saber cómo funciona de verdad. Aquí tienes un flujo de investigación concreto en Glass.NET, el decompilador de .NET gratuito y de solo análisis estático que nunca ejecuta el ensamblado que inspecciona.

Leer →
Keyright

Proteger tu endpoint de activación frente al abuso

Tu ruta caliente de activación —/v1/activate y /v1/validate— no está autenticada por diseño: es la ruta que llaman las apps de tus clientes con una clave de licencia, sin token de administrador. Así que la defiendes con lógica de licenciamiento y controles en el borde, no con autenticación. Aquí tienes el manual por capas: topes de puestos y bloqueo por equipo como estrangulador natural, detección de activaciones duplicadas para claves compartidas y VM clonadas, revocación para una clave filtrada, un límite de tasa o WAF en tu propio proxy inverso delante de /v1/*, y registros de licencia estructurados que ocultan la clave.

Leer →
Keyright

Ejecuta Keyright autoalojado totalmente aislado de la red

Keyright autoalojado no necesita internet saliente en tiempo de ejecución. Verifica su propia autolicencia sin conexión contra la clave pública embebida de Delta1 —sin llamar a casa, fail-closed ante manipulación— y las apps de tus clientes validan sin conexión entre activaciones. Aquí tienes cómo instalar la autolicencia como archivo, desactivar la búsqueda GeoIP, llevar la imagen a tu registro privado, ejecutar contra tu propio Postgres y gestionar el licenciamiento medido con bloques de crédito aislados.

Leer →
Keyright

Copia de seguridad y recuperación de una instancia de Keyright autoalojado

Keyright autoalojado es una app sin estado cuyo estado completo vive en tu PostgreSQL, así que la recuperación ante desastres es en realidad copia de seguridad de Postgres más salvaguardar dos secretos que tú generas. Aquí tienes qué hay que respaldar de verdad, el secreto que marca la diferencia entre una restauración y una base de datos muerta, y un simulacro de restauración que devuelve un servidor de licencias a la ruta de activación.

Leer →
Keyright

Actualizar una instancia de Keyright autoalojada de forma segura

Actualizar Keyright autoalojado es poco dramático porque la app es sin estado y ejecuta sus propias migraciones de esquema al arrancar — nada de SQL a mano. Pero aun así quieres un procedimiento seguro: respalda Postgres primero, prueba en no-producción, fija la etiqueta de imagen y actualiza un nodo cada vez tras tu balanceador de carga. Aquí tienes la secuencia, incluido por qué el rollback significa restaurar la copia de la base de datos, no degradar contra una base de datos ya migrada.

Leer →
Nebula.NET

Elegir qué excluir del renombrado en Nebula

Todo ofuscador te deja excluir nombres del renombrado, y el primer instinto cuando algo se rompe es excluir de más. Una keep-list es una frontera diseñada y mínima, no un cajón de sastre para todo lo que se rompió. Esta es la disciplina: qué debe quedarse de verdad sin renombrar (API pública, objetivos de reflexión, DTOs serializados, clases de options, escaneo de DI, XAML, puntos de entrada de un host), cómo expresarlo en nebula.config.json, cómo estrechar cada entrada hasta lo mínimo posible, y cómo demostrar el resultado en Glass.NET.

Leer →
Nebula.NET

Ofuscar una solución .NET de varios proyectos de forma coherente

Una solución con una docena de bibliotecas de clases y una app no son una docena de problemas de ofuscación: es uno solo. Protege cada proyecto por separado y duplicarás la protección de copias transitivas, romperás InternalsVisibleTo entre tus propios ensamblados y acabarás con un montón de mapas de renombrado que no cuadran. Esta es la guía: decide qué entregas de verdad y protege solo eso, ejecuta una sola pasada sobre la salida de publicación, gobierna cada ensamblado desde un único nebula.config.json compartido, renombra toda la solución para que el acceso de amigos y las referencias cruzadas sigan sincronizados, mantén un mapa sembrado por versión y cablea todo en CI para que cada build entregada quede protegida igual.

Leer →
Nebula.NET

Ofuscar una app .NET construida sobre AutoMapper y MediatR

Estas tres bibliotecas son la columna vertebral de un servicio ASP.NET Core moderno, y las tres resuelven cosas en tiempo de ejecución —por tipo y por nombre de propiedad— mediante convención y escaneo de ensamblados. Eso hace que se comporten de forma muy distinta bajo el renombrado. AutoMapper empareja miembros por nombre de propiedad, así que los DTOs renombrados dejan de mapear en silencio; MediatR encuentra los handlers por la forma de la interfaz, así que normalmente sobrevive intacto; FluentValidation descubre los validadores por forma pero informa de los errores por nombre de propiedad, así que el descubrimiento se mantiene mientras tus cadenas PropertyName quedan opacas. Esto es exactamente lo que se rompe en cada uno, la regla keep mínima para cada uno, un nebula.config.json consolidado, y cómo demostrarlo con pruebas de integración y Glass.NET.

Leer →
Glass.NET

Compara dos versiones de un ensamblado .NET con Glass.NET

Tienes la v1.2.0 y la v1.3.0 de una DLL y necesitas saber exactamente qué cambió — APIs nuevas, un método alterado en silencio, una llamada de red recién añadida — sin el código fuente y sin ejecutar ninguna de las dos compilaciones. Así se comparan dos versiones de un ensamblado en Glass.NET, el decompilador de .NET gratuito y de solo análisis estático.

Leer →
Keyright

Ejecutar Keyright autoalojado en varios nodos

Tu servidor de licencias está en la ruta de activación de tus clientes, así que no debería ser un punto único de fallo. Keyright autoalojado es un servicio ASP.NET Core sin estado —todo el estado vive en tu PostgreSQL— por lo que la alta disponibilidad es solo ejecutar dos o tres réplicas tras un balanceador de carga sin afinidad de sesión. Aquí tienes exactamente cómo.

Leer →
Keyright

Migrar claves de licencia caseras a Keyright

Un plan de migración paso a paso para dejar atrás un sistema de claves artesanal y pasarte a Keyright: inventaría lo que tienes, emite licencias firmadas para los clientes existentes, publica un cliente que lea ambos formatos durante una ventana de transición y luego retira el camino antiguo, todo sin obligar a un solo cliente a reactivar.

Leer →
Nebula.NET

Proteger un .NET Worker Service sin interfaz

Un Worker Service de .NET es el tipo de app más fácil de ofuscar con agresividad y el más fácil de olvidar ofuscar por completo. Se entrega al servidor de un cliente como una DLL, se ejecuta sin interfaz como servicio de Windows o unidad de systemd, y lleva tus secretos de integración y tu lógica de negocio con apenas superficie de reflexión que proteger —lo que significa que puedes renombrar casi todo—. Esta entrada cubre por qué un worker en segundo plano es un objetivo tentador de ingeniería inversa, las pocas costuras del Generic Host que aún leen nombres (enlace de options, escaneo de ensamblados, DTOs serializados) y cómo integrar Nebula.NET en el paso de publicación para que el binario entregado quede renombrado, con cadenas cifradas y virtualizado donde importa.

Leer →
Comparativa

Una alternativa a SmartAssembly en 2026

SmartAssembly combina la ofuscación de .NET con informes automáticos de errores y de uso de funciones. Esta es una comparación honesta con Nebula.NET: en qué destaca cada uno, qué plataformas modernas importan y cómo decidir sobre tu propio binario.

Leer →
Glass.NET

¿De verdad funcionó tu ofuscación? Compruébalo en Glass.NET

Una compilación limpia no demuestra que tu código esté protegido. Abre el ensamblado ofuscado en Glass.NET — el decompilador de .NET gratuito y de solo análisis estático — y léelo como lo hará un atacante: confirma que el renombrado, el cifrado de cadenas, el flujo de control y la virtualización aguantaron, y que no sobreprotegiste tu API pública.

Leer →
Glass.NET

Cómo se decompilan los árboles de expresiones de C#

El mismo `x => x + 1` compila de dos formas completamente distintas según el tipo al que se asigna. Como delegado es un método oculto y un ldftn; como Expression<Func<int, int>> es un nido de llamadas a Expression.Parameter, Expression.Constant, Expression.Add y Expression.Lambda con los miembros referenciados por ldtoken. Aquí tienes exactamente qué emite el compilador para un árbol de expresiones — variables capturadas como un Constant de una clausura, igualdad de cadenas con su op_Equality, lambdas anidadas envueltas en Quote — y cómo un decompilador pliega las llamadas de fábrica de vuelta a la lambda que escribiste.

Leer →
Keyright

Licenciar una app .NET en Linux y macOS

La mayoría de las guías de licenciamiento están escritas para Windows, y el SDK de Keyright lo disimula sin decirlo: las mismas llamadas a Validate() y ActivateAsync() funcionan en Linux y macOS. Pero las tres cosas de las que depende un SDK de licencias —una carpeta de datos por usuario, una identidad de máquina estable y una app que se relanza con la frecuencia suficiente para refrescar su lease— son distintas fuera de Windows. El lease acaba en ~/.local/share, donde una app de Mac en sandbox o un servicio systemd con ProtectHome= no pueden escribir. La huella de máquina se ancla en /etc/machine-id o en el IOPlatformUUID en lugar de en un valor del registro, y una imagen maestra que olvidó limpiar el machine-id convierte toda una flota en una sola máquina. Y un daemon que arranca una vez al trimestre nunca recibe el refresco de arranque en el que confía una app de escritorio, así que su lease de 14 días caduca con el proceso aún en ejecución. Esta entrada recorre dónde escribe el SDK en cada plataforma, de qué se construye la huella y las dos trampas del machine-id, una unidad de systemd con StateDirectory= y LoadCredential= que le da un hogar al SDK, el bucle de refresco del lease que necesita un servicio de larga duración, el modo de archivo que el lease merece en un host multiusuario y el bucle de verificación que lo demuestra.

Leer →
Nebula.NET

Ofuscar tipos de Newtonsoft.Json sin romper el JSON

Newtonsoft.Json lee tu DTO por los nombres de sus miembros mediante reflexión — Customer se convierte en "Customer" en el cable porque la propiedad se llama literalmente Customer — así que en el momento en que un ofuscador la renombra a a, el JSON que produce tu servicio se convierte en { "a": … } y cada consumidor y cada documento almacenado se rompen, en silencio, en tiempo de ejecución. Json.NET no tiene un generador de código fuente en tiempo de compilación para esquivar ese recorrido por reflexión, así que fijar los nombres con [JsonProperty] no es una optimización, es todo el contrato. Y esconde una segunda trampa, peor: TypeNameHandling escribe el nombre cualificado por ensamblado de tu tipo en el documento como $type, de modo que renombrar un tipo rompe cada payload polimórfico que otro build haya escrito — un fallo que ningún atributo arregla. Esta entrada precisa a qué nombres se vincula Json.NET, por qué [JsonProperty] y [EnumMember] convierten los nombres en el cable en constantes que el renombrador no puede tocar, por qué el constructor de deserialización es un segundo vínculo por nombre, y por qué TypeNameHandling necesita un ISerializationBinder estable en lugar de una regla de keep. Termina con la prueba de ida y vuelta, ejecutada contra el build protegido, que convierte "la serialización se rompió" en un test fallido en vez de un correo de un cliente.

Leer →
Glass.NET

Cómo se decompila la interpolación de cadenas de C#

Una cadena interpolada no tiene IL propio: el compilador elige una de tres reducciones completamente distintas según tu framework de destino, los tipos de los huecos y si un método optó por un manejador. Aquí tienes exactamente qué emite `$"..."` como string.Concat, como string.Format y como la danza de DefaultInterpolatedStringHandler, además del caso de manejador personalizado en el que la cadena nunca se construye, y dónde un decompilador puede replegar cada forma a `$"..."`.

Leer →
Keyright

Licenciar una app de Windows empaquetada como MSIX

MSIX es la forma en que se instalan hoy las apps de escritorio en Windows —a través de winget, del despliegue empresarial, de la Store— y cambia silenciosamente tres cosas de las que depende un SDK de licencias. Las escrituras en %LocalAppData% se redirigen a una carpeta por paquete que la app nunca ve en una ruta. Desinstalar el paquete borra esa carpeta, así que el lease de activación en caché, el reloj local de prueba y el estado de manipulación del reloj desaparecen mientras el puesto en el servicio de licencias sigue vinculado. Y el directorio de instalación es de solo lectura, que es exactamente donde debería estar una licencia de sitio incluida en el paquete. Esta entrada recorre qué escribe el SDK de Keyright y dónde acaba bajo una app empaquetada, por qué la huella de máquina sobrevive cuando la caché no, qué le hace un ciclo de desinstalación/reinstalación al recuento de puestos (nada, gracias a la activación idempotente — salvo que el cliente quisiera mudarse), cómo detectar la identidad de paquete y darle al SDK rutas explícitas, cómo incluir una licencia dentro del paquete, cuándo desactivar la virtualización de escritura en el manifiesto, y el bucle de pruebas que lo demuestra.

Leer →
Glass.NET

Cómo se decompilan los tipos de valor anulables en C#

int? parece un tipo con un null dentro, y en el IL no es ninguna de las dos cosas: es el struct genérico System.Nullable<int>, dos campos y ningún null en ninguna parte, y toda operación que el lenguaje te deja escribir sobre él la reescribe el compilador en llamadas a ese struct. a + b sobre dos valores int? se convierte en una conjunción de HasValue, dos llamadas a GetValueOrDefault, un add y un newobj — o un initobj para el resultado nulo. a == b se convierte en una comparación de valores con AND de una comparación de HasValue. a == null se convierte en una sola llamada a HasValue. a ?? 5 se convierte en un condicional sobre HasValue. Y hacer box de un int? hace algo que ningún otro struct hace: la instrucción box produce o bien un int boxeado o bien una referencia nula, así que Nullable<T> nunca existe en el heap. Esta entrada lee cada una de esas rebajas en IL y sigue a un decompilador mientras las pliega de vuelta a los operadores que el autor escribió — por qué el patrón HasValue y GetValueOrDefault tiene que reconocerse como unidad, por qué int? sale del blob de firma y no de ningún atributo (a diferencia de string?), cómo unbox.any sobre una referencia nula produce silenciosamente un Nullable vacío, y qué hace mal un decompilador cuando renderiza la rebaja en lugar del lenguaje.

Leer →
Keyright

Vincular una licencia de sitio Keyright a un dominio

Una empresa que compra cuatrocientos puestos no quiere cuatrocientas activaciones, y tú no quieres que la clave que los desbloquea todos salga por la puerta en el portátil de un contratista. La respuesta clásica es una licencia de sitio —una clave para toda la organización— y la pregunta que nadie escribe es a qué está vinculada la clave, si no es a una máquina. Esta entrada construye una licencia de sitio sobre Keyright como una capacidad firmada que nombra el dominio DNS del cliente, opcionalmente fijada por el SID del dominio de Windows: de dónde salen esas dos identidades (IPGlobalProperties.DomainName, no Environment.UserDomainName, y SecurityIdentifier.AccountDomainSid), por qué la coincidencia por sufijo es la comparación correcta para un bosque con dominios hijos, cómo la puerta falla cerrada en un portátil no unido al dominio, cómo el cliente te entrega los valores sin un viaje de ida y vuelta con TI, y el modelo de amenazas honesto: un nombre de dominio es una valla de política que un atacante decidido puede rodear renombrando una VM, un SID de dominio eleva el listón hasta clonar un controlador de dominio, y ninguno de los dos sustituye a un recuento de puestos cuando realmente lo necesitas.

Leer →
Nebula.NET

Por qué el renombrado rompe el código que usa dynamic

Una llamada estática sobrevive al renombrado porque se resuelve por token de metadatos y el ofuscador reescribe el token junto con el miembro. Una llamada dynamic no sobrevive a nada: el compilador de C# rebaja settings.Timeout a un call site cuyo binder recibe la cadena "Timeout", y en tiempo de ejecución Microsoft.CSharp recorre el tipo real del receptor buscando un miembro con exactamente ese nombre. Renombra Timeout a a y el sitio sigue pidiendo "Timeout", la búsqueda falla, y la app lanza RuntimeBinderException en una línea que compiló bien y pasó todas las pruebas en la build sin proteger. Esta entrada lee el IL de un sitio dynamic para mostrar dónde vive el nombre (un ldstr que alimenta Binder.GetMember y Binder.InvokeMember dentro de un contenedor oculto <>o__), explica por qué el cifrado de cadenas ni ayuda ni perjudica, por qué ningún renombrador puede arreglarlo automáticamente con seguridad (el tipo del receptor no se conoce hasta que la llamada se ejecuta), qué operaciones dynamic se vinculan por nombre y cuáles no (indexadores vía Item, operadores vía nombres op_, claves de ExpandoObject nunca), el patrón de doble despacho por dynamic que rompe silenciosamente un visitor entero, y las tres soluciones por orden de preferencia: sustituir dynamic por una interfaz, fijar solo los miembros que un sitio alcanza con [Obfuscation(Exclude = true)], o una entrada exclude en nebula.config.json — más la única prueba que lo detecta en la build protegida.

Leer →
Glass.NET

Cómo se decompilan los inicializadores de array en C#

Escribe int[] x = { 1, 2, 3, 4, 5 } y podrías esperar cinco instrucciones stelem, una por elemento. Para un array pequeño eso es aproximadamente lo que obtienes, pero pasado un umbral el compilador de C# deja de almacenar los elementos uno a uno y hace algo más extraño: asigna el array y después llama a RuntimeHelpers.InitializeArray con un handle a un campo estático cuyos bytes son el array completo empaquetado de principio a fin, y ese campo no tiene ningún inicializador en el IL: sus datos viven en una sección de datos del PE, apuntada por una fila de metadatos FieldRVA, tipada como un struct sintético en una clase oculta cuya única propiedad es su longitud en bytes. Un decompilador no puede leer el literal del IL, porque el IL solo contiene un memcpy; tiene que reconocer el patrón InitializeArray, resolver el token del campo, seguir el FieldRVA hasta los bytes en bruto, tomar el tipo de elemento del newarr que lo precedió y dividir el blob little-endian de vuelta en { 1, 2, 3, 4, 5 }. Esta entrada recorre el IL y los metadatos de un array inicializado por blob, muestra lo que Glass.NET reconstruye, explica por qué un array de cadenas nunca toma este camino, y cubre el caso ReadOnlySpan de bytes en el que no hay array en absoluto: solo un handle de campo y un CreateSpan.

Leer →
Glass.NET

Cómo se decompila una constante decimal en .NET

Cualquier otro literal numérico en C# —42, 3.14, 1_000_000L— acaba en el IL como una instrucción ldc o en la tabla Constant de los metadatos, un valor que el runtime carga directamente. decimal no puede: es un struct de 128 bits, no un primitivo para el que el CLR tenga un opcode de carga, así que un const decimal o un parámetro decimal por defecto no tiene ningún sitio nativo donde vivir, y el compilador lo resuelve con un truco que desconcierta a cualquiera que lea IL en bruto: codifica el número en un [DecimalConstantAttribute] cuyos cinco argumentos de constructor (escala, signo y tres enteros de 32 bits) deletrean el valor exacto. Esta entrada sigue a un decompilador a través de esa reconstrucción: por qué la tabla Constant rechaza decimal, cómo los argumentos del atributo se corresponden con los cuatro enteros de los que se construye un decimal, por qué un campo const decimal no tiene inicializador en ningún constructor, en qué se diferencia un parámetro decimal por defecto de uno int por defecto, y por qué confundir el atributo con una anotación ordinaria convierte 3.14m de vuelta en new decimal(314, 0, 0, false, 2) en lugar de en un literal.

Leer →
Glass.NET

Qué delata un método de extensión al decompilar

Un método de extensión no existe en tiempo de ejecución como extensión. Es un método estático corriente cuyo primer parámetro resulta estar marcado, y una llamada a él —text.Trim().Count()— compila a una llamada estática ordinaria, Enumerable.Count(string.Trim(text)), sin sintaxis de punto, sin receptor, sin nada que diga que alguna vez se escribió de forma fluida. Lo único que el compilador deja atrás es un atributo [Extension]: en el método, para que el primer parámetro pueda representarse con this, y en la clase estática que lo contiene, para que una herramienta sepa siquiera que debe mirar ahí. Un decompilador tiene que leer ese atributo, decidir que una llamada estática cuyo destino lo lleva debe imprimirse como una llamada de miembro sobre su primer argumento, y acertar con la precedencia para que una cadena de diez operadores LINQ vuelva como una cadena y no como un anidamiento de diez niveles de llamadas estáticas. Esta entrada recorre el IL de un método de extensión definido y de un lugar de llamada, muestra qué reconstruye Glass.NET, explica por qué el atributo —y no la llamada— es la fuente de verdad, y cubre la forma más reciente de bloque de extensión de C# 14, cuyos miembros compilan a los mismos métodos estáticos bajo otra piel.

Leer →
Glass.NET

Cómo se decompilan los campos volatile en .NET

La palabra clave volatile no tiene un runtime propio. Compila en dos piezas de metadatos separadas que viven en lugares distintos: un modificador requerido, modreq(IsVolatile), soldado a la firma del campo, y un prefijo volatile. de un byte estampado delante de cada ldfld y stfld que toca el campo. Un decompilador tiene que leer los dos, ponerse de acuerdo consigo mismo sobre cuál manda, y luego no confundir el resultado con las dos cosas que parecen idénticas en C# pero compilan de forma completamente distinta: Volatile.Read sobre un campo corriente, que es una llamada normal sin prefijo y sin modificador, e Interlocked.Increment sobre un campo volatile, que toma el campo por dirección y, por tanto, lleva el modificador pero no el prefijo. Esta entrada recorre el IL de los tres, muestra qué reconstruye Glass.NET a partir de cada uno, explica por qué el propio token de referencia al campo tiene que llevar el modreq o el acceso ni siquiera resuelve, y cubre el único caso que C# no sabe deletrear —un prefijo volatile. sin un campo volatile detrás— y la llamada que Glass emite para él.

Leer →
Keyright

¿Qué estado HTTP debe devolver una comprobación de licencia fallida?

Cuando una API con licencia decide que un llamador no tiene permiso para ejecutarse, lo peor que puede hacer es devolver un 500 pelado con un stack trace, y lo segundo peor es un 200 con { "ok": false } que ningún cliente nota jamás. Esta entrada deduce el contrato HTTP que una puerta de licencia realmente debe a sus llamadores: por qué un fallo de licencia no es un 401 (el llamador está perfectamente autenticado — es la licencia la que caducó), cuándo es correcto el 403 y cuándo el 402 Payment Required dice más, cómo transportar el motivo legible por máquina en un cuerpo application/problem+json según RFC 9457 con miembros de extensión sobre los que un cliente puede ramificar, y la única cabecera de respuesta —nunca la clave— que permite a una CLI o a un servicio hermano reaccionar sin analizar prosa. Construye la puerta como un IEndpointFilter de ASP.NET Core que mapea el LicenseStatus de Keyright sobre códigos de estado mediante IProblemDetailsService, añade Retry-After cuando el servicio de licencias está brevemente inaccesible y la ventana de gracia sigue abierta, y termina con una prueba WebApplicationFactory que afirma el estado, el tipo de problema y que la clave firmada nunca aparece en el cuerpo.

Leer →
Keyright

Mapear el estado de la licencia a un health check de ASP.NET Core

Un servicio .NET sin interfaz no tiene un cuadro Acerca de donde mostrar su licencia, así que el único lugar donde los operadores llegan a ver el estado de la licencia es el panel de monitorización, lo que significa que la licencia tiene que convertirse en un health check. La versión ingenua conecta la licencia directamente a la sonda de readiness: una clave caducada empieza a devolver 503, el orquestador saca la instancia de rotación y después la mata, el reemplazo arranca con la misma clave caducada y acabas de construir un bucle de reinicios a partir de un evento de facturación. Esta entrada lee qué significan realmente los tres valores de HealthStatus para un orquestador, mapea el LicenseStatus de Keyright sobre ellos de modo que una clave válida pero a punto de caducar sea Degraded y no Unhealthy, mantiene el estado de la licencia completamente fuera de la sonda de liveness para que un vencimiento nunca dispare un kill, cachea la validación para que una sonda por segundo no vuelva a verificar una firma cada vez y expone el detalle que los operadores necesitan a través del diccionario de datos del health check. Termina con la disposición de tags que separa el endpoint de licencia de readiness y liveness, y con la prueba que demuestra que una clave caducada se degrada sin tumbar el proceso.

Leer →
Keyright

Una clave de licencia para muchas apps y paquetes de productos

Distribuyes un Designer, un Renderer y una CLI, y tu cliente quiere una sola clave para todos ellos, no tres. El atajo evidente —dar a cada aplicación el mismo slug de producto y dejar que la firma haga el resto— es el atajo que, sin hacer ruido, vende tu aplicación más cara al precio de la más barata, porque una clave que verifica para la línea de producto verifica en todas las aplicaciones de la línea. Esta entrada lee qué comprueba realmente la claim de producto de una licencia Keyright (es una comprobación de audiencia, no de características), expone las tres formas de licenciar una suite, muestra el agujero del diseño de slug compartido con el gate exacto que lo abre y construye la versión que aguanta: un slug para la línea, la pertenencia por aplicación como entitlements con espacio de nombres y un gate en cada aplicación que pregunta «¿estoy en este paquete?» antes de preguntar cualquier otra cosa. Termina con la ruta de actualización de una clave de una sola aplicación a una clave de suite, y el respaldo de dos clientes para equipos que ya distribuyeron un slug por aplicación.

Leer →
Keyright

Registro estructurado de comprobaciones de licencia, sin la clave

La comprobación de licencia es el único evento que decide si tu software tiene permiso para ejecutarse, y casi siempre se registra o bien como nada en absoluto o bien como un desastre: un log.LogInformation("license: {License}", info) que serializa el objeto completo e imprime la clave firmada, la firma y el correo del licenciatario en un fichero que se envía a un agregador de logs y se comparte en un ticket de soporte. Esta entrada construye el camino intermedio: un único evento estructurado por verificación, emitido a través de un LoggerMessage generado en compilación para que la regla de redacción viva exactamente en un sitio, con la clave reducida a una huella corta que permite a un operador correlacionar sin transportar nunca el secreto. Mapea el LicenseStatus de Keyright sobre niveles de log de modo que una licencia inválida sea un Error sobre el que puedas alertar y una sana sea una Information silenciosa, asigna un rango de EventId estable para que un panel pueda contar fallos de licencia sin comparar cadenas, envuelve la verificación en un scope de logging para que cada línea posterior lleve la huella, mantiene el evento fuera de la ruta caliente por petición, y termina con la prueba —una aserción con FakeLogger— que demuestra que la clave en bruto nunca llega al sink.

Leer →
Nebula.NET

Por qué la DI por escaneo de ensamblados se rompe al renombrar

Muchísimas apps .NET nunca escriben explícitamente sus registros de DI. Escanean un ensamblado al arrancar —con Scrutor, o con un bucle de reflexión hecho a mano— y registran cada tipo cuyo nombre termina en "Service", "Handler" o "Repository". Esa convención es una comparación de cadenas contra el nombre del tipo, y la ofuscación por renombrado cambia todos esos nombres, de modo que el predicado t.Name.EndsWith("Handler") no coincide con nada, los servicios nunca se registran en silencio y la app lanza "Unable to resolve service for type ..." en la primera petición: un fallo en tiempo de ejecución con una compilación en verde, lejos de la línea que lo causó. Esta entrada separa las dos formas en que un escaneo puede encontrar un tipo: por su nombre, que no sobrevive al renombrado, y por su forma —asignable a una interfaz marcadora, decorado con un atributo, derivado de una base—, que sí sobrevive, porque son identidades por token de metadatos que el renombrado reescribe de forma consistente en ambos lados. Muestra los registros de Scrutor que se rompen y los equivalentes que sobreviven, explica por qué AsImplementedInterfaces no da problemas mientras que el predicado por nombre sí, traza la línea que traza Nebula, ofrece tanto el refactor recomendado como la regla de exclusión para cuando no puedes refactorizar, y termina con una prueba de humo de arranque que hace fallar la compilación ofuscada rápido en lugar de en la primera petición.

Leer →
Nebula.NET

Ofuscar un ensamblado .NET visible para COM de forma segura

Un ensamblado .NET visible para COM lo consume código que no sabe que es .NET —una macro de VBA, un VBScript, un host de C++ heredado— y ese consumidor se enlaza a él mediante un contrato hecho de tres cosas que no están donde un desarrollador de C# guarda la API pública: un GUID en la clase y en la interfaz, un DispId en cada miembro, y un ProgID que por defecto es el nombre del tipo cualificado con su espacio de nombres. Ofúscalo como ofuscarías una biblioteca y los GUID sobreviven (son constantes de atributo), pero el ProgID se mueve en el momento en que renombras la clase, y un cliente de enlace tardío que hace CreateObject("Acme.Widget") e invoca los miembros por nombre mediante IDispatch se rompe tanto por el ProgID desplazado como por los nombres de miembro renombrados. Esta entrada lee qué resuelve realmente un cliente COM en cada etapa —de ProgID a CLSID a miembro de IDispatch—, traza la línea entre lo que Nebula renombra (la implementación, el motor) y lo que queda fijado (los GUID, los DispId, los nombres de miembro que usa el enlace tardío, el ProgID), muestra la disposición con [ProgId] e interfaz explícita que reduce la superficie fijada, da la configuración y termina con la comprobación de registrar e invocar tanto en un script de enlace tardío como en un cliente tlb de enlace temprano.

Leer →
Nebula.NET

Ofuscar un módulo binario de PowerShell de forma segura

Un módulo binario de PowerShell es un ensamblado .NET corriente que PowerShell carga por reflexión, y es un objeto peculiar de ofuscar porque su contrato público no está donde los desarrolladores de C# esperan encontrarlo. El nombre del cmdlet —Get-Widget— procede del atributo [Cmdlet], así que la clase que lo implementa puede renombrarse a cualquier cosa. Pero los nombres de los parámetros —-Name, -Force, -Path— son literalmente los nombres de tus propiedades públicas: renómbralos y se rompen todos los scripts, todo el autocompletado con tabulador y todas las páginas de Get-Help. Lo mismo ocurre con los objetos que el cmdlet escribe en la canalización, cuyos nombres de propiedad son los encabezados de columna de Format-Table y los objetivos de Select-Object. Esta entrada lee exactamente sobre qué reflexiona el runtime de PowerShell cuando importa un módulo y enlaza los parámetros, traza la línea entre lo que Nebula puede renombrar (la clase del cmdlet, el motor que hay detrás) y lo que queda fijado (las propiedades de parámetro, las propiedades de salida, los atributos), muestra la disposición de «cmdlet fino, motor grueso» que mantiene pequeña la superficie fijada, da la configuración y termina con la comprobación de importar e invocar que de verdad demuestra que el módulo protegido funciona.

Leer →
Nebula.NET

Ofuscar tipos de System.Text.Json sin romper el JSON

System.Text.Json basado en reflexión lee tu DTO por los nombres de sus propiedades — Order se convierte en "order" en el cable porque la propiedad se llama literalmente Order — lo que significa que en el momento en que un ofuscador renombra esa propiedad a a, el JSON que produce tu servicio se convierte en { "a": …, "b": … } y cada consumidor y cada ida y vuelta se rompen, en silencio, en tiempo de ejecución, donde ningún paso de build puede detectarlo. Esta entrada precisa exactamente a qué nombres se vincula el serializador y a cuáles no: por qué una auto-propiedad pelada es una mina, por qué [JsonPropertyName("order")] es el arreglo que convierte el nombre en el cable en una constante que el renombrador no puede tocar, por qué un [JsonConstructor] parametrizado empareja parámetros con propiedades por nombre de modo que los argumentos del constructor también quedan fijados, cómo se comportan [JsonExtensionData] y [JsonStringEnumMemberName] en enums, y por qué el JsonSerializerContext generado en compilación cambia el panorama por completo. Muestra la configuración de Nebula que mantiene el contrato intacto — atribuye los nombres, deja que los miembros se renombren — y la prueba de ida y vuelta que demuestra que un build protegido sigue deserializando lo que serializó.

Leer →
Glass.NET

Cómo se decompilan los métodos de interfaz por defecto

Un método de interfaz por defecto rompe la regla más antigua que un decompilador conoce sobre las interfaces: que contienen firmas, no cuerpos. Desde C# 8 una interfaz puede incluir una implementación funcional, y una clase que implementa la interfaz puede no aportar absolutamente nada y aun así obtener el comportamiento. Eso deja tres rompecabezas para Glass.NET: un método de instancia virtual con cuerpo dentro de una interfaz (ni abstracto ni método de clase), una clase cuyos metadatos no contienen ningún override ni ningún MethodImpl pero que se comporta como si los tuviera, y un sitio de llamada que debe pasar por el tipo de la interfaz porque el miembro es invisible en la clase. Esta entrada lee el IL de los tres —el newslot virtual con cuerpo, el MethodImpl ausente, el callvirt contra la interfaz— y muestra cómo Glass reconstruye la implementación por defecto, deja la clase implementadora correctamente vacía y conserva el cast a la interfaz que el lenguaje realmente exige.

Leer →
Glass.NET

Cómo se decompilan los filtros de excepción en C#

Un bloque catch con un tipo es de lo más sencillo que lee un descompilador: una cláusula de manejador con un token de tipo, listo. Un catch con una cláusula when es de lo más espinoso, porque es un tipo de región de excepción completamente distinto. El filtro no tiene token de tipo; la prueba de tipo se traslada a un bloque de IL aparte que se ejecuta mientras la pila aún se está desenrollando, evalúa la condición when y acaba en un endfilter que devuelve 1 para ejecutar el manejador o 0 para seguir buscando. Reconstruir catch (IOException e) when (e.HResult == 5) significa reconocer esa estructura de dos bloques, elevar el objeto de excepción que el runtime puso en la pila a la variable e, extraer la prueba de tipo del filtro como el tipo del catch, y leer el resto como la expresión when, sabiendo luego que las excepciones lanzadas dentro del filtro se tragan, lo cual es una garantía real del lenguaje visible en el IL. Este artículo lee el IL exacto que emite un catch filtrado, recorre el protocolo de endfilter y muestra cómo Glass.NET reconstruye la cláusula.

Leer →
Glass.NET

Cómo se decompila la instrucción fixed en C#

No hay sentencia fixed en IL. Lo que el compilador de C# emite en su lugar es una variable local con el modificador pinned en su firma, unas pocas instrucciones que calculan un puntero a partir de lo que hayas fijado — con guardas que nunca escribiste — y un almacenamiento que limpia la local al final del bloque. No hay try/finally, porque un pin es una propiedad del tiempo de vida de una local y no una región de código. El inicializador se rebaja de cuatro maneras distintas según lo que fijes: un array recibe una comprobación de nulo o vacío y un ldelema del elemento cero, una cadena recibe o bien la aritmética heredada de OffsetToStringData o bien una llamada a GetPinnableReference, un Span o cualquier tipo con un método GetPinnableReference recibe esa llamada sobre su dirección, y &campo o &local recibe un simple ldflda o ldloca. Este artículo lee el IL real de cada forma, explica por qué un array vacío produce un puntero nulo en lugar de una excepción, y muestra cómo Glass.NET se ancla en la local pinned para plegar la maquinaria de vuelta en el fixed de una línea que escribiste.

Leer →
Glass.NET

Cómo se decompilan los argumentos opcionales y con nombre

Un parámetro opcional no tiene coste en tiempo de ejecución en el sitio de llamada que usted escribió: el valor predeterminado no se almacena en el método, el compilador lo sustituye en cada llamador. Así que en IL no hay rastro de un argumento predeterminado salvo en la llamada: un literal apilado donde usted no escribió nada. El propio valor predeterminado vive lejos, en la tabla de metadatos Constant asociada al parámetro, junto a una marca Optional; un decompilador que lea el método tiene que ir a buscarlo allí para imprimir = 0 o = null. Los argumentos con nombre son aún más extraños: desaparecen por completo cuando están en orden, y cuando están desordenados el compilador los reescribe como pushes posicionales en orden, a menos que evaluarlos fuera de orden tenga efectos secundarios, en cuyo caso vuelca primero cada argumento en un temporal para preservar la evaluación de izquierda a derecha, dejando un bloque de almacenamientos que parece código que usted escribió. Este artículo lee el IL y los metadatos de ambos, muestra las filas de la tabla Constant que hay detrás de un valor predeterminado, recorre los temporales de reordenación y explica cómo Glass.NET recupera los valores predeterminados opcionales y decide cuándo merece la pena imprimir un argumento con nombre.

Leer →
Keyright

Desfase de reloj en la verificación de licencias

Un cliente activa una licencia a las 9:00 y tu aplicación la rechaza como «aún no válida». Nada está falsificado, nada ha caducado: el reloj de su portátil va cuatro minutos por detrás de la máquina que emitió la clave, así que la claim NotBefore queda en su futuro. Esta entrada trata el problema del reloj honesto (no el del atacante que retrasa el reloj, que es otra entrada distinta): los pocos minutos de desacuerdo entre el reloj del emisor y el del verificador que convierten una licencia correcta en un fallo espurio en el peor momento posible, justo después de la compra. Lee las tres claims de tiempo de una licencia Keyright (IssuedAt, NotBefore, Expiry), muestra la comparación ingenua que se rompe y construye la verificación con tolerancia: un pequeño margen simétrico en NotBefore y Expiry, por qué la tolerancia es asimétrica en su intención, y por qué el tiempo transcurrido dentro de una sesión debe medirse con un reloj monótono y no con el reloj de pared del que acabas de decidir que no puedes fiarte del todo.

Leer →
Keyright

Licenciar una biblioteca de componentes .NET

Una biblioteca de componentes tiene dos audiencias y solo una de ellas es tu cliente. El desarrollador que compra tu motor de PDF o tu control de gráficos es quien tiene la licencia; los usuarios finales que ejecutan las aplicaciones construidas con él nunca han oído hablar de ti, nunca se les debe pedir una clave y trabajan en máquinas que tú no puedes activar. Eso cambia dónde se comprueba una licencia y qué viaja dentro del binario distribuido. Este artículo construye el diseño al que convergen la mayoría de los proveedores de controles con Keyright: una licencia de desarrollador perpetua, sin bloqueo por equipo, verificada en tiempo de compilación por un target de MSBuild dentro de tu paquete NuGet, incrustada en el ensamblado del cliente como un atributo firmado y verificada de nuevo en tiempo de ejecución, sin conexión, contra la clave pública de tu biblioteca — con un derecho updates-until en lugar de una caducidad para que la aplicación del cliente nunca se detenga, una reclamación de audiencia para que una licencia extraída de una aplicación no active otra, y un nombre de licenciatario con valor de marca de agua firmado en cada binario que la usa.

Leer →
Keyright

Verificar una licencia en Native AOT

Native AOT y el recorte (trimming) completo premian lo único que una comprobación de licencia ya debería ser: una función pura sobre bytes. Pero las comodidades que hacen agradable un SDK en el JIT (un serializador JSON basado en reflexión, cargar una clave por nombre, obtener el algoritmo de firma a partir de una cadena) son exactamente lo que el recortador elimina y aquello para lo que el compilador AOT se niega a generar código. Este artículo toma una verificación sin conexión de Keyright y la deja limpia para AOT de principio a fin: incrusta la clave pública como un ReadOnlySpan<byte> que compila a un puntero a la sección de datos sin asignación alguna, la importa con ImportSubjectPublicKeyInfo y verifica con ECDsa.VerifyData (ambos seguros frente al recorte) y lee la carga firmada con un Utf8JsonReader en lugar de un serializador por reflexión, de modo que toda la ruta no lleva ningún RequiresDynamicCode ni RequiresUnreferencedCode y produce cero advertencias de recorte. Lee el IL de la optimización de span sobre datos estáticos, muestra la única llamada a JsonSerializer que habría envenenado la publicación y explica por qué un verificador de licencias es la parte más fácil de su aplicación para llevar a AOT.

Leer →
Keyright

Avisos de renovación que no molestan a tus usuarios

Un banner de cuenta atrás es fácil de equivocar de dos formas opuestas: molesta a un cliente perpetuo que no tiene nada que renovar, o calla hasta que una suscripción ya ha caducado y la aplicación ha fallado en cerrado a Free. Ambos errores nacen del mismo fallo: calcular el mensaje a partir del archivo de licencia en bruto en lugar del resultado validado. Este artículo construye el aviso de renovación de la forma correcta, a partir del LicenseInfo de Keyright: usando Kind para distinguir una licencia perpetua de una suscripción y una de prueba, DaysRemaining e IsExpiringSoon para decidir cuándo hablar, y el hecho de que una suscripción caducada se valida a Free, por lo que el aviso debe dispararse mientras la licencia sigue siendo válida, no después. Lee la pequeña lógica tras Kind, muestra por qué una licencia perpetua tiene un ExpiryUtc nulo y nunca debe mostrar una cuenta atrás, y conecta un banner que renueva al cliente que caduca en silencio y deja en paz a todos los demás.

Leer →
Nebula.NET

Ofuscar un ensamblado de F# sin romper las uniones

F# compila al mismo IL que C#, así que un renombrador puede ofuscarlo, pero F# se apoya en una capa de metadatos emitidos por el compilador para la que C# no tiene equivalente, y un renombrador que no la entiende rompe en silencio cosas que aun así compilan. Una unión discriminada no es un tipo suma para el CLR; es una clase abstracta con una subclase anidada por caso, un entero Tag y un atributo [CompilationMapping(SourceConstructFlags.SumType)] que la reflexión de FSharp.Core lee para recuperar los casos. Renombra los tipos de caso a ciegas, o elimina ese atributo como "metadatos sin usar", y FSharpType.GetUnionCases no devuelve nada, la impresión con %A deja de nombrar tus casos y cualquier serializador consciente de F# pierde la forma, todo con una compilación limpia. Este artículo lee el IL que una unión, un registro y un módulo emiten de verdad, muestra exactamente qué nombres y atributos son de carga porque FSharp.Core los observa en tiempo de ejecución, y configura Nebula para renombrar la lógica preservando el contrato de reflexión del que depende F#.

Leer →
Nebula.NET

Ofuscar readonly structs y retornos ref de forma segura

Un readonly struct, un parámetro in y un retorno ref readonly no son meras comodidades del código fuente: se codifican en los metadatos como modificadores personalizados y atributos emitidos por el compilador, que el compilador de C# vuelve a leer para decidir si un sitio de llamada hace una copia defensiva oculta, qué sobrecarga gana y si un valor puede pasarse por referencia siquiera. Un modreq(InAttribute) en un parámetro forma parte de su firma, así que eliminarlo cambia la identidad del método y rompe el enlace; quitar IsReadOnlyAttribute de un struct hace que cada llamada con in empiece a copiarlo; eliminar IsByRefLike permite aplicar boxing a un ref struct. Un ofuscador que trate todo esto como metadatos decorativos que renombrar o descartar produce ensamblados que siguen cargando pero se comportan de otra manera, o que no consiguen enlazar con llamadores que no controla. Este artículo lee el IL de cada característica, muestra exactamente qué piezas son firma y cuáles son atributo, recorre las tres formas en que un renombrador descuidado las corrompe y explica cómo Nebula conserva textualmente los modreqs y los atributos de compilador conocidos mientras sigue renombrando todo lo que es genuinamente suyo.

Leer →
Nebula.NET

Ofuscar un generador de código fuente de Roslyn de forma segura

Un generador de código fuente es una cosa extraña de ofuscar: es un ensamblado .NET Standard 2.0 que el compilador carga por reflexión y ejecuta dentro de la compilación de tu cliente, y es donde vive tu lógica de tiempo de compilación más valiosa, exactamente el código que distribuyes y que preferirías no entregar a un decompilador. La buena noticia es que Roslyn descubre los generadores por atributo, no por nombre, así que Nebula puede renombrar el tipo del generador y toda su superficie privada sin ningún efecto sobre el descubrimiento. Las partes que están fijas son pocas y concretas: el atributo [Generator] debe sobrevivir, el constructor público sin parámetros debe seguir siendo público (el compilador lo instancia con Activator.CreateInstance) y el método de interfaz al que llama debe conservar su slot. Esta entrada lee sobre qué reflexiona realmente el GeneratorDriver, traza la línea entre lo que se renombra y lo que es estructural, muestra la configuración de Nebula y aclara lo único que la gente entiende al revés: ofuscar el generador no ofusca el código que emite.

Leer →
Nebula.NET

Ofuscar miembros virtuales y de interfaz de forma segura

Renombrar un método privado es una edición local. Renombrar un método virtual no lo es, porque su nombre forma parte de cómo el CLR cablea el despacho: un override reutiliza el slot de su base emparejando nombre y firma al cargar el tipo, una implementación implícita de interfaz se encuentra de la misma manera, y solo una implementación explícita se vincula mediante una fila MethodImpl que lleva tokens en lugar de texto. Si te equivocas en la agrupación, o bien obtienes una TypeLoadException en el momento en que se carga el tipo — o, peor, nada en absoluto, mientras el override se desconecta en silencio y se ejecuta en su lugar la implementación base. Este artículo lee el IL de cada vinculación, muestra cuáles son por nombre y cuáles por tabla, recorre las tres formas en que un renombrador ingenuo las rompe, y explica cómo Nebula agrupa un método virtual con cada override e implementación a los que está conectado — a través de tipos e interfaces — para que todo el slot se renombre a un único nombre o se mantenga intacto cuando cualquier miembro de él cruza a un ensamblado que no controlas.

Leer →
Glass.NET

Qué recupera un decompilador de los tipos anónimos

Un tipo anónimo no tiene un nombre que tú hayas escrito, pero es una clase real en los metadatos: una genérica que el compilador sintetiza, llamada algo como <>f__AnonymousType0`2, con una propiedad de solo lectura por miembro, un constructor que las recibe todas y sobrescrituras de Equals, GetHashCode y ToString. El truco que la hace reutilizable es que la clase generada es genérica sobre los tipos de sus propiedades, de modo que dos sitios new { } con los mismos nombres de propiedad en el mismo orden comparten un único tipo de respaldo instanciado con argumentos de tipo distintos. Esta entrada lee la clase generada y el sitio de llamada newobj en IL, muestra dónde viven realmente los nombres de propiedad (en las propiedades del tipo generado, no en los parámetros de tipo <Name>j__TPar), recorre el Equals estructural y el GetHashCode de combinación de hashes que escribe el compilador, y explica cómo Glass.NET reconoce el patrón y lo pliega de vuelta a new { Name = ..., Total = ... } en lugar de dejarte un tipo genérico impronunciable.

Leer →
Glass.NET

Cómo Glass reconstruye bucles y condicionales a partir de saltos

El IL no tiene while, ni for, ni else: tiene bloques básicos e instrucciones de salto: br, brtrue, brfalse, switch. Un bucle for y una reescritura con goto-espagueti del mismo bucle pueden compilar a IL idéntico, así que un decompilador no puede leer la estructura de vuelta; tiene que reconstruirla. Esta entrada recorre la tubería real que ejecuta Glass.NET: dividir el método en bloques básicos en cada salto y destino de salto, construir un grafo de flujo de control, calcular dominadores para hallar qué bloque gobierna cuál, detectar bucles naturales a partir de aristas hacia atrás al bloque que los domina, y estructurar los saltos hacia delante en if/else, y luego explica el caso difícil honesto, el flujo de control irreducible, donde no existe un bucle limpio y un decompilador debe o bien duplicar código o bien recurrir a etiquetas y goto.

Leer →
Glass.NET

Cómo foreach se decompila de vuelta a C#

No hay foreach en IL. El compilador de C# lo rebaja a una de tres formas completamente distintas según lo que iteres: una llamada a GetEnumerator con un bucle while y un try/finally oculto que libera el enumerador, una versión con enumerador struct sin ningún dispose, o, sobre un array o un span, un simple bucle for contado por índice sin enumerador a la vista. Un decompilador solo ve el código rebajado y tiene que reconocer qué patrón está mirando para imprimir de vuelta foreach en lugar de la maquinaria. Este artículo lee el IL real de cada caso, muestra por qué el Dispose vive en un finally que el código fuente nunca escribió, por qué el enumerador struct se lo salta, y cómo Glass.NET empareja la forma — el trío GetEnumerator/MoveNext/get_Current, el try/finally, la comprobación de IDisposable — para recuperar el bucle que realmente escribiste.

Leer →
Keyright

Elegir un algoritmo de firma para las claves de licencia

Una clave de licencia es un payload firmado, y el algoritmo de firma que eliges no es un detalle intercambiable: decide cuán larga es la clave que tu cliente tiene que teclear, cuán rápido la verifica cada arranque y si un solo error en tu código de emisión puede filtrar la clave privada. Las firmas RSA-2048 ocupan 256 bytes, lo que convierte una clave tecleable en un muro de base32; ECDSA P-256 ocupa un tercio de eso pero lleva un nonce que, reutilizado, entrega tu clave a un atacante; Ed25519 ocupa 64 bytes, es determinista y no tiene nonce que estropear. Este artículo sopesa los tres en los ejes que de verdad importan para el licenciamiento offline-first — tamaño de firma y de clave pública, coste de verificación en un arranque en frío, determinismo y modos de fallo, y qué aspecto tiene cada uno en System.Security.Cryptography — y explica por qué Keyright firma con Ed25519 por defecto.

Leer →
Keyright

Fijar tu clave pública de verificación de licencias

Tu app verifica una licencia porque una firma cuadra contra una clave pública embebida en el ensamblado. Pero esa clave son datos: una constante base64 que cualquier atacante capaz de editar tu DLL puede encontrar y sobrescribir con una clave que él controla, de modo que sus licencias autofirmadas ahora verifican y la tuya queda olvidada. Esto es la sustitución del ancla de confianza, y es el ataque de mayor apalancamiento contra el licenciamiento offline-first. Esta entrada muestra el ataque a nivel de IL —el ldstr que carga la clave, el único rango de bytes que toca un parche— y luego eleva su coste: toma la huella de la clave contra un valor entretejido en el flujo de control en lugar de dejarlo solo, la verifica en más de un sitio, lleva varias claves con AdditionalPublicKeysBase64 para que un solo cambio no baste, y empareja la comprobación del cliente con strong-naming, anti-tamper y report-home para que un build manipulado sea a la vez más difícil de hacer y visible cuando se distribuye.

Leer →
Licenciamiento

Diseñar una clave de licencia que las personas puedan teclear

Una licencia de Keyright son bytes firmados, pero lo que un cliente lee en una factura, teclea en un diálogo de activación o dicta por teléfono es una cadena, y base64 es una cadena pésima para ese trabajo. Distingue mayúsculas de minúsculas, usa + y / que se corrompen en el correo y en los shells, y un solo carácter mal tecleado produce un fallo de firma sin ninguna pista de dónde estuvo el error. Esta entrada construye la codificación de transporte que Keyright usa realmente: base32 de Crockford para que el alfabeto sobreviva a una llamada telefónica y a la tecla de mayúsculas, segmentos de cinco caracteres para que el ojo pueda seguir la posición, y un símbolo de control módulo 37 que atrapa todos los errores de un solo carácter y casi todas las transposiciones antes de ejecutar siquiera la costosa verificación de firma. Muestra la codificación y decodificación reales en C#, la normalización que convierte una clave tecleada con descuido de vuelta en bytes canónicos, y por qué el dígito de control es una característica de ergonomía y nunca de seguridad.

Leer →
Nebula.NET

Ofuscar enums sin filtrar los nombres

Renombra un enum y sus miembros y un decompilador sigue imprimiendo LicenseTier.Pro, no a.b, porque un enum es una clase sellada cuyos miembros son campos const literales públicos, y en cuanto tu código llama a ToString() o Enum.Parse el runtime lee esos nombres de campo directamente de los metadatos en tiempo de ejecución. Renombrarlos a a, b, c es legal y no te cuesta nada salvo lo único que querías: un ida y vuelta por el nombre se rompe, porque "Pro" ya no coincide con un campo llamado a. Esta entrada lee el IL al que compila un enum, muestra dónde viven los nombres (la tabla Field y el heap #Strings, no los valores), recorre exactamente qué se rompe al renombrar —ToString, Enum.Parse, el formateo de [Flags], la serialización JSON por cadena, Enum.GetNames— y cómo Nebula acota el tratamiento de enums para que los valores que gobiernan tu lógica queden protegidos mientras los nombres de los que depende tu protocolo permanezcan intactos.

Leer →
Nebula.NET

Ofuscar genéricos sin romper la reflexión

Un parámetro de tipo genérico como TResult es un nombre en los metadatos — una fila de la tabla GenericParam con una cadena en #Strings —, así que un renombrador puede convertirlo en T0 y un decompilador imprimirá fielmente T0, que es exactamente el resultado inofensivo que quieres. Pero los genéricos son donde el renombrado ingenuo rompe cosas en silencio, porque el CLR identifica una instanciación por posición y aridad, no por nombre, mientras que tu código de reflexión identifica un parámetro de tipo por su nombre. Este artículo lee en qué se compilan realmente un método y una clase genéricos — las tablas GenericParam y GenericParamConstraint, el MethodSpec y el TypeSpec que registran una instanciación por índice —, muestra por qué renombrar el parámetro es gratis pero renombrar un tipo de restricción no lo es, y recorre las llamadas de reflexión (Type.GetGenericArguments().Name, MakeGenericType, GetMethod sobre un genérico abierto) que leen nombres de vuelta y se rompen cuando un renombrador toca lo que no debe.

Leer →
Nebula.NET

Cómo Nebula reutiliza un mismo nombre entre varios miembros

Un renombrador ingenuo da a cada miembro un nombre corto único (a, b, c, d) y ahí se queda. Está dejando valor sobre la mesa, porque .NET no identifica un miembro por su nombre. Un método se identifica por su nombre junto con su firma, un campo por su nombre y su tipo declarante, y el runtime enlaza cada llamada a través de un token de metadatos resuelto en tiempo de carga, no comparando cadenas de nuevo. Eso significa que puedes renombrar docenas de métodos sin relación entre sí al único nombre a, siempre que sus firmas difieran, y el ensamblado sigue cargando, verificándose y ejecutándose. Esta entrada lee los metadatos de MethodDef y del heap de cadenas para mostrar por qué el renombrado con colisiones es legal, recorre las reglas exactas que lo acotan (choques de firmas idénticas, cadenas de sobrescritura virtual, implementaciones explícitas de interfaz) y explica cómo Nebula comprime los nombres hasta un conjunto minúsculo y reutilizado que a la vez reduce el heap de cadenas y convierte la salida de un decompilador en un muro ilegible de miembros con nombres idénticos.

Leer →
Glass.NET

Cómo se decompilan los eventos de C# en .NET

Una línea de C# — public event EventHandler Changed; — se convierte en cuatro cosas en el ensamblado: un campo de delegado privado, un accesor add_Changed y otro remove_Changed, y una fila de la tabla Event que los vincula mediante MethodSemantics. Los accesores tampoco son simples asignaciones: desde C# 4 el compilador emite un bucle Interlocked.CompareExchange sin bloqueos alrededor de Delegate.Combine y Delegate.Remove, y los binarios más antiguos llevan en su lugar una variante con [MethodImpl(Synchronized)]. Un decompilador tiene que reconocer ambas formas para plegar las cuatro piezas de vuelta en una sola declaración, conservar un add/remove explícito cuando el autor lo escribió y renderizar el sitio de invocación ?.Invoke en lugar del baile de dup/brtrue al que compila. Aquí tienes los metadatos, el IL y lo que Glass.NET hace con ello.

Leer →
Glass.NET

Cómo se decompilan los operadores condicionales nulos

El operador condicional nulo se lee como un único símbolo pulcro —order?.Customer?.Name—, pero no existe ninguna instrucción ?. en IL. El compilador de C# lo rebaja a comprobaciones de nulo y ramas ordinarias, y el detalle que hace que una cadena se decompile limpiamente es que cada eslabón cortocircuita hacia el mismo destino compartido, no hacia un nido propio. Esta entrada lee el IL real de una cadena de dos eslabones, muestra por qué el primer receptor se comprueba con un brtrue a secas mientras que un resultado intermedio se duplica con dup y se descarta con pop, recorre el lifting a Nullable que convierte s?.Length en un int? con un initobj en el lado nulo y un Nullable..ctor en el otro, cubre las rebajas de ?? y ??= que comparten la misma forma de cortocircuito, y explica cómo Glass.NET reconoce el patrón y pliega las ramas de vuelta a ?. y ?? en lugar de dejarte un laberinto de etiquetas.

Leer →
Glass.NET

Dónde esconden el array las colecciones params

Durante veinte años un parámetro params significaba una sola cosa en IL: el llamador construía un newarr y lo rellenaba. C# 13 generalizó params a cualquier tipo de colección, y el caso estrella — params ReadOnlySpan<T> — no asigna absolutamente nada en el heap. El llamador apila los argumentos en un búfer inline-array generado por el compilador y envuelve un span a su alrededor; params List<T> pasa en cambio por un collection builder. La pista para descompilar está enteramente en el sitio de llamada, no en la firma. Aquí está lo que emite cada forma, cómo un descompilador pliega el búfer de vuelta en una llamada simple, y por qué un params ReadOnlySpan<T> que muestra un newarr es una ruta de respaldo fría que merece atención.

Leer →
Glass.NET

Cómo se decompila un switch sobre cadenas en C#

Un switch sobre un entero se compila en una única instrucción switch de IL. Un switch sobre una cadena no puede —no hay tabla de salto para texto—, así que en cuanto tienes más de un puñado de casos el compilador de C# lo reescribe en silencio como un despacho de dos etapas: calcula un hash de la cadena con un ComputeStringHash sintetizado, ramifica según el hash hacia un candidato y luego confirma con un String.Equals ordinal antes de saltar al caso. Esta entrada lee el IL real de un switch grande sobre cadenas, muestra el ayudante FNV <PrivateImplementationDetails>.ComputeStringHash y el segundo switch denso sobre un índice de caso, explica por qué la comprobación de igualdad no es opcional y recorre cómo Glass.NET reconoce toda la forma y la vuelve a plegar en switch (s) { case "...": } en lugar de dejarte una página de constantes hash.

Leer →
Licenciamiento

Cachear la comprobación de firma de licencia sin quedar obsoleta

Una licencia firmada de Keyright se verifica con una comprobación de firma RSA, y esa comprobación cuesta microsegundos reales. Llama a Validate() en cada petición y habrás puesto criptografía de clave pública en tu ruta caliente sin ningún motivo: la firma no ha cambiado desde el arranque. Pero tampoco puedes cachear el resultado para siempre, porque la respuesta depende del tiempo: un entitlement puede expirar a mediodía, un lease puede ser recolectado, una renovación puede ampliar el plan. Esta entrada separa las dos mitades de una comprobación de licencia —la verificación de firma, cara y cacheable, y la evaluación de la licencia en el instante actual, barata y obligatoriamente por llamada—, mide lo que cuesta cada una y muestra una memoización de dos niveles que mantiene la criptografía fuera de la ruta caliente sin devolver jamás una respuesta con un minuto de retraso.

Leer →
Licenciamiento

Derechos como políticas de autorización de ASP.NET Core

La mayoría de las aplicaciones comprueban la licencia una vez al arrancar y dispersan llamadas a IsEnabled por todo el código. En un servicio ASP.NET Core eso es un error: ya tienes un pipeline de autorización construido para responder "¿puede este llamador hacer esto?", y un derecho licenciado es exactamente esa pregunta. Aquí explicamos cómo proyectar los derechos de Keyright sobre el sistema de autorización: un requisito que nombra un derecho, un handler que lee la licencia validada, un proveedor de políticas que las crea bajo demanda y [Authorize(Policy = "ent:export")] en los endpoints que lo necesitan — todo fail-closed, todo sin conexión.

Leer →
Licenciamiento

Activación de licencia sin interfaz para una herramienta CLI .NET

Una herramienta de línea de comandos no tiene pantalla de configuración, a menudo se ejecuta en una máquina en la que no hay nadie sentado y la dirigen scripts que solo leen códigos de salida. Eso rompe el guion del licenciamiento de escritorio — pegar una clave en un diálogo, cachear un lease y seguir adelante. Aquí tienes cómo licenciar una herramienta dotnet o una tarea de compilación con Keyright sin interfaz: un subcomando `license` que activa e informa, los seis lugares en los que el SDK busca una licencia y qué idioma de CLI corresponde a cada uno, un control de acceso fail-closed que nunca pregunta cuando stdin no es un terminal, y el problema del runner de CI efímero resuelto con un archivo de licencia offline transportado en KEYRIGHT_LICENSE en lugar de un asiento por trabajo.

Leer →
Nebula.NET

Por qué las máquinas de estados async sobreviven al renombrado

Abre un ensamblado ofuscado y decompilado y lo más aterrador que ves es un MoveNext lleno de flujo de control aplanado y campos llamados <>1__state. La gente asume que el renombrado debió de romper su código async. No lo hizo —porque cada enlace entre un método async, su tipo de máquina de estados generado y el AsyncTaskMethodBuilder es un token de metadatos, no una búsqueda por nombre, así que renombrar el tipo y sus campos a a y b no cambia nada que el runtime lea—. Pero hay una cosa que un ofuscador descuidado sí puede romper: MoveNext, SetStateMachine, Current y Dispose son métodos de interfaz, y renombrarlos sin reescribir el enlace de interfaz (el MethodImpl) deja al builder llamando a un método que ya no implementa IAsyncStateMachine. Esta entrada lee el rebajado real de un método async y de un iterador, muestra qué nombres son libres y qué enlace debe preservarse, y explica el compromiso del endurecimiento de metadatos: elimina el atributo AsyncStateMachine para una compilación de release y entiende que cuesta depuración paso a paso de async, no corrección.

Leer →
Nebula.NET

Ofuscar atributos personalizados sin romper la reflexión

Un atributo personalizado no es un comentario que el compilador descarta: es una fila de la tabla de metadatos CustomAttribute que apunta, por token, a un constructor, y transporta un blob de argumentos posicionales y con nombre. Esa estructura decide exactamente qué puede tocar la ofuscación y qué no. Renombra la clase del atributo y el GetCustomAttribute<T>() basado en tokens sigue funcionando, porque a los tokens no les importan los nombres; renómbrala y el GetCustomAttributes().First(a => a.GetType().Name == "FeatureGate") basado en cadenas se rompe, porque estaba leyendo un nombre que acabas de borrar. Los argumentos con nombre son la parte sutil: referencian un campo o propiedad por su nombre en forma de cadena dentro del blob, así que un renombrador que mueve uno sin el otro produce un ensamblado que lanza TypeLoadException al cargar. Esta entrada lee los metadatos reales, muestra qué patrones de reflexión sobreviven a un renombrado y cuáles no, y explica cómo Nebula mantiene coherentes los usos de atributos mientras sigue eliminando los nombres que leería un atacante.

Leer →
Nebula.NET

Ofuscar un ensamblado cuyas pruebas aún deben pasar

Renombrar los internos es donde la ofuscación se gana su sitio — pero [InternalsVisibleTo] convierte silenciosamente algunos de esos internos en un contrato. Un proyecto de pruebas, un ensamblado hermano o un mock generado accede a tus tipos internos por nombre, y ese nombre solo existe en tiempo de compilación. Ofusca el productor por sí solo y el amigo deja de compilar o, peor aún, un mock basado en reflexión falla en tiempo de ejecución. Aquí tienes exactamente qué hace [InternalsVisibleTo] en los metadatos, por qué Nebula.NET preserva el caso de un solo ensamblado por ti y cómo mantener en verde un ensamblado amigo genuino ofuscando el par en conjunto.

Leer →
Nebula.NET

Ofuscar código generado por generadores de forma segura

Los generadores de código se ejecutan dentro del compilador y emiten C# ordinario en tu ensamblado, así que el IL que producen es indistinguible del código que escribiste tú. La consecuencia útil para la ofuscación es que los generadores resuelven los nombres en tiempo de compilación: un contexto de System.Text.Json captura "Name" como un literal de cadena y accede a la propiedad a través de un delegado, el enlazador de configuración hace switch sobre claves literales y un GeneratedRegex es pura identidad de tipo. Renómbralo todo y el JSON, las opciones enlazadas y la regex siguen funcionando — a diferencia de sus equivalentes basados en reflexión. Lo que los generadores sí dejan atrás son literales: el patrón de la regex, la plantilla del mensaje de log y un nameof() que graba el nombre original de tu método en un EventId. Aquí tienes qué emite cada generador, qué renombra Nebula.NET de forma segura y qué cifrar o excluir.

Leer →
Licenciamiento

Verificar una misma clave de licencia en cuatro runtimes

Una línea de producto rara vez es un solo lenguaje —una app de escritorio .NET, una CLI de Node, una herramienta de datos en Python, un servicio JVM, todo vendido como un producto—. La respuesta perezosa da a cada uno su propio licenciamiento y deja al cliente haciendo malabares con cuatro claves. La buena: un único tenant firma una licencia con una clave privada RSA, cada componente incrusta la misma clave pública y cuatro SDK verifican offline el formato idéntico de licencia y lease firmados. Esta entrada muestra el mismo flujo de inicializar-validar-restringir en C#, JavaScript, Python y Java en paralelo, explica por qué la huella de máquina es compatible byte a byte entre todos ellos para que un asiento cubra cada componente en una máquina, y cubre las dos cosas que son genuinamente por componente —la caché local del lease y la ruta de resolución de licencia— además de cómo una rotación de clave recorre toda la línea a la vez.

Leer →
Glass.NET

Cómo se decompilan los miembros init-only y required

init y required son dos de las palabras clave más pequeñas de C# y dos de las más fáciles de perder para un decompilador. Un accesor init no es más que un accesor set cuya firma lleva un modificador requerido —modreq(IsExternalInit)— y un decompilador que no mira el modificador lo muestra como un set ordinario, entregándote en silencio un tipo cuyas propiedades pueden reasignarse tras la construcción. required es peor: son tres atributos distintos trabajando juntos —RequiredMemberAttribute en cada miembro, RequiredMemberAttribute en el tipo y CompilerFeatureRequired en el tipo— más un SetsRequiredMembers en cualquier constructor que los satisfaga, y un decompilador que los descarta produce código cuyos llamadores ya no están obligados a asignar nada. Esta entrada lee el IL y los metadatos de ambas funcionalidades, muestra la forma exacta a nivel de byte del modreq y de los blobs de atributos, recorre cómo Glass.NET reconstruye init, required y [SetsRequiredMembers], y explica por qué saltarse el paso cambia en silencio el contrato público de un tipo.

Leer →
Glass.NET

Cómo se decompilan las sobrecargas de operadores en C#

Un operador definido por el usuario es un método estático con un nombre reservado y la marca specialname —op_Addition, op_Implicit, op_Equality— y mapearlo de vuelta a una declaración de operador parece una búsqueda en una tabla. Tres cosas lo hacen más difícil que la tabla. Las conversiones definidas por el usuario pueden sobrecargarse solo por tipo de retorno, lo que es IL legal y C# ilegal: dos métodos op_Explicit con parámetros idénticos difieren solo en lo que devuelven, así que un decompilador que los emite como métodos ordinarios produce código fuente que no puede compilar. C# 11 añadió operadores checked —op_CheckedAddition, op_CheckedExplicit— que deben renderizarse con la palabra clave checked y emparejarse con su gemelo unchecked, o cada sitio de llamada checked(a + b) se decompila como una llamada a método. Y op_True/op_False, op_Increment y los operadores de asignación compuesta de instancia de C# 14 compilan cada uno a patrones de llamada que hay que plegar de vuelta a sintaxis en lugar de mostrarlos como invocaciones. Esta entrada lee el IL de cada uno, muestra los sitios de llamada que guían la reconstrucción, y recorre cómo Glass.NET los convierte de nuevo en los operadores que el autor escribió.

Leer →
Glass.NET

Cómo se decompilan las ref struct de C# 11 en IL

Un campo ref es la primera vez que un campo de C# almacena una referencia en lugar de un valor, y se compila a metadatos que los decompiladores anteriores nunca tuvieron que leer. La firma del campo lleva un tipo de elemento byref —ELEMENT_TYPE_BYREF dentro de una firma FIELD, que era ilegal antes de .NET 7— y las reglas de seguridad ref que impiden que sobreviva a aquello a lo que apunta están codificadas en modreq y atributos, no en IL que puedas ejecutar. scoped es la más ruidosa de ellas: es un ScopedRefAttribute sobre un parámetro, sin efecto alguno en tiempo de ejecución, que un decompilador o bien muestra como la palabra clave scoped o bien descarta, cambiando en silencio el contrato de seguridad ref del método. Esta entrada lee las firmas en crudo y los blobs de atributos de un campo ref, de una ref struct que contiene uno, y de un parámetro scoped ref, muestra dónde viven en los metadatos las reglas de escape de ref, y recorre cómo Glass.NET reconstruye ref, ref readonly, scoped y la salida de emergencia [UnscopedRef] para que el código fuente decompilado compile con la misma seguridad que escribió el autor.

Leer →
Decompilación

Cómo se decompila el nuevo lock de C#

Durante veinte años, lock (obj) se reducía a Monitor.Enter/Exit con un indicador lockTaken. C# 13 lo cambió: un lock sobre un System.Threading.Lock se reduce a EnterScope() y a un ref struct Scope que se libera en un finally, una forma de IL completamente distinta. Aquí explicamos exactamente qué genera cada forma, cómo un decompilador las distingue y pliega ambas de vuelta a lock, y la única pista en la decompilación que delata un error silencioso: un Lock convertido a object que recae discretamente en Monitor.

Leer →
Keyright

Detectar activaciones duplicadas cuando se clona una VM

Una huella de equipo identifica un equipo — y una VM clonada es, por construcción, el mismo equipo dos veces. La restauración de instantáneas, las imágenes maestras y las instancias autoescaladas reproducen exactamente los atributos de hardware y de sistema operativo que un bloqueo por equipo resume en un hash, así que dos copias en ejecución presentan una huella idéntica y el bloqueo por equipo no puede distinguirlas. La solución no es una huella mejor; es una identidad de activación que posee el servidor más un nonce de instancia por ejecución que el cliente no puede clonar de forma útil, de modo que dos copias de una activación se delatan en cuanto ambas llaman a casa. Esta entrada lee el SDK y la política del servidor para exactamente eso: por qué se derrota la huella, cómo un registro de activación y un id de instancia de ejecución separan una migración legítima de un clon en vivo, y cómo Keyright decide entre "gana el más nuevo" y "marcar y retener" sin bloquear a un cliente que simplemente se mudó.

Leer →
Licenciamiento

Caducidad por derecho con Keyright

Una licencia suele tener una única fecha de caducidad, pero los contratos reales rara vez la tienen: un plan base se renueva anualmente mientras un complemento de prueba dura 30 días y una característica promocional termina con el trimestre. Fijar una sola fecha para toda la licencia te obliga a conceder de más o a reemitir constantemente. Aquí explicamos cómo dar a cada derecho su propia caducidad dentro de una única licencia Keyright firmada: la forma del payload, el SDK que lee un reloj por característica sin conexión, cómo aplicarlo en el límite de la capacidad y las reglas de gracia que evitan que un complemento caducado tumbe toda la aplicación.

Leer →
Keyright

Desactivar una licencia y trasladarla a una máquina nueva

Liberar un puesto parece la mitad fácil del bloqueo por equipo: el cliente pulsa "desactivar este dispositivo" y el puesto vuelve a estar disponible. Pero una desactivación es una afirmación que el cliente hace sobre su propio estado, y el cliente es la única parte en la que no puedes confiar. En línea, el problema es el orden y los reintentos: liberar en el servidor antes o después de borrar localmente, y qué pasa cuando una de las dos cosas falla. Sin conexión, el problema es la prueba: un equipo sin red tiene que entregar al cliente algo que convenza al servidor de que un puesto se ha cedido de verdad. Y para los equipos muertos —el portátil que cayó al lago— el problema es el abuso: cada liberación forzada es una oportunidad para multiplicar puestos. Esta entrada lee el SDK y la política del servidor de Keyright para los tres casos: la liberación en línea idempotente, el recibo de desactivación con HMAC ligado al secreto de instancia de la activación, por qué el TTL del arrendamiento acota lo que puede ganar un cliente mentiroso, y el enfriamiento de transferencias y los límites móviles que impiden que "he perdido mi equipo" se convierta en un generador de puestos.

Leer →
Licenciamiento

Desplegar la aplicación de licencias primero en modo auditoría

El despliegue más temible de cualquier proyecto de licenciamiento es el que pasa la aplicación de off a on. Hasta ese momento la puerta nunca le ha dicho que no a nadie; en cuanto lo hace, cada clave mal aprovisionada, cada reloj que va un día desfasado, cada cliente que activó tras un proxy que no previste se convierte en un ticket de soporte, todos a la vez, en producción. Esta entrada muestra cómo evitar el corte de golpe con el modo auditoría: una puerta que evalúa la licencia exactamente como lo hará en modo aplicación, registra la decisión que habría tomado y luego deja pasar la llamada de todos modos. La ejecutas sobre toda tu base instalada, lees la población que se habría bloqueado, corriges los datos y solo entonces pasas a aplicar, por cohortes, guiado por un modo que la licencia firmada transporta para que ningún cliente pueda apagarlo. Con un registro de decisión, un enum de modo de aplicación que el payload firma, un despliegue escalonado y las métricas que te dicen que es seguro bloquear.

Leer →
Nebula.NET

Ofuscar una aplicación Avalonia sin romper los enlaces

Avalonia no es WPF con otro logotipo, y la diferencia importa en el momento en que lo ofuscas. Avalonia compila tu .axaml a IL en tiempo de compilación, así que un enlace compilado es un accesor de propiedad tipado que referencia el getter por token de metadatos —sobrevive intacto a un renombrado completo— mientras que un enlace por reflexión es una cadena que el runtime resuelve por nombre y que vuelve vacía en silencio. Lo que se rompe primero no es ninguno de los dos: es el ViewLocator de la plantilla MVVM por defecto, que encuentra una vista tomando el nombre del tipo del view model, sustituyendo "ViewModel" por "View" y llamando a Type.GetType — una convención que un renombrado convierte en un TextBlock de "Not Found" o en una InvalidCastException. Esta entrada lee lo que el compilador de XAML emite realmente para un enlace compilado, muestra por qué INotifyPropertyChanged sigue coincidiendo tras el renombrado, recorre los dos tipos generados por Avalonia que el runtime localiza con Assembly.GetType por sus nombres literales, y da la configuración de Nebula y el mapeo de vistas basado en DataTemplate que te permiten aplanar toda la aplicación sin tocar las partes que Avalonia resuelve por nombre.

Leer →
Nebula.NET

Ofuscar un servicio gRPC sin romper el protocolo en el cable

gRPC pone dos clases de nombres en tu ensamblado, y la ofuscación tiene que tratarlas como opuestas. Los nombres que viajan por el cable —la ruta del servicio, la ruta del método, los números de campo de un mensaje protobuf— son un contrato del que depende cada par, y renombrarlos rompe la interoperabilidad tan seguro como cambiar una URL. Los nombres que nunca salen del proceso —tus nombres de método C#, los nombres de propiedad de tus mensajes, tus registros de DI— son libres de desaparecer. La trampa es que de qué clase es un nombre dado depende por completo de si fuiste contract-first con protoc o code-first con protobuf-net.Grpc, porque code-first deriva la identidad del cable de tus nombres .NET por reflexión, convirtiendo los nombres libres de nuevo en nombres portadores. Esta entrada lee el código generado y los metadatos para mostrar exactamente dónde vive la identidad del cable en cada estilo, por qué los números de campo de protobuf hacen que los miembros de los mensajes sean seguros de renombrar, y cómo Nebula fija la superficie del contrato mientras renombra todo lo que hay detrás.

Leer →
Nebula.NET

Ofuscar un host de plugins sin romper los plugins

Un host de plugins tiene una personalidad dividida que la ofuscación debe respetar con exactitud. El ensamblado de contrato —las interfaces, las clases base abstractas y los atributos contra los que compilan los plugins de terceros— es una ABI publicada: renombra un miembro suyo y todo plugin ya distribuido contra los nombres antiguos falla al enlazar, igual que renombrar una API pública rompe a quienes la llaman. Pero el host que carga esos plugins es tu código más valioso y lo que más quieres renombrar. Los dos viven en una sola solución y una pasada de ofuscación corriente no puede distinguirlos. Esta entrada lee los puntos de enlace exactos —los nombres de tipo de interfaz y de método que un AssemblyLoadContext resuelve al cargar, los nombres de contrato [Export]/[Import] que MEF empareja, y los nombres de tipo de atributo que un host escanea—, muestra por qué cada uno está en la ABI y debe sobrevivir, y cómo Nebula fija la superficie del contrato por su forma mientras aplana el host detrás de ella.

Leer →
Nebula.NET

Ofuscar una aplicación WinForms sin perder recursos

WinForms tiene una trampa que WPF no tiene: el diseñador vincula cada formulario a un flujo .resources incrustado cuyo nombre se deriva del nombre completo del tipo del formulario, y enlaza los controles a los datos mediante cadenas con el nombre de la propiedad. Renombra lo que no debes y tus iconos desaparecen o un campo enlazado se queda en blanco, en tiempo de ejecución y sin ningún error de compilación. Aquí explicamos exactamente qué emite el diseñador, por qué renombrar un tipo Form rompe ComponentResourceManager y cómo proteger una compilación WinForms con Nebula.NET para que los internos queden endurecidos y el diseñador siga funcionando.

Leer →
Glass.NET

Cómo se decompilan los punteros a función en C#

Un delegate* no es un delegado: no hay objeto, no hay método Invoke, no hay asignación de memoria. Compila a una dirección de código en crudo apilada en la pila y a una instrucción calli que llama a través de ella. Así que un decompilador no tiene nada en lo que apoyarse: ni nombre de tipo, ni método que seguir, solo una llamada indirecta y una firma independiente que debe leer para conocer los tipos de los argumentos y la convención de llamada. Y la convención —gestionada, Cdecl, Stdcall, Thiscall— no es una palabra clave en el IL; se codifica como tipos modopt atornillados a la firma. Aquí tienes exactamente cómo se dispone un puntero a función, cómo calli nombra su propia firma, dónde vive realmente la convención no gestionada y cómo Glass.NET reconstruye el delegate* que escribiste.

Leer →
Glass.NET

Cómo se decompilan los inline arrays y stackalloc de C# 12

Los inline arrays de C# 12 te dan un búfer de tamaño fijo, de tipo valor, que vive en línea dentro de su struct contenedor —lo que C llamaba `int buf[8]`—, pero en IL es un struct de un solo campo decorado con [InlineArray(8)], accedido mediante intrínsecos del runtime y Span<T> en vez de cualquier instrucción de array. stackalloc, por su parte, compila a un localloc crudo que un decompilador ingenuo muestra como un puntero y un montón de opcodes stind. Equivócate en cualquiera de los dos y el decompilador emite aritmética de punteros unsafe donde la fuente tenía un indexador limpio, o inventa un array que nunca se asignó. Aquí tienes exactamente qué emite el compilador para un tipo [InlineArray], cómo el acceso a elementos baja a un helper de PrivateImplementationDetails sobre un Span, cómo se ven localloc y el constructor Span(void*, int) en IL, y cómo Glass.NET los lee de vuelta a las declaraciones de inline array y las expresiones stackalloc que realmente escribiste.

Leer →
Glass.NET

Dónde viven los tipos de referencia anulables en los metadatos

string y string? son el mismo tipo para el runtime —System.String, una sola TypeRef, ninguna diferencia en ninguna firma—. El signo de interrogación existe solo en tiempo de compilación, y el compilador tiene que colarlo en el ensamblado en algún sitio para que los consumidores de tu biblioteca reciban las advertencias correctas. Lo hace con dos atributos embebidos, NullableAttribute y NullableContextAttribute, un vocabulario de tres valores en bytes, un aplanamiento en preorden de árboles de tipos genéricos a arrays de bytes, y un esquema de compresión agresivo que omite lo que coincide con el valor por defecto del ámbito. Esta entrada lee esos bytes directamente del IL, muestra la codificación exacta del blob para las formas de un byte y de array, recorre cómo un decompilador reconstruye ?, notnull y class? a partir de ellos, y explica por qué saltarse este paso cambia silenciosamente el contrato público de una biblioteca.

Leer →
Glass.NET

Cómo se decompilan los miembros de interfaz estáticos abstractos

C# 11 dejó que las interfaces declararan miembros estáticos abstractos, y la BCL lo usó para construir la matemática genérica: escribe Sum<T>(span) una vez y corre sobre int, double o tu propio tipo. Pero la característica se apoya en un rincón de la especificación ECMA que la mayoría de descompiladores nunca tuvo que manejar: una llamada constrained a un método de interfaz *estático*, resuelta al argumento de tipo en tiempo de ejecución. Si se hace mal, el descompilador emite una llamada a un método que parece no tener receptor, o inventa un cast que no está. Esto es exactamente lo que el compilador emite para T.Zero y a + b sobre una restricción genérica, por qué el prefijo constrained. sobre una llamada estática no virtual es todo el truco, y cómo Glass.NET lo lee de vuelta en los operadores y miembros estáticos que de verdad escribiste.

Leer →
Nebula.NET

Cifrar recursos incrustados: los datos que tu ofuscador olvida

Renombraste cada tipo, cifraste cada cadena y virtualizaste los métodos calientes, y luego alguien abrió tu ensamblado en un visor de recursos y leyó tu SQL incrustado, tu material de claves de licenciamiento y el texto completo de tus mensajes de error directamente del blob .resources. Los recursos gestionados no son código, así que la protección a nivel de método nunca los toca; se sientan en el manifiesto como valores con prefijo de longitud que cualquiera puede volcar. Así se almacenan realmente los recursos incrustados en un PE, por qué el renombrado los deja intactos, y cómo Nebula los cifra en tiempo de compilación y los descifra de forma transparente a través de un resolver para que tus llamadas a ResourceManager y GetManifestResourceStream sigan funcionando sin cambios.

Leer →
Licenciamiento

Latidos de licencia y recolección de leases para asientos concurrentes

Una licencia flotante vende N asientos compartidos por un equipo, así que el servidor tiene que saber cuántos están en uso *ahora mismo*. Es fácil hasta que un cliente muere de la forma incorrecta —una caída, una VM eliminada, un cable de red arrancado— y nunca devuelve su asiento. Lleva la cuenta en el checkout y el asiento queda perdido para siempre; tu cliente paga por diez y puede ejecutar seis. La solución es dejar de confiar en checkout/checkin como un par emparejado y tratar cada asiento como un contrato (lease) con un tiempo de vida que el cliente debe mantener con latidos. Aquí tienes el protocolo de contrato y latido en Keyright: el contrato firmado de TTL corto, el bucle de renovación en el cliente, el recolector (reaper) que reclama asientos muertos en el servidor, y las reglas de reloj y gracia que mantienen la cuenta honesta sin castigar una red inestable.

Leer →
Licenciamiento

Versionar el payload de tu licencia sin romper a los clientes

Una licencia firmada es un conjunto de claims congelados en bytes, y en el momento en que publicas un cliente que los lee, esa disposición de bytes se convierte en un contrato que no puedes cambiar unilateralmente. Entonces producto pide un claim nuevo —un tope de asientos, un bloqueo regional, una lista de funcionalidades— y descubres que la mitad de tu base instalada ejecuta un parser que nunca lo ha visto. Esta entrada recorre cómo evolucionan de forma segura los payloads de licencia al estilo Keyright: una versión de esquema cubierta por la firma, un parseo de mundo abierto que mantiene verificables los claims desconocidos, una lista de claims críticos para que un cliente antiguo rechace lo que no puede aplicar en lugar de ignorarlo en silencio, negociación de esquema en la activación para que el lado emisor nunca emita lo que un cliente no puede leer, y las pruebas con ficheros dorados que impiden que un cambio de formato llegue a producción sin que nadie lo note.

Leer →
Licenciamiento

Vincular licencias a una persona, no a una máquina

La vinculación a máquina responde a "¿qué ordenador es este?", pero muchos productos se venden por *asiento*, no por caja. Un desarrollador con un portátil, un equipo de escritorio y un runner de CI es un usuario de pago, no tres activaciones. El licenciamiento por usuario nombrado cambia el ancla: la licencia pertenece a una identidad, y los dispositivos cuelgan de ella como hojas bajo un límite que tú controlas. Aquí tienes cómo modelar un derecho de identidad firmado en Keyright, canjear un inicio de sesión por un contrato (lease) de corta duración acotado al dispositivo, imponer un límite de dispositivos sin atar al usuario a una sola caja, y permitir que un usuario retire un dispositivo de un asiento lleno, con el C# real para emitirlo, vincularlo y verificarlo.

Leer →
Nebula.NET

Las funciones de .NET que filtran tus miembros renombrados

Renombraste cada tipo y método, luego abriste el binario ofuscado y encontraste tus nombres originales en literales de cadena a la vista. El culpable no es un error del ofuscador: es el compilador. nameof(OrderService) incrusta el literal "OrderService" en el IL en tiempo de compilación, mucho antes de que se ejecute el renombrado, y [CallerMemberName] hace lo mismo con el nombre original del método como valor por defecto de un parámetro. Renombra el miembro y el literal sigue diciendo el nombre antiguo, así que un decompilador lee tu mapa gratis y cualquier reflexión que esperase el nombre en tiempo de ejecución se rompe en silencio. Aquí tienes exactamente de dónde salen estos literales en el IL, por qué el renombrado no puede tocarlos por sí solo, y cómo el cifrado de cadenas y el manejo consciente del renombrado de Nebula.NET cierran la fuga.

Leer →
Nebula.NET

Ofuscar una app ASP.NET Core sin romperla

ASP.NET Core encuentra casi todo por su nombre en tiempo de ejecución: los tipos de controlador por su sufijo, las acciones por el nombre del método, las rutas desde los tokens [controller] y [action], los parámetros de query y de formulario por los nombres de parámetro, las propiedades JSON por los nombres de propiedad, los métodos de hub por cadenas, las clases de opciones por las claves de configuración. Renombra cualquiera de ellos y la app sigue compilando, sigue arrancando y devuelve 404 o un DTO vacío. Esta entrada cartografía cada costura dirigida por reflexión de una app ASP.NET Core —MVC, Minimal APIs, vistas y tag helpers de Razor, SignalR, el patrón options, servicios alojados—, muestra cómo se ve realmente la metadata renombrada, y construye un nebula.config.json que renombra y endurece los servicios y el dominio mientras fija exactamente la superficie que el framework observa.

Leer →
Nebula.NET

Ofuscar código P/Invoke sin romper la interoperabilidad

El renombrado es la columna vertebral de la ofuscación, y se rompe exactamente donde tu código gestionado deja de ser autónomo: en la frontera con el código nativo. Un método [DllImport], un delegado que marshalizas a un puntero de función, un struct que vuelcas a través de la frontera: cada uno lleva un nombre o una disposición de la que algo externo al CLR depende, y renómbralo a ciegas y la llamada falla en tiempo de ejecución con un MarshalDirectiveException o un struct corrompido en silencio. Por eso la interop nativa solo sobrevive a la ofuscación cuando la herramienta entiende el marshaller: qué nombres son portantes, por qué EntryPoint desacopla el nombre gestionado del nativo, cómo deben preservarse el orden de campos y StructLayout, y cómo Nebula renombra todo alrededor de la frontera dejando la frontera misma intacta.

Leer →
Licenciamiento

Almacenar de forma segura una licencia activada en el cliente

La activación entrega al cliente un contrato (lease) firmado; luego llega la pregunta que nadie planifica: ¿dónde lo guardas? Déjalo en un archivo plano y un usuario edita la caducidad; cífralo mal y habrás atado la aplicación a una sola máquina por accidente. La caché sirve para la disponibilidad, no para la autenticidad: la firma sigue decidiendo si un contrato es real, así que el almacén solo tiene tres tareas: sobrevivir a un reinicio, resistir la edición casual y rechazar un contrato copiado desde otra máquina. Aquí tienes cómo sellar un contrato en caché con DPAPI donde exista, vincularlo al dispositivo con un HMAC para detectar una caché editada o trasplantada, y por qué nunca debes confiar en la caducidad en caché por encima de la firmada.

Leer →
Glass.NET

Cómo se decompila la palabra clave dynamic

Una línea de C# con dynamic se compila en un call site cacheado, un binder, un array de flags de información de argumentos y una invocación a través de un campo delegado: una docena de miembros de andamiaje generado para una sola llamada a método. Esto es lo que el compilador emite realmente para el despacho dynamic, cómo un decompilador ingenuo te muestra la maquinaria CallSite en crudo y cómo Glass.NET reconoce el patrón y te devuelve la única línea que escribiste.

Leer →
Glass.NET

Cómo se decompilan las funciones locales en C#

Una función local no es una lambda, y el compilador lo demuestra en el IL. No hay asignación de delegado ni clase de cierre: una función local que no captura nada se convierte en un método estático normal con un nombre con mangling como <Run>g__Add|0_0, y una que captura se convierte en un método que recibe sus variables capturadas por ref en un struct de visualización de tipo valor, así que nada aterriza en el heap. Aquí está exactamente qué emite el compilador de C# para ambos tipos, cómo un decompilador que no reconoce el patrón te entrega el método con mangling y el struct ref, y cómo Glass.NET lo repliega a la función local que escribiste.

Leer →
Glass.NET

Leer un manejador de cadenas interpoladas de vuelta al código

El C# moderno ya no compila $"Hello {name}" a string.Format: lo reduce a un DefaultInterpolatedStringHandler con llamadas a AppendLiteral y AppendFormatted. Aquí tienes exactamente cómo se ve eso en IL, cómo Glass.NET reconoce la secuencia por patrones para reconstruir una cadena interpolada con su formato y alineación intactos, y el único caso en el que honestamente no puede.

Leer →
Glass.NET

Dónde viven los nombres de elementos de tupla en los metadatos

Una ValueTuple no tiene un campo llamado count ni name: son Item1 e Item2, y el sistema de tipos no sabe nada de tus nombres. Los nombres que escribiste viven en un atributo [TupleElementNames] que el compilador adjunta a la firma del método, al campo o a la propiedad, como un array de cadenas con null en las posiciones sin nombre. Un decompilador que ignora ese atributo te entrega Item1/Item2; uno que lo lee restaura (int count, string name). Aquí tienes exactamente cómo se codifican los nombres de tupla, por qué sobreviven en las firmas pero desaparecen en las variables locales, y cómo Glass.NET los vuelve a poner.

Leer →
Licenciamiento

Licenciar contenedores y servicios .NET con autoescalado usando Keyright

El licenciamiento ligado a la máquina da por hecho que hay una máquina: un equipo estable con una huella a la que asignar un asiento. Un contenedor no tiene nada de eso: la imagen es idéntica en todas las réplicas, el host es efímero y un autoescalador crea y destruye instancias más rápido de lo que cualquier flujo de activación puede seguir. Aquí tienes cómo licenciar un servicio .NET escalado horizontalmente con Keyright: activar una sola vez en el límite del despliegue, enviar una licencia firmada a cada réplica, validar sin conexión sin llamadas por instancia y decidir de antemano si un asiento significa un despliegue o una instancia en ejecución.

Leer →
Licenciamiento

Diseñar una puerta de licencia que falle cerrada

Una sola llamada a Validate() es la parte fácil del licenciamiento. La parte difícil es la arquitectura: en qué lugar de tu app vive la comprobación, con qué frecuencia se ejecuta, qué cacheas entre ejecuciones y —la pregunta que decide si un bug deja fuera a un cliente que paga o regala tu software— qué fallos fallan cerrado y cuáles fallan abierto. Aquí tienes una compuerta de licencia a prueba de fallos para .NET construida sobre Keyright, con una tabla de decisión estado por estado y una instantánea cacheada que sobrevive sin conexión.

Leer →
Licenciamiento

Cómo una licencia decide qué versiones puede ejecutar

Una licencia perpetua es para siempre; "un año de actualizaciones" no lo es, y ambas conviven en la misma clave. La cobertura de versiones es la forma en que una licencia declara qué versiones tiene derecho a ejecutar, como concesiones firmadas de rango de versión y de ventana temporal que la compilación comprueba localmente, sin conexión y sin reactivación. Aquí tienes cómo se da forma a una concesión de cobertura, cómo la fecha de derecho (no la de instalación) decide un parche, cómo el bloque firmado viaja junto al lease y cómo tu compilación lo exige sin una sola llamada de red en la ruta crítica.

Leer →
Nebula.NET

Ofuscar una app de EF Core sin romper la capa de datos

EF Core asigna tus tipos CLR a tablas por sus nombres. Renombra una entidad o una propiedad con un ofuscador y, por defecto, el esquema que EF espera se mueve con ellos: tu DbContext ahora busca una tabla llamada "a" con una columna "c", las migraciones dejan de coincidir y el acceso a propiedades basado en cadenas lanza en tiempo de ejecución. La solución no es excluir toda tu capa de datos de la ofuscación. Es entender exactamente qué nombres lee EF en tiempo de ejecución, hacer explícito tu mapeo para desacoplar el esquema de los nombres CLR y luego dejar que Nebula.NET renombre los miembros libremente. Aquí está el panorama completo, con las reglas de renombrado y los patrones de EF que lo hacen seguro.

Leer →
Nebula.NET

Ofuscar un ensamblado multi-target con una sola configuración

Una biblioteca que apunta a net48;net8.0 se compila en dos ensamblados distintos, con dos conjuntos de referencias distintos y a veces dos conjuntos de IL distintos. Proteger solo uno de ellos es distribuir un build sin ofuscar. Así es como Nebula.NET trata cada target framework como su propia ejecución de ofuscación compartiendo una única política, y las trampas por TFM que muerden si no lo haces.

Leer →
Nebula.NET

Volver a firmar un ensamblado .NET tras la ofuscación

El renombrado reescribe tu ensamblado, lo que invalida el nombre fuerte y la firma Authenticode con los que se compiló: una build protegida que se envía sin firmar, o peor, con una firma ya rota, no cargará o no verificará. Nebula.NET vuelve a firmar por ti como último paso de la canalización: una nueva firma de nombre fuerte sobre la imagen ofuscada, tokens de clave pública entre ensamblados reescritos para que los ensamblados interdependientes sigan resolviéndose, y luego una firma Authenticode encima. Aquí tienes el orden exacto, cómo entregar la clave a un servidor de compilación sin incluirla en el repositorio y qué rompe InternalsVisibleTo si lo olvidas.

Leer →
Nebula.NET

Mantener estables los nombres ofuscados entre versiones

Por defecto, cada ejecución de ofuscación renombra desde cero, así que un método que era "a" en 1.4.0 pasa a ser "q" en 1.4.1 y cada mapa de desofuscación archivado se pudre en el momento en que publicas. El seedMapFile de Nebula.NET fija la salida en su sitio: los miembros sin cambios conservan el nombre ofuscado que tenían en la versión anterior y solo el código nuevo recibe nombres nuevos. Así funciona el mapa de símbolos, por qué los nombres estables hacen tratables la simbolización de crashes y los diffs binarios, y cómo integrar la ofuscación incremental en CI.

Leer →
Licenciamiento

Probar el código que vive detrás de una comprobación de licencia

Tus funciones de pago están detrás de una puerta de licencia, pero ¿cómo las pruebas sin un servicio emisor en vivo, una clave real o el reloj del sistema? Aquí tienes una estrategia en dos capas para Keyright: una costura fina que simulas para pruebas unitarias rápidas, y un puñado de fixtures firmados con una clave de prueba y versionados en el repositorio que ejercitan la ruta real de verificación del SDK, totalmente sin conexión y de forma determinista en CI.

Leer →
Glass.NET

Convertir una DLL de nuevo en un proyecto compilable con Glass.NET

Leer C# decompilado en una ventana es una cosa; obtener un .csproj que puedes abrir, grepear, refactorizar y compilar es otra. Aquí está cómo la exportación de proyecto de Glass.NET reconstruye un ensamblado entero —fuente, referencias, recursos—, qué maneja limpiamente, dónde el código generado por el compilador necesita una mano, y cómo scriptarlo desde la CLI.

Leer →
Licenciamiento

Rotar las claves de firma de licencias sin dejar fuera a los clientes

Tus claves de licencia y tus leases valen tanto como la clave que las firma. Así se rota esa clave de firma a una nueva sin interrupciones: confianza solapada con AdditionalPublicKeysBase64, un despliegue por fases, y cómo los leases y los archivos sin conexión hacen segura la transición.

Leer →
Nebula.NET

Saber cuándo atacan una compilación .NET protegida

Los guardias anti-tamper y anti-debug reaccionan en la máquina del usuario, pero nunca te enteras de que se dispararon. El report-home de Nebula.NET (tamperReportUrl, Pro) hace POST de un evento mínimo a tu propio endpoint en cuanto un guardia salta, así que un ataque a una compilación distribuida se convierte en una señal sobre la que puedes actuar. Aquí está cómo funciona y cómo construir el receptor.

Leer →
Keyright

Por qué las firmas de licencia necesitan firma canónica

Una firma se calcula sobre bytes, no sobre campos — así que si tu servicio emisor y tu cliente serializan el payload de la licencia aunque sea de forma ligeramente distinta, la verificación falla en una licencia perfectamente genuina. Así se canonicaliza un payload una sola vez (orden de campos estable, formato invariante de números y fechas, UTF-8, base64url) para que una misma firma verifique de forma idéntica en .NET, Node, Python y Java.

Leer →
Glass.NET

Decompilar expresiones de colección y constructores primarios

Las expresiones de colección y los constructores primarios parecen ideas sintácticas únicas, pero el compilador los reduce a IL muy distinto según el tipo de destino y según si un parámetro se captura. Aquí tienes exactamente qué emiten `[1, 2, 3]`, los spreads y un constructor primario, y dónde un decompilador puede replegar el azúcar frente a dónde solo puede mostrar la forma reducida.

Leer →
Nebula.NET

Ofuscar aplicaciones .NET con Native AOT y de archivo único

Publicar como archivo único o con Native AOT es empaquetado y compilación, no protección. Esto es lo que cada modo hace realmente con tu código, por qué las aplicaciones de archivo único siguen distribuyendo IL gestionado totalmente recuperable, qué oculta y qué no oculta Native AOT, y por qué la ofuscación debe ejecutarse sobre el IL antes de que se construya el paquete o el compilador AOT lo elimine.

Leer →
.NET

Endurecer automáticamente tus comprobaciones de licencia

El método que verifica tu licencia es el objetivo de mayor valor de toda tu app — vúlneralo y todo lo demás es irrelevante. Nebula.NET puede encontrar los métodos que llaman a tu SDK de licenciamiento y aplicar automáticamente la protección más fuerte que permita tu edición exactamente a esos métodos, de modo que la puerta queda endurecida sin que la enumeres a mano. Esto es cómo funciona la auto-protección.

Leer →
Decompilación

Cuando await y yield comparten una máquina de estados

Un método async IAsyncEnumerable mezcla await y yield return — así que el compilador genera una única máquina de estado que es a la vez una máquina de estado async y un iterador. Aquí tienes la forma a la que se reduce, cómo el campo de estado impulsa tanto las reanudaciones de await como los puntos de yield, y cómo un decompilador reconoce el patrón para reconstruir await foreach.

Leer →
Decompilación

Decompilar el pattern matching y las expresiones switch de C#

Una expresión switch no es una construcción en IL: se reduce a una cadena de comprobaciones de tipo, comprobaciones de null y saltos, que termina lanzando una SwitchExpressionException para el caso no cubierto. Esto es exactamente lo que el compilador emite para los patrones de tipo, de propiedad, relacionales y lógicos, y cómo un decompilador recupera la forma hasta un switch.

Leer →
Decompilación

Cómo se decompila una instrucción using en C#

Una sentencia using no tiene IL propio — el compilador la reduce a un try/finally que llama a Dispose, y await using a un try/finally que espera DisposeAsync. Aquí tienes exactamente qué aspecto tiene ese código generado, las sutilezas del null-check y del enumerador struct, y cómo un decompilador lo pliega de vuelta en using.

Leer →
Ofuscación

Lo que la ofuscación .NET te cuesta en tiempo de ejecución

No toda la protección de .NET tiene el mismo coste en tiempo de ejecución. El renombrado es gratis; el cifrado de cadenas y constantes añade una diminuta decodificación por uso; el aplanado del flujo de control añade sobrecarga de despacho; el cifrado de métodos y la virtualización son pesados por llamada. Aquí tienes el modelo de coste honesto de cada transformación y cómo acotar la protección para defender lo que importa sin frenar una ruta caliente.

Leer →
Licenciamiento

Qué debe hacer tu app cuando el servidor de licencias está caído

Una comprobación de licencia que falla en seco en cuanto el servidor es inalcanzable convierte tu caída — o el Wi-Fi inestable del cliente — en la caída de ellos. Aquí tienes cómo diseñar ventanas de gracia, elegir fail-open vs fail-closed por nivel, y evitar que un corte de red pasajero deje fuera a clientes que pagan.

Leer →
.NET

Ofuscación de referencias en .NET: ocultar el grafo de llamadas

Renombra todo y un decompilador aún leerá tu intención a partir de las llamadas que haces: File.ReadAllText, RSA.Create, tu propio CheckLicense. La ofuscación de referencias (llamadas por proxy) enruta esas llamadas a través de proxies generados para que el sitio de llamada ya no nombre su destino. Aquí tienes cómo funciona en IL, qué derrota y qué cuesta.

Leer →
Licenciamiento

Cómo probar la integración de licenciamiento de tu software

Los errores de licenciamiento llegan a producción porque el único camino que alguien ejerce es «clave válida, servidor arriba, reloj correcto». Aquí tienes cómo poner la caducidad, la revocación, la gracia sin conexión y los límites de puestos bajo pruebas automatizadas: inyecta el reloj, falsea el cliente de licencias y dirige cada caso límite desde xUnit para que CI detecte los bloqueos antes que tus clientes.

Leer →
.NET

Publicar una demo con tiempo limitado de tu app .NET

A veces quieres una compilación que simplemente deje de funcionar tras una fecha: una demo de una conferencia, una copia de evaluación, una preliminar que no debe ejecutarse en producción para siempre. Nebula.NET puede incorporar una caducidad en el propio ensamblado, aplicada desde un inicializador de módulo antes de que se ejecute tu código, con la reacción que elijas. Esto es cómo funciona y cuándo usarla en vez del licenciamiento con servidor.

Leer →
Licenciamiento

Anatomía de una clave de licencia firmada: por qué no se puede falsificar

Una buena clave de licencia no es una cadena aleatoria cotejada contra una lista — es un payload de claims firmado que la app puede verificar sin conexión con una clave pública que distribuye. Aquí tienes qué vive dentro de una clave firmada, por qué la división privada/pública la hace infalsificable, cómo funciona la verificación sin servidor, y qué protege y qué no la firma.

Leer →
Ofuscación

Marcar al agua ensamblados .NET para rastrear quién filtró una build

La ofuscación impide que un lector entienda tu código; no hace nada por decirte qué cliente lo filtró. Una marca de agua por licenciatario sí — un marcador único y encubierto horneado en cada build que sobrevive a la copia casual y mapea un ensamblado filtrado de vuelta a la cuenta a la que se emitió. Aquí tienes qué debe ser una buena marca de agua, dónde vive, y cómo complementa a la ofuscación y al licenciamiento.

Leer →
Ofuscación

Ocultar las constantes que los decompiladores leen en .NET

El cifrado de cadenas se lleva la atención, pero los literales numéricos de tu código — umbrales, opcodes, números mágicos, desplazamientos — compilan a instrucciones ldc que un decompilador lee al instante. Aquí tienes cómo las constantes numéricas filtran la lógica, cómo el cifrado de constantes las reemplaza por valores decodificados en tiempo de ejecución, y dónde encaja junto al cifrado de cadenas y la protección del flujo de control.

Leer →
Decompilación

Qué revela un decompilador en los records de C#

Un record es una clase más un conjunto preciso de miembros generados por el compilador — igualdad por valor, un método de clonación, un Deconstruct, un PrintMembers/ToString, setters init-only. Un decompilador reconoce esa huella y reconstruye la palabra clave record. Aquí tienes exactamente qué emite el compilador para un record y cómo se lee de vuelta el patrón.

Leer →
Decompilación

Cómo yield return se convierte en una máquina de estados

Un método iterador con yield return no tiene representación directa en IL — el compilador lo reescribe en una clase generada que implementa IEnumerator y reanuda dentro de un switch MoveNext. Aquí tienes la forma de esa máquina de estado, cómo la reconoce un decompilador, y cómo se recuperan yield return y yield break del código generado.

Leer →
Endurecimiento

El parcheo en tiempo de ejecución que tu comprobación de integridad no ve

La anti-manipulación que hashea la DLL en disco detecta un archivo parcheado — pero no un método reescrito en memoria en tiempo de ejecución. Bibliotecas como Harmony desvían tus métodos sin tocar el archivo, que es como funcionan las evasiones de licencia y los cheats modernos. Aquí tienes cómo funciona el parcheo en memoria y qué lo detecta de verdad.

Leer →
Licenciamiento

Cómo el licenciamiento sobrevive a la manipulación del reloj

Las pruebas y las suscripciones caducan en una fecha — pero el reloj del dispositivo está bajo control del atacante, y retrasarlo es el truco más antiguo para revivir una licencia caducada. Aquí tienes por qué no puedes confiar en la hora local, y las técnicas de marca de agua y de hora del servidor que defienden la caducidad sin castigar a los usuarios honestos.

Leer →
Licenciamiento

Diseñar una huella de máquina que sea estable pero no frágil

El node-locking vincula una licencia a un dispositivo, lo que significa que necesitas una huella lo bastante única para identificar una máquina y lo bastante estable para sobrevivir a una ampliación de RAM. Aquí tienes cómo construir una a partir de señales de hardware ponderadas, emparejarla con tolerancia, hashearla por privacidad, y manejar los casos de VM y cambio de hardware que hacen tropezar a las implementaciones ingenuas.

Leer →
Ofuscación

Lo que la anti-depuración puede y no puede hacer en .NET

Un depurador es como un atacante observa tus cadenas descifradas y pone un breakpoint en tu comprobación de licencia. Aquí están las formas gestionadas, nativas y basadas en tiempo en que una app .NET puede detectar uno —con código real— y una explicación honesta de por qué la anti-depuración es un reductor de velocidad, no un muro.

Leer →
Licenciamiento

Convertir una prueba en una licencia de pago sin reinstalar

Un usuario de prueba que paga debería convertirse en usuario con licencia en el sitio: misma instalación, mismos datos, sin clave que volver a introducir. Esto es cómo funciona una conversión limpia de prueba a pago: mejorar la clave en el sitio, refrescar los derechos cacheados, y diseñar la caducidad de la prueba para que pagar simplemente restaure lo que ya estaba.

Leer →
Decompilación

En qué se decompilan las lambdas y los closures

Decompila un método que usa una lambda y encontrarás un tipo llamado <>c__DisplayClass con tus variables locales como campos. Esto es cómo el compilador de C# convierte los closures en clases, por qué una lambda que captura asigna memoria y una que no captura no lo hace, y qué te dice el código generado sobre un bug de closure.

Leer →
Decompilación

Qué recupera un decompilador sin un PDB

Una DLL de release se distribuye sin su PDB y, aun así, un decompilador reconstruye C# legible. Esta es la separación: qué vive en los metadatos del ensamblado (y sobrevive), qué vive solo en el PDB (nombres locales, números de línea), y cómo un decompilador rellena el hueco cuando faltan los símbolos.

Leer →
Ofuscación

Leer stack traces .NET ofuscados

La ofuscación por renombrado convierte tus stack traces de producción en un muro de a, b, c — a menos que conserves el mapa de renombrado. Aquí tienes cómo funciona el mapa, cómo restaurar un trace legible a partir de un fallo ofuscado, y cómo mantener el mapa a salvo sin distribuirlo.

Leer →
Decompilación

Cómo funcionan las tablas de metadatos de .NET — y cómo las lee un decompilador

Cada ensamblado .NET lleva una pequeña base de datos relacional de su propia estructura: las tablas de metadatos. Aquí tienes qué contienen realmente TypeDef, MethodDef y los índices codificados, cómo un token de metadatos direcciona una fila, y cómo un decompilador recorre las tablas para convertir una DLL de vuelta en tipos y métodos.

Leer →
Licenciamiento

Hacer que una clave de licencia deje de funcionar, en línea y sin conexión

Emitir una licencia es fácil; hacer que una deje de funcionar tras un reembolso, una filtración o un contracargo es la mitad más difícil. Así funciona la revocación de verdad: el check-in en línea que falla hacia el estado bloqueado, las listas de revocación firmadas que llegan a los clientes sin conexión, y cómo acotar la ventana de exposición que nunca puedes cerrar del todo.

Leer →
Ofuscación

Qué rompe la ofuscación: reflexión, serialización y qué excluir

La primera vez que ofuscas una app que funcionaba puede romperse de formas sorprendentes: el JSON sale mal, la reflexión devuelve null, el data binding deja de funcionar. La causa siempre es la misma: algo resolvió por su nombre a un miembro renombrado. Esto es exactamente qué se rompe, por qué, y cómo excluir lo correcto sin debilitar la protección.

Leer →
Licenciamiento

Automatizar la entrega de licencias con webhooks de fulfillment

Un pedido pagado debería generar una licencia sin ningún humano de por medio. Así funcionan los webhooks de fulfillment de principio a fin: verificar la firma sobre el cuerpo en bruto, hacer la entrega idempotente por pedido, y mapear los eventos de pago, reembolso y cancelación a emitir, revocar y renovar.

Leer →
Decompilación

En qué se decompila async/await

Decompila un método async y no verás async/await: verás una estructura generada por el compilador con un switch en MoveNext(). Esto es cómo el compilador de C# transforma async en una máquina de estados, cómo leer el tipo <Método>d__N que te muestra un decompilador, y cómo un buen decompilador reconstruye el original.

Leer →
Ofuscación

Por qué el .NET renombrado se sigue leyendo como código fuente

El renombrado de identificadores es la capa de ofuscación más débil: un decompilador sobre código solo renombrado sigue mostrando tu lógica, tus cadenas y tus constantes tal cual. Esto es lo que el renombrado oculta y lo que no, y las capas —cifrado de cadenas, enmascaramiento de constantes, aplanamiento del flujo de control y virtualización— que de verdad hacen difícil de leer el .NET.

Leer →
Licenciamiento

Derechos y feature flags, definidos por la licencia

Cómo habilitar funciones y aplicar límites numéricos según el nivel de licencia: plantillas de derechos firmadas, lectura de flags y límites sin conexión en tu app, aplicación en la frontera de cada capacidad, y cambiar lo que desbloquea un nivel sin publicar una nueva versión.

Leer →
Licenciamiento

Licenciamiento para entornos aislados (air-gapped) y sin conexión

Cómo funciona la activación de licencias en entornos aislados (air-gapped): archivos de licencia offline firmados, flujos de activación manual, caducidad y gracia sin conexión, y revocación sin red.

Leer →
Decompilador

Cómo analizar de forma segura un ensamblado .NET sospechoso

Una guía defensiva para analizar estáticamente una DLL .NET no confiable sin ejecutarla: decompilar, inspeccionar APIs y recursos, detectar ofuscación y mantenerse a salvo.

Leer →
.NET

Anti-manipulación para .NET: detén las compilaciones parcheadas y crackeadas

La anti-manipulación para .NET detecta un ensamblado modificado o parcheado y un depurador en tiempo de ejecución. Aquí tienes cómo funcionan las comprobaciones de autointegridad y anti-depuración, y sus límites honestos.

Leer →
.NET

Ofuscación del flujo de control en .NET: por qué el renombrado no basta

El renombrado oculta nombres; la ofuscación del flujo de control oculta la lógica. Aquí tienes cómo funcionan el aplanado del flujo de control y los predicados opacos en .NET, con un ejemplo de antes/después.

Leer →
Decompilador

Alternativa a dnSpy en 2026: un decompilador de .NET con mantenimiento

dnSpy está archivado y sin mantenimiento. Estas son las mejores alternativas a dnSpy en 2026 para decompilar, leer y depurar .NET: gratuitas y en desarrollo activo.

Leer →
Licenciamiento

Licencias flotantes (concurrentes) explicadas

Cómo funciona una licencia flotante (concurrente) frente a las de bloqueo por equipo y de usuario nombrado: el techo de concurrencia, el check-in/check-out y cuándo encaja cada una.

Leer →
Decompilador

Alternativa a ILSpy: cuando quieres más

ILSpy es un excelente decompilador de .NET gratuito. Una mirada honesta a las alternativas a ILSpy en 2026 — dónde los usuarios quieren más experiencia y navegación, y cómo se compara Glass.

Leer →
Tutorial

Ofuscar .NET en Azure DevOps Pipelines

Un pipeline de YAML de Azure DevOps concreto que ofusca tu aplicación .NET solo en Release, licencia únicamente el agente de compilación y conserva el mapa de símbolos como artefacto.

Leer →
.NET

Proteger un SDK o una biblioteca de clases .NET que entregas a tus clientes

Ofuscar una biblioteca de clases o un SDK de .NET es diferente: la API pública debe seguir siendo invocable mientras se protegen las interioridades. Aquí tienes cómo excluir la superficie y publicar con seguridad.

Leer →
Decompilador

Cómo recuperar código fuente perdido a partir de una DLL de .NET

¿Perdiste el repositorio pero aún tienes la DLL? Cómo recuperar código fuente de una DLL de .NET decompilándola de vuelta a un proyecto C# compilable, con advertencias honestas.

Leer →
.NET

de4dot y la desofuscación de .NET: qué lo frena de verdad

Los desofuscadores automáticos como de4dot eliminan el renombrado simple con un clic. Aquí tienes lo que eleva el coste: flujo de control, cifrado de cadenas y de métodos, y virtualización.

Leer →
Licenciamiento

Licenciamiento autoalojado frente a la nube: cómo elegir

Licenciamiento autoalojado frente a un servidor de licencias gestionado en la nube: las verdaderas disyuntivas en control, aislamiento (air-gap), cumplimiento, disponibilidad y carga operativa.

Leer →
Licenciamiento

Cómo detener el uso compartido de claves de licencia y la piratería

Cómo detener el uso compartido de claves de licencia y evitar la piratería de licencias: bloqueo por equipo, límites de activación, topes de puestos y dispositivos, revalidación y revocación.

Leer →
Licenciamiento

Licenciamiento basado en uso (medido) para software

Cómo funciona el licenciamiento basado en uso (medido): créditos, cuotas, medición de llamadas a la API o puestos, bloques de créditos prepago y reconciliación del uso sin conexión.

Leer →
Decompilador

Cómo ver el IL de un ensamblado .NET (y por qué)

Cómo ver el IL de un ensamblado .NET, qué es realmente el CIL y cuándo leer IL supera al C# decompilado — con un ejemplo práctico pequeño y correcto de C# a IL.

Leer →
.NET

Cómo depurar una app .NET cuando no tienes el código fuente

¿No tienes el código de ese paquete NuGet o de una DLL heredada? Un decompilador de .NET convierte el ensamblado de nuevo en C# legible que puedes navegar, comparar entre versiones y exportar a un proyecto, para que encuentres el fallo sin el código original.

Leer →
.NET

Ofuscador de .NET gratuito: lo que realmente obtienes (y lo que no)

Un ofuscador de .NET gratuito te da renombrado de identificadores, algo de cifrado de cadenas y protección básica del flujo de control — las funciones de pago son el cifrado de cadenas completo, la anti-manipulación, el cifrado de métodos, la virtualización de código y la integración con CI. Aquí tienes un desglose honesto, y dónde encaja la edición gratuita de Nebula.NET.

Leer →
Licenciamiento

Cómo licenciar tu software: una guía práctica

Una guía práctica y de principio a fin para licenciar tu software: elige un modelo de licenciamiento, emite claves de licencia firmadas en lugar de una cadena casera, entrégalas a los clientes, verifica sin conexión y activa en línea, aplica puestos y bloqueo por equipo, controla funciones con derechos, y gestiona pruebas, renovaciones y revocación.

Leer →
.NET

Hacer que tu app .NET no merezca ingeniería inversa

Aplicar ingeniería inversa a una aplicación .NET es fácil porque el IL se decompila limpiamente de vuelta a C#: cadenas, comprobaciones de licencia y lógica, todo legible. Aquí tienes cómo funciona y las capas defensivas que elevan el coste.

Leer →
Licenciamiento

Tipos de licencia de software y cuándo usar cada uno

Una referencia clara sobre los principales tipos de licencia de software — perpetua, suscripción/por plazo, flotante/concurrente, con bloqueo por equipo, prueba y por volumen/sede — con cuándo usar cada uno, sus contrapartidas, una tabla comparativa y cómo se corresponde cada uno con lo que admite Keyright.

Leer →
Licenciamiento

Cómo añadir una prueba gratuita a tu software (que no se filtre)

Pruebas con límite de tiempo bien hechas: emite una clave firmada que caduca sola, bloquéala por equipo para una prueba por máquina, hazla revocable y rastreable, conviértela a pago sin reemitir clave y ofrece pruebas de autoservicio desde tu propio sitio, en lugar de un flag en el registro que cualquiera puede resetear.

Leer →
Licenciamiento

Generador de claves de licencia para .NET: por qué no deberías hacer el tuyo propio

Un sistema de licencias de .NET de verdad no es una cadena de clave aleatoria: es una licencia firmada que se verifica contra una clave pública incrustada, con caducidad, bloqueo por equipo, derechos y revocación. Aquí tienes por qué un generador de claves casero fracasa y cómo es un sistema de licencias firmadas en condiciones.

Leer →
.NET

Cómo el cifrado de métodos protege tu código .NET

El cifrado de métodos almacena el IL de un método cifrado en el ensamblado y lo vuelve a emitir en tiempo de ejecución, de modo que un decompilador solo ve un esbozo: ni C# ni IL legibles. Así funciona, cuándo usarlo y sus contrapartidas.

Leer →
.NET

Una alternativa a dotPeek: Glass.NET, un decompilador de .NET gratuito

Glass.NET es un decompilador de .NET gratuito construido sobre el motor de ILSpy, con un flujo de trabajo centrado en la navegación, exportación de proyectos y un informe de exposición. Aquí tienes una comparación honesta con JetBrains dotPeek.

Leer →
Licenciamiento

Bloqueo por equipo y gestión de puestos para licencias de software

Cómo vincular una licencia a un equipo con una huella estable y tolerancia a cambios, imponer un número de puestos en N máquinas, dejar que los clientes desactiven un puesto por su cuenta, y por qué solo la activación en línea hace reales los puestos y la revocación.

Leer →
Licenciamiento

Cómo añadir licenciamiento de software a una aplicación .NET

Un cómo-hacerlo práctico para añadir licenciamiento a una aplicación .NET: emite una clave firmada, embebe una clave pública, verifica sin conexión, limita funciones por nivel y derechos, activa en línea para los puestos y gestiona pruebas y revocación.

Leer →
Licenciamiento

Construir o comprar: licenciamiento de software para .NET (2026)

Un desglose honesto del coste real de crear tu propio licenciamiento de .NET —claves de firma, bloqueo por equipo, puestos, revocación, pruebas, un portal de cliente— frente a adoptar un servicio de licenciamiento como Keyright.

Leer →
Licenciamiento

Una alternativa a Cryptolens para el licenciamiento de software

Cryptolens es un servicio de licenciamiento establecido y centrado en .NET. Aquí tienes una comparación justa con Keyright: licencias firmadas offline-first, claves de firma por tenant, derechos y pruebas de autoservicio, con un nivel gratuito para probar primero.

Leer →
Decompilación

Cómo decompilar una DLL de .NET a C# (guía 2026)

Decompila cualquier DLL o EXE de .NET de vuelta a C# legible gratis. Una guía paso a paso más una comparación honesta de ILSpy frente a dnSpy frente a dotPeek frente a Glass.NET.

Leer →
Ofuscación

Cómo proteger el código de .NET frente a la decompilación (2026)

Una guía práctica y honesta para proteger el código de .NET frente a la decompilación: por qué C# es trivialmente reversible, y las capas de ofuscación que realmente elevan el coste.

Leer →
.NET

Cómo inspeccionar el código de un paquete NuGet antes de confiar en él

Un paquete NuGet distribuye DLLs compiladas, no el código fuente que lees en GitHub — así que la única forma de auditar el código exacto que estás a punto de ejecutar es decompilarlo. Aquí tienes cómo decompilar un paquete NuGet de vuelta a C#, qué señales de alarma buscar, y cómo un decompilador gratuito hace la revisión rápida.

Leer →
Licenciamiento

Una alternativa a Keygen para el licenciamiento de .NET

Keygen es una API de licenciamiento capaz y agnóstica al lenguaje. Aquí tienes una comparación honesta con Keyright — dónde encaja cada uno, y por qué un equipo .NET-first que distribuye licencias firmadas sin conexión podría preferir Keyright.

Leer →
Blazor

Cómo ofuscar una aplicación Blazor WebAssembly (WebCil)

El Blazor WebAssembly moderno envuelve tus ensamblados .NET reales en WebCil, les pone una huella y los protege con hashes de integridad — de modo que los ofuscadores posteriores a la publicación rompen la aplicación. Aquí tienes por qué, y cómo proteger una aplicación Blazor WASM de la forma correcta: ofuscar en tiempo de compilación, antes de que el SDK empaquete en WebCil.

Leer →
Licenciamiento

Validación de licencias sin conexión con claves firmadas, explicada

Cómo funciona la validación de licencias sin conexión: firmas RSA firmadas en el servidor y verificadas en el cliente contra una clave pública embebida, bloqueo por equipo mediante huella de la máquina, caducidad, listas de revocación y por qué importa fallar en cerrado.

Leer →
Comparativa

Una alternativa a Dotfuscator para .NET en 2026

Dotfuscator es el veterano ofuscador empresarial de .NET, pero sus precios por presupuesto y su enfoque empresarial no encajan con todos los equipos. Aquí tienes una mirada honesta a dónde brilla, dónde no, y cómo se compara Nebula.NET como alternativa moderna.

Leer →
Comparativa

Una alternativa a Eazfuscator.NET en 2026

Eazfuscator.NET es un ofuscador de .NET pulido, nativo de MSBuild y con virtualización. Aquí tienes una comparación justa con Nebula.NET: dónde encaja cada uno y cómo elegir para tu equipo.

Leer →
Glass.NET

Glass.NET frente a ILSpy, dnSpy y dotPeek: un decompilador que navegas

Un análisis función por función de Glass.NET frente a ILSpy, dnSpy, dotPeek y .NET Reflector — el mismo motor de decompilación probado, pero un flujo de trabajo centrado en la navegación, una vista completa de información del ensamblado, exportación de proyectos y un informe de exposición. Gratuito, y en desarrollo activo.

Leer →
Comparación

Una alternativa a .NET Reactor en 2026

.NET Reactor es un ofuscador capaz y asequible, con compilación nativa (NecroBit) y licenciamiento integrado. Aquí tienes una comparación honesta con Nebula.NET — en qué destaca cada uno y cómo decidir.

Leer →
Guía

Cómo ofuscar una aplicación .NET MAUI (sin romperla)

Una aplicación .NET MAUI distribuye tus ensamblados administrados a cada dispositivo, donde se decompilan de vuelta a C#. Aquí tienes qué queda expuesto en cada plataforma, cómo ofuscar una aplicación MAUI con Nebula.NET y las trampas de los enlaces de XAML y de iOS que debes evitar.

Leer →
Blazor

Cómo proteger una aplicación Blazor WebAssembly de la decompilación

Blazor WebAssembly envía tus ensamblados .NET reales al navegador, donde cualquiera puede descargarlos y decompilarlos. Aquí tienes por qué Blazor es el objetivo .NET más expuesto, por qué no puedes limitarte a ofuscar las DLL y cómo Nebula.NET protege una aplicación Blazor WASM de principio a fin.

Leer →
Anuncio

Nebula.NET 1.1 añade virtualización de código

Nebula.NET 1.1 añade virtualización de código, protección de Blazor WebAssembly y un endurecimiento creado específicamente para derrotar a los desofuscadores automáticos como de4dot.

Leer →
Tutorial

Cómo ofuscar una aplicación .NET en GitHub Actions (CI/CD)

Ofusca tu aplicación .NET automáticamente en GitHub Actions: un flujo de trabajo de CI/CD paso a paso que protege tu compilación de Release en el runner, licencia solo el servidor de compilación y mantiene limpias las compilaciones de los desarrolladores.

Leer →
Guía

Ofusca solo en tu servidor de compilación

Protege solo las compilaciones oficiales y distribuibles — las máquinas de los desarrolladores compilan sin ofuscar y depurables. Una configuración de CI paso a paso con Nebula.NET.

Leer →
Guía

Cómo ofuscar un paquete NuGet antes de publicarlo

Distribuye una biblioteca .NET protegida en NuGet sin romper la API pública de la que dependen tus consumidores — una guía paso a paso con Nebula.NET.

Leer →
Guía

Cómo ofuscar una aplicación WPF sin romper el enlace de datos de XAML

Una guía paso a paso para proteger una aplicación de escritorio WPF con Nebula.NET — y mantener funcionando los enlaces, comandos y convertidores.

Leer →
Comparativa

Mejores ofuscadores de .NET en 2026: comparativa del Top 5

Los mejores ofuscadores de .NET para 2026, comparados con honestidad: ConfuserEx, Dotfuscator, Eazfuscator.NET, .NET Reactor y Nebula.NET. Protección real frente a trucos de renombrado.

Leer →
Comparativa

¿Buscas una alternativa a ConfuserEx? Lo que debes saber en 2026

ConfuserEx es popular pero está efectivamente sin mantenimiento. Aquí tienes qué significa eso para tu protección de .NET, qué buscar en una alternativa moderna y tus opciones.

Leer →
Explicación

¿La ofuscación protege de verdad el código .NET?

Una respuesta directa sobre lo que la ofuscación de .NET puede y no puede hacer: por qué .NET es fácil de decompilar, qué cambia la ofuscación y cómo construir una protección realista y por capas.

Leer →
Anuncio

Presentamos Glass.NET: un decompilador de .NET gratuito que puedes navegar

Glass.NET es un decompilador de .NET gratuito que convierte cualquier ensamblado en C# limpio y legible, con Ir a definición rápido, Buscar todas las referencias, Ir a todo, jerarquía de llamadas/tipos, vistas de C#/IL y exportación de proyectos. Una alternativa moderna a ILSpy, dnSpy y .NET Reflector.

Leer →
Guía

Cómo ofuscar un ensamblado de .NET (paso a paso, 2026)

Una guía práctica para ofuscar ensamblados de .NET — qué proteger, cómo hacerlo con Nebula.NET, y cómo verificar que tu aplicación sigue ejecutándose de forma idéntica después.

Leer →
Explicación

¿Puede alguien decompilar mi aplicación .NET? Cómo frenar dnSpy e ILSpy

Sí: herramientas como dnSpy e ILSpy decompilan binarios .NET en segundos. Aquí tienes cómo funciona la decompilación y cómo hacer que tus ensamblados sean mucho más difíciles de leer y depurar.

Leer →
Guía

Cómo proteger el código fuente de C# para que no lo decompilen

El C# compilado puede convertirse de nuevo en código fuente legible en segundos. Aquí tienes por qué ocurre eso y los pasos prácticos para proteger tu código C# antes de publicarlo.

Leer →
Guía

¿Añadiendo licenciamiento a tu aplicación .NET? Protege también la comprobación de licencia

Una clave de licencia es tan fuerte como el código que la verifica. Conoce los enfoques habituales de licenciamiento en .NET y por qué la ofuscación y la anti-manipulación son esenciales para que aguanten.

Leer →
Explicación

Las cadenas incrustadas están filtrando los secretos de tu app .NET

Las cadenas literales en un binario .NET se leen en segundos con cualquier decompilador — exponiendo endpoints de API, claves y lógica. Esto es por qué importa el cifrado de cadenas y cómo funciona.

Leer →
Guía

¿Qué edición de Nebula.NET es la adecuada para ti?

¿Free, Licensed o Enterprise? Una guía práctica para elegir la edición de Nebula.NET adecuada para tu proyecto, equipo y modelo de amenazas.

Leer →
Anuncio

Presentamos Nebula.NET

Nuestro primer producto ya está aquí — una suite de ofuscación y endurecimiento de .NET construida para la corrección, con una CLI, una GUI de escritorio e integración con CI.

Leer →