Blog
Neuigkeiten und Engineering-Notizen
Release-Ankündigungen, ausführliche Analysen zur Funktionsweise unserer Tools und praktische Anleitungen.
Wie Glass eine native Interop-Struct rekonstruiert
StructLayout und MarshalAs werden nicht als benutzerdefinierte Attribute gespeichert, sondern leben in den Metadatentabellen ClassLayout und FieldMarshal. So liest Glass.NET diese Tabellen und rekonstruiert den exakten nativen Byte-Vertrag, den eine P/Invoke-Struct beschreibt.
Artikel lesen →Keine Beiträge mit diesem Tag.
Wie Glass eine native Interop-Struct rekonstruiert
StructLayout und MarshalAs werden nicht als benutzerdefinierte Attribute gespeichert, sondern leben in den Metadatentabellen ClassLayout und FieldMarshal. So liest Glass.NET diese Tabellen und rekonstruiert den exakten nativen Byte-Vertrag, den eine P/Invoke-Struct beschreibt.
Lesen →Umbenennung dringt in Ihre Expression Trees ein
Ein Lambda wie c => c.Name wird nicht zu einem Methodenrumpf kompiliert, wenn sein Typ Expression<T> ist — es wird zu Fabrikaufrufen kompiliert, die den Property-Zugriff als Metadaten-Token codieren, nicht als Zeichenfolge. Die Umbenennung schreibt dieses Token zusammen mit dem Member um, der Baum löst also weiterhin auf und das kompilierte Lambda läuft weiterhin. Die Falle ist Member.Name: er liefert den aktuellen Metadaten-Namen, sodass jede Bibliothek, die aus x => x.Prop eine Spalte, einen JSON-Schlüssel oder eine Validierungsmeldung ableitet, still den obfuskierten Namen ausgibt. Hier ist das exakte IL, warum die Umbenennung ins Innere des Baums reicht und wie Sie einen aus dem Namen abgeleiteten Vertrag stabil halten.
Lesen →Warum ist die Lizenz dieses Kunden blockiert?
Ein Support-Ingenieur bekommt ein Ticket, dass sich eine Lizenz „nicht aktivieren lässt", aber der Client scheitert geschlossen und meldet nur „blockiert". Hier ist ein schreibgeschütztes Diagnosewerkzeug, gebaut auf der Keyright-Admin-API, das die gesamte Verifizierungs-Pipeline im Erklärungsmodus abspielt und genau meldet, welche Prüfung fehlschlug — Ablauf, Widerruf, Maschinenbindung, ein Sitz oder ein fehlendes Recht — ohne den Schlüssel je offenzulegen.
Lesen →Wie quellgenerierter P/Invoke dekompiliert
Klassische [DllImport]-Methoden haben keinen verwalteten Rumpf, daher rekonstruiert ein Dekompiler sie aus der ImplMap-Tabelle. Eine [LibraryImport]-Methode ist das Gegenteil: der Marshalling-Stub ist echter kompilierter C#-Code, und Glass zeigt ihn vollständig.
Lesen →Warum ein gespeicherter Typname nach dem Umbenennen bricht
Eine Plugin-Anwendung, die "Acme.Exporters.PdfExporter, Acme.Exporters" mit Type.GetType und Activator.CreateInstance auflöst, läuft im Debug und fällt in der Produktion aus, sobald man sie obfuskiert. Die Ursache ist eine Diskrepanz zwischen einem Metadaten-Token und einer schlichten Zeichenfolge – und die Lösung ist eine umbenennungssichere Registry, die keinen Namen behält.
Lesen →Lizenzablauf in der richtigen Zeitzone anzeigen
Eine Lizenz läuft zu einem einzigen Zeitpunkt auf der Zeitachse ab, aber „30. November" ist ein bürgerliches Datum, das davon abhängt, wo man steht. Verwechselt man beides, sieht ein Kunde in Auckland „abgelaufen" bei einem Schlüssel, den ein Kunde in Los Angeles noch als gültig anzeigt. Dieser Beitrag baut die korrekte Ablaufanzeige in .NET: den Ablauf als UTC-Zeitpunkt speichern, ihn mit DateTimeOffset und TimeZoneInfo in die Zeitzone des Betrachters projizieren, die Zone kennzeichnen und die „verbleibenden Tage" so berechnen, dass Sommerzeitwechsel einen Tag nie 23 oder 25 Stunden lang machen.
Lesen →Was ein Decompiler in einer NativeAOT-Binärdatei sieht
Geben Sie Glass eine mit NativeAOT veröffentlichte Bibliothek, und Sie bekommen nichts zurück — kein C#, kein IL, nicht einmal eine Methodenliste. Hier ist der Grund auf PE-Ebene, welche Metadaten im nativen Image überleben und warum NativeAOT nicht der Obfuskator ist, für den man es hält.
Lesen →Einen Speicher-Dump am Wiederherstellen Ihres Assemblys hindern
Umbenennung und String-Verschlüsselung sind hinfällig, wenn ein Angreifer Ihren laufenden Prozess einfach auf die Festplatte dumpt. Wie der Anti-Dump von Nebula.NET die PE- und Metadaten-Header im Speicher verschiebt und überschreibt, sodass ein herausgeschnittenes Abbild unbrauchbar ist – mit den echten Offsets, C#, einem SVG des Extraktionspfads und den ehrlichen Grenzen.
Lesen →Eine Blazor-Server-App pro Circuit lizenzieren
In Blazor Server lebt ein DI-Scope für den gesamten SignalR-Circuit, nicht pro Request — eine Lizenz, die beim Verbinden eines Tabs validiert wurde, ist deshalb drei Tage später noch immer die Antwort, lange nach Ablauf des Lease. So begrenzen Sie Keyright-Entitlements auf den Circuit, halten sie über dessen gesamte Lebensdauer frisch und schalten die Oberfläche bei Änderung in einen degradierten Modus.
Lesen →Wie Glass generische Methoden-Instanziierungen liest
Ein generischer Methodenaufruf wird zu einem MethodSpec-Token mit einem separaten Typargument-Blob kompiliert. So liest Glass.NET diesen Blob, ersetzt die !!0-Platzhalter und entscheidet, wann das wiederhergestellte C# überhaupt explizite Typargumente braucht.
Lesen →Wie Ausnahmehandler .NET-Kontrollfluss verbergen
Ein Decompiler baut dein if/else aus den Sprungbefehlen wieder auf, die er im IL findet. Leitet man eine Entscheidung über eine geworfene und gefangene Sentinel-Ausnahme, wandert diese Kante in die Klauseltabelle der Ausnahmebehandlung, wo die strukturierte Dekompilierung zusammenbricht. Hier ist das echte IL, warum es eine statische Lesung aushebelt und die Laufzeitkosten, die zum sparsamen Einsatz zwingen.
Lesen →Eingehende Billing-Webhooks in .NET verifizieren
Ihr Lizenzserver vertraut einem POST Ihres Zahlungsanbieters, bis ein Angreifer seinen eigenen schickt. Wie man eingehende, HMAC-signierte Webhooks korrekt verifiziert: Signatur über die Rohbytes, zeitkonstanter Vergleich, Zeitstempeltoleranz und Replay-Schutz, und anschließend eine Rückerstattung mit der Lizenzsperrung abgleicht.
Lesen →Jede Version aus einem einzigen Schlüsselpaar lizenzieren
Die Signaturschlüssel bei jeder Hauptversion zu rotieren ist die Falle: Es bricht ältere Builds, erzwingt eine Massenmigration und gibt Ihnen keine Kontrolle pro Kunde. Das bessere Modell behält ein einziges Schlüsselpaar für die gesamte Lebensdauer des Produkts und trägt das, was eine Lizenz darf — welche Versionen sie ausführt, welche Funktionen sie freischaltet, wie viel sie nutzen darf — in signierten Entitlements. Dieser Beitrag zeigt die drei Muster mit echtem Code, wie die Freigaben online wie offline fälschungssicher bleiben und wann stattdessen die vollständige Release-Abdeckung angebracht ist.
Lesen →Wie ein Decompiler die Werte benutzerdefinierter Attribute liest
Die Anwendung eines Attributs wird nicht als Quellcode gespeichert. Sie ist ein binärer Blob im #Blob-Heap: ein Prolog, die nach der Konstruktorsignatur serialisierten Positionsargumente und dann eine gezählte Liste benannter Feld- und Eigenschaftswerte. Hier ist das exakte Byte-Layout und wie Glass.NET es wieder in ein C#-Attribut verwandelt.
Lesen →Wie checked-Arithmetik in C# dekompiliert
Ein checked- oder unchecked-Schlüsselwort überlebt niemals in den Metadaten. Die Überlaufprüfung wird pro Instruktion als add.ovf, mul.ovf und conv.ovf.u1 kodiert – hier sind die IL, die Asymmetrien und wie Glass.NET die kleinste checked-Region rekonstruiert, die das erklärt.
Lesen →Wie Raw-String-Literale in C# dekompilieren
Ein Raw-String-Literal, eine Verbatim-Zeichenkette und eine gewöhnliche Zeichenkette kompilieren alle zu ein und demselben ldstr in den #US-Heap. Hier sind die IL, die Benutzer-String-Bytes dahinter und wie Glass.NET entscheidet, welche Anführungsform es rekonstruiert.
Lesen →Wie Glass with-Ausdrücke von Records rekonstruiert
Ein `with`-Ausdruck hinterlässt kein Schlüsselwort im IL – er ist ein virtueller Aufruf einer versteckten `<Clone>$`-Methode, gefolgt von einer Reihe von init-only-Settern. Glass.NET liest genau diese Form wieder als `record with { … }` ein. Hier ist der vollständige Weg source → IL → rekonstruiertes C# für die nicht-destruktive Mutation.
Lesen →Den stark typisierten Ressourcen-Designer mit Glass.NET wiederherstellen
Eine `Resources.Designer.cs` ist maschinell generierter Klebecode: ein fauler `ResourceManager`, ein Kulturfeld und eine typisierte Eigenschaft pro `.resx`-Schlüssel, die nur `GetString` aufruft. Nichts von dieser Schlüsselwort-Magie überlebt die Kompilierung – es ist reines IL. Glass.NET liest den Attribut-Fingerabdruck und die `GetString`-Form zurück in die vertraute Designer-Klasse. Hier ist der vollständige Hin-und-Rückweg Quellcode → IL → rekonstruiertes C#.
Lesen →Lizenzprüfung mit OpenTelemetry instrumentieren
Sie instrumentieren jeden Datenbankaufruf und jede ausgehende HTTP-Anfrage Ihrer Anwendung, aber die eine Abhängigkeit, die entscheidet, ob die Software laufen darf – die Lizenzprüfung – bleibt meist unsichtbar, bis ein Kunde ein Ticket öffnet. Diese Anleitung verdrahtet eine Keyright-Prüfung mit OpenTelemetry wie jede andere kritische Abhängigkeit: ein Meter mit einem Prüfzähler, einem Dauer-Histogramm und einer Ablauf-Anzeige; ein ActivitySource-Span um den Refresh-Pfad, der festhält, ob die Antwort online, aus dem Cache oder aus dem Kulanzfenster kam; die Tags mit niedriger Kardinalität, die ein Dashboard ergeben, und jene mit hoher Kardinalität (der Schlüssel, der Lizenznehmer, die Maschinen-ID), die niemals Tag-Werte werden dürfen; sowie die OTLP-Verdrahtung und die vier Alarme, die einen Anruf wert sind.
Lesen →Eine Keyright-Lizenz auf eine Umgebung begrenzen
Dieselbe Lizenzdatei wandert gern von der Produktion ins Staging, auf den Laptop eines Entwicklers und durch die CI, bis niemand mehr weiß, aus welcher Umgebung eine Validierung kam, und ein geleakter Staging-Schlüssel unbemerkt die Produktion freischaltet. Dies ist eine Migrationsanleitung: Vergleichen Sie die drei Wege, auf denen Teams Umgebungen trennen — ein Produkt pro Umgebung, eine schlichte Datei pro Umgebung und ein einziges Produkt mit einem signierten env-Entitlement — und migrieren Sie dann ohne Stichtag auf Keyright zum letzten. Er behandelt, wo die Anwendung ihre eigene Umgebung erfährt (IHostEnvironment und der Fallback DOTNET_ENVIRONMENT / ASPNETCORE_ENVIRONMENT), eine Prüfung von zwanzig Zeilen, die bei unbekannter Umgebung geschlossen abriegelt, ein rückwärtskompatibles Rollout, bei dem ein alter, uneingeschränkter Schlüssel weiterhin überall läuft, und die ehrliche Grenze: die Umgebung wird von Ihrer eigenen Konfiguration gemeldet, also geht es um Hygiene und saubere Telemetrie, nicht um eine Mauer gegen einen Operator, der die Variable setzt.
Lesen →Eine Keyright-Lizenz aus einem WiX/MSI-Installer vorbefüllen
Desktop-Unternehmenssoftware wird nicht von der Person aktiviert, die sie ausführt. Sie wird still über Gruppenrichtlinien, Intune oder SCCM mit msiexec /qn auf Rechner ausgerollt, deren Benutzer nie einen Dialog sehen und oft Ihren Lizenzdienst nicht erreichen können. Diese Anleitung baut die Bereitstellung, die die meisten ISVs letztlich brauchen: ein MSI, das eine signierte maschinenweite Lizenz unter ProgramData ablegt, sodass die App beim ersten Start bereits lizenziert ist, plus die Alternative, einen Aktivierungsschlüssel als MSI-Eigenschaft zu übergeben und die App ihn einmal online einlösen zu lassen. Es behandelt die Erstellung in WiX v5, wo die Datei liegen muss, damit alle Windows-Benutzer des Rechners einen Platz teilen, die verzögerte benutzerdefinierte Aktion, die einen Schlüssel schreibt, den die App aufnehmen wird, die SDK-Optionen, die ProgramData maßgeblich machen, und die msiexec-Befehlszeilen, die ein Administrator in sein Bereitstellungswerkzeug einfügt.
Lesen →Delegationsketten lassen Reseller eigene Schlüssel ausstellen
Sie unterschreiben einen Vertriebsvertrag, und die erste Integrationsfrage lautet: „Wie stellen unsere Reseller Schlüssel an Endkunden aus?" Die beiden naheliegenden Antworten sind beide falsch: Geben Sie jedem Reseller Ihren Root-Signaturschlüssel, und ein einziger gestohlener Laptop fälscht Ihren gesamten Katalog; oder leiten Sie jeden Reseller-Verkauf über einen Live-Aufruf an Ihren Ausstellungsdienst, und Ihre Partner können nicht verkaufen, wenn Sie ausfallen. Das Design, das hält, ist eine Delegationskette: Geben Sie jedem Reseller ein signiertes Zertifikat, das seinen eigenen öffentlichen Schlüssel und einen Geltungsbereich trägt, den er nie überschreiten kann, lassen Sie ihn Endkunden-Lizenzen mit der privaten Hälfte signieren, und lassen Sie den Client die gesamte Kette offline gegen einen einzigen angehefteten Root-Schlüssel prüfen. Dieser Artikel baut diese Kette in Keyright: das Delegationszertifikat und seinen Geltungsbereich, wie ein Reseller darin ausstellt, die SDK-Prüfung, die Lizenz → Delegat → Root durchläuft, die Regel, dass sich der Geltungsbereich nur verengen kann, und warum das Widerrufen eines einzigen Zertifikats stillschweigend jeden Schlüssel verfallen lässt, den ein kompromittierter Reseller je ausgestellt hat.
Lesen →Ein manipulationssicheres Lizenz-Audit-Log mit Hash-Verkettung bauen
Eine Schritt-für-Schritt-Anleitung, um Keyrights Lizenz-Audit-Spur in ein hash-verkettetes, manipulationssicheres Log zu verwandeln: wie jeder Eintrag den vorherigen versiegelt, wie man die Kette über die Admin-API und die CLI liest und verifiziert, wie man den Kopf-Hash verankert, damit eine Löschung sich nicht verstecken kann, und das C#, das du brauchst, um die Spur in CI zu beweisen.
Lesen →Ein .NET-Assembly nach der Obfuskierung verkleinern
Das Umbenennen hinterlässt tote Strings und Blobs in den Heaps #Strings und #Blob. Wie Nebula die Metadaten-Heaps kompaktiert und Tokens neu nummeriert, mit echtem Metadaten-Layout, IL, Konfiguration und Vorher/Nachher-Messungen.
Lesen →Die Ganzzahl-Rechnungen verbergen, die Ihre Software steuern
Umbenennung verbirgt, wie ein Wert heißt; MBA verbirgt, was er berechnet. Dieser Deep Dive zeigt, wie Nebula a + b in äquivalente Gewirre aus Arithmetik und Bitoperationen umschreibt, die Konstantenfaltung und symbolische Ausführung aushebeln – mit echtem C#, repräsentativem IL, den Identitäten, der Konfiguration und den ehrlichen Kosten.
Lesen →Eine benutzerdefinierte MSBuild-Task obfuskieren, ohne sie zu zerstören
Eine benutzerdefinierte MSBuild-Task ist das Spiegelbild eines Quellcode-Generators. Der Compiler findet einen Generator über ein Attribut, sodass du die gesamte Klasse frei umbenennen kannst; MSBuild findet eine Task über die literale Typnamen-Zeichenfolge, die in ein UsingTask-Element geschrieben wurde, und liest ihre Parameter aus den öffentlichen Eigenschaftsnamen — beides ist also ein harter externer Vertrag, den die Umbenennung nicht antasten darf. Dieser Beitrag untersucht, worüber die MSBuild-Engine tatsächlich reflektiert, wenn sie deine Task ausführt, zieht die genaue Linie zwischen der kleinen festgenagelten Oberfläche und der wertvollen Logik, die sich problemlos umbenennen lässt, und zeigt die Nebula-Konfiguration sowie den Verifizierungs-Build, der den einzigen Fehlermodus abfängt, der lautlos ist.
Lesen →Die richtige Reihenfolge von ReadyToRun und Obfuskierung
Ein ReadyToRun-Build ist ein Doppelabbild — dein IL plus eine native Kopie davon, von crossgen aus dem Zustand des IL zum Veröffentlichungszeitpunkt kompiliert. Obfuskierst du nach crossgen, ist diese native Kopie ein sauberer, von jedem Decompiler unabhängiger Mitschnitt deiner ursprünglichen Logik; sie macht zudem das R2R-Abbild ungültig, sodass die Runtime still auf den JIT zurückfällt. Hier steht, warum die Reihenfolge alles entscheidet und wie du Nebula so einhängst, dass crossgen geschütztes IL kompiliert.
Lesen →Kann Obfuskierung eine .NET-Verbindungszeichenfolge verbergen?
Eine Verbindungszeichenfolge, ein API-Schlüssel oder ein Signaturgeheimnis, das innerhalb Ihrer .NET-Anwendung ausgeliefert wird, ist prinzipiell wiederherstellbar: Der Prozess muss es verwenden, also muss der Prozess es vorhalten. Dies ist ein ehrlicher Vergleich der drei Orte, an denen sich ein Geheimnis in einer ausgelieferten Assembly versteckt, was die String- und Ressourcenverschlüsselung von Nebula.NET an jedem davon genau ändert, wo die Obergrenze liegt und welche Schichtung ein Geheimnis wirklich aus der Reichweite eines Angreifers hält.
Lesen →Warum Anti-ILDASM schwächer schützt, als Sie denken
Warum das Attribut [SuppressIldasm] genau ein Werkzeug stoppt — und auf modernem .NET schlicht ignoriert wird — plus was echtes Metadaten- und String-Hardening leistet, mit C#, IL und Nebula-Konfiguration.
Lesen →Wie allows ref struct in .NET dekompiliert
Die allows-ref-struct-Anti-Constraint aus C# 13 erzeugt keinerlei IL im Methodenrumpf. Sie lebt vollständig in einem Bit von GenericParameterAttributes (AllowByRefLike, 0x20) an einem generischen Parameter — sieh, wie Glass.NET es zurückliest.
Lesen →Wie das field-Schlüsselwort von C# 14 dekompiliert
Das field-Schlüsselwort verwendet dasselbe <Name>k__BackingField wieder, das eine Auto-Property ausgibt, also sind die Metadaten identisch. Die Entscheidung, field darzustellen, liegt vollständig im IL des Accessors. So liest Glass.NET es zurück.
Lesen →Den file-Modifizierer beim Dekompilieren zurückgewinnen
Der file-Modifizierer von C# 11 hat weder Attribut noch Flag. Der Compiler kodiert ihn, indem er den Typnamen in eine unaussprechliche Form <File>F0__Type verstümmelt und den Typ als assembly-intern ausgibt. Ein Dekompilierer, der diesen Namen wörtlich ausgibt, erzeugt Code, der nicht kompiliert. So liest Glass.NET die Verstümmelung zurück zu file class.
Lesen →Was OverloadResolutionPriority in einen Aufruf einfriert
Das Attribut OverloadResolutionPriority steuert die Überladungsauflösung, markiert aber nur die Methodendefinition, nie den Aufruf. So liest Glass.NET beide Seiten.
Lesen →Wie UnsafeAccessor in .NET dekompiliert
Eine UnsafeAccessor-Methode hat überhaupt keinen IL-Rumpf — das private Member, das sie erreicht, lebt nur als Zeichenkette im Blob eines benutzerdefinierten Attributs, vom JIT gebunden. So liest Glass.NET sie zurück.
Lesen →Wie ref-readonly-Parameter dekompilieren
ref readonly und in kompilieren zu byteweise identischen Parameter-Metadaten: gleiches [in]-Flag, gleiches modreq(InAttribute). Der einzige Unterschied ist ein benutzerdefiniertes Attribut. Das liest Glass.NET.
Lesen →Wie UTF-8-String-Literale in C# dekompilieren
Ein "abc"u8-Literal ist weder eine Zeichenfolge noch ein Byte-Array – es ist ein ReadOnlySpan<byte> über ein statisches RVA-Datenfeld. Hier sind das IL, der versteckte Null-Terminator und was Glass.NET rekonstruiert.
Lesen →Referenzen aus einer NuGet-Lockfile in Glass.NET auflösen
Ein Dekompilierer ist nur so genau wie die Referenzen, die er auflösen kann. Richte Glass.NET auf deine packages.lock.json und es lädt die exakt fixierten Paketversionen — so werden Typen, Basisklassen und Überladungen gegen das aufgelöst, was wirklich wiederhergestellt wurde, nicht gegen eine Vermutung.
Lesen →Massen-Provisionierung von Lizenzen über die Keyright-Admin-API
Ein Enterprise-Deal mit 2000 Plätzen per POST nacheinander einzurichten ist langsam und lässt dich raten, wenn ein Stapel auf halbem Weg stirbt. So provisionierst du in Masse und führst gefahrlos erneut aus.
Lesen →Features zur Compile-Zeit absichern mit einem Roslyn-Generator
Schluss mit handgeschriebenen Entitlement-Prüfungen überall im Code. Ein Roslyn-Source-Generator emittiert die Guards für Sie, validiert Entitlement-Namen gegen ein Manifest und lässt den Build bei einem Tippfehler scheitern.
Lesen →Optimistisches Sperren für die nebenläufige Lizenzaktivierung
Zwei Maschinen beanspruchen den letzten Platz in derselben Millisekunde. Ein naives Lesen-Zählen-Schreiben lässt beide herein und überverkauft die Lizenz. So macht optimistische Nebenläufigkeit aus der Platzbeanspruchung ein Compare-and-Swap, und so behandelt das SDK den 409.
Lesen →Bedingter Lizenz-Refresh mit ETag
Ein Keyright-Client aktualisiert seinen zwischengespeicherten Lease über einen Timer, und die überwältigende Mehrheit dieser Refreshes beantwortet dieselbe Frage mit derselben Antwort: nichts hat sich geändert. Den vollständigen signierten Lease jedes Mal erneut herunterzuladen verschwendet Bandbreite und wiederholt grundlos eine Signaturprüfung. HTTP besitzt bereits das passende Werkzeug für „hat sich diese Ressource seit meinem letzten Besuch geändert?" – das ETag und das bedingte GET. Dieser Beitrag zeigt, wie der Issuing Service jede Lizenzantwort mit einem starken Validator kennzeichnet, wie das SDK If-None-Match sendet, um einen Refresh in ein günstiges 304 Not Modified zu verwandeln, und welche Korrektheitsregeln verhindern, dass ein 304 jemals eine Sperrung verbirgt.
Lesen →Benötigte und gewährte Berechtigungen beim Upgrade vergleichen
Wenn eine neue Version Berechtigungen braucht, die die Lizenz des Kunden nie gewährt hat, ist ein bloßes „Funktion gesperrt" eine Sackgasse. So vergleichen Sie Benötigtes und Gewährtes und sagen genau, was zu kaufen ist.
Lesen →Einen Lizenz-Revalidierungs-Ansturm mit Jitter vermeiden
Wenn Tausende Clients einen gemeinsamen Cache-Validierungs-TTL teilen oder nach einem Ausfall alle zugleich neu verbinden, synchronisieren sich ihre Refresh-Aufrufe zu einer Lawine. So setzen Sie Jitter auf die Hintergrund-Revalidierung des SDK, um nicht Ihren eigenen Ausstellungsdienst zu DDoS-en.
Lesen →Named-User- vs. Geräte-Seats in Keyright
Ein Sitz kann eine Maschine oder eine Person bedeuten, und beide zählen unterschiedlich. So binden, erzwingen und gleichen Sie Geräte- und Named-User-Sitze in Keyright ab, ohne zu überverkaufen oder zahlende Nutzer auszusperren.
Lesen →Eine Desktop-App durch Scannen eines QR-Codes aktivieren
Einen 29-stelligen Lizenzschlüssel an einem Kiosk, einer TV-Box oder einem gesperrten Arbeitsplatz einzutippen ist fehleranfällig und mühsam. So baust du mit Keyright einen Geräte-Pairing-Aktivierungsfluss für eine .NET-Desktop-App: Die App zeigt einen QR-Code, der Nutzer bestätigt auf seinem Smartphone, und der Desktop fragt eine signierte Aktivierung ab, die er zwischenspeichert und offline validiert.
Lesen →Wie opake Prädikate automatische Deobfuscatoren ausbremsen
Warum stets-wahre Prädikate und Müllverzweigungen Tools vom Typ de4dot scheitern lassen — mit echtem C#, repräsentativem IL, dem Kompromiss Performance/Größe und der zuständigen Nebula-Stufe.
Lesen →Die Laufzeitkosten der String-Verschlüsselung in einer heißen Schleife
Verschlüsselte String-Literale werden an der Verwendungsstelle entschlüsselt. In einer engen Schleife summiert sich das. So misst man die Kosten mit BenchmarkDotNet und grenzt die String-Verschlüsselung in nebula.config.json ein.
Lesen →Einen polymorphen JSON-Vertrag sicher obfuskieren
Polymorphe Serialisierung schreibt die Typidentität auf die Leitung. TypeNameHandling von Newtonsoft bettet den CLR-Typnamen ein, den die Obfuskation umbenennt, wodurch jedes persistierte Dokument bricht. [JsonDerivedType] von System.Text.Json nutzt einen vom Typ entkoppelten String-Diskriminator und lässt sich daher frei umbenennen. Hier steht genau, warum, und wie man die Hierarchie sicher obfuskiert.
Lesen →Eine Minimal API obfuskieren, ohne die Parameterbindung zu zerstören
ASP.NET-Core-Minimal-APIs binden Route- und Query-Werte über den reflektierten Namen an die Handler-Parameter. Entfernt oder benennt man diese Namen um, schlägt die Bindung lautlos fehl: id kommt als 0 an. Hier ist die Lösung.
Lesen →Orleans-Grains obfuskieren, ohne das Cluster-Routing zu zerstören
Orleans routet jeden Grain-Aufruf über Zeichenketten aus dem Cluster-Manifest: einen GrainInterfaceType und einen GrainType, standardmäßig aus den Namen deiner .NET-Typen abgeleitet. Benenne einen Grain um, und die Identität verschiebt sich, verwaist den persistierten Zustand und zerstört Silo-übergreifende Aufrufe. So entkoppelst du die Identität mit [Alias]/[GrainType] und obfuskierst trotzdem aggressiv.
Lesen →Eine Quartz.NET-Anwendung obfuskieren, ohne den JobStore zu zerstören
Ein persistenter Quartz.NET-JobStore schreibt den assembly-qualifizierten Namen jedes IJob-Typs in die Datenbank und lädt ihn beim Auslösen eines Triggers per Reflection zurück – oft in einem späteren Deployment. Benennst du diesen Typ um, wirft der Scheduler eine JobPersistenceException. Hier ist die Keep-List, die das behebt.
Lesen →Ein Semantic-Kernel-Plugin sicher obfuskieren
Ein [KernelFunction]-Plugin ist ein per Reflexion entdeckter Vertrag, der dem LLM als Tool-Schema geschickt wird. Funktionsname, Parameternamen und Beschreibungen sind tragend; der Methodenrumpf ist Ihr geistiges Eigentum. Fixieren Sie die Namen mit Attributen, damit die Bezeichner frei umbenannt werden, und lassen Sie Nebula die Implementierung härten.
Lesen →Generische Einschränkungen und Varianz aus Metadaten rekonstruieren
Einschränkungen generischer Typparameter und Varianz sind, genau wie das Strukturlayout, Merkmale, die ein Dekompiler nicht aus der Form des Codes wiederherstellen kann: Sie leben vollständig in den Metadaten. Jeder generische Parameter trägt in der Tabelle GenericParam eine Varianzrichtung und Spezial-Einschränkungsflags, und die Tabelle GenericParamConstraint listet den Basistyp und die Schnittstellen auf, an die ein Parameter gebunden ist. Kovarianz (out) und Kontravarianz (in) sind Flag-Bits; die Einschränkungen class / struct / new() sind ebenfalls Bits; aber notnull und unmanaged werden indirekt kodiert, über ein modreq und ein Attribut statt über ein rohes Flag. Verlierst du die Varianz, ist eine Schnittstelle nicht mehr so zuweisbar wie zuvor; gibst du die Einschränkungen in der falschen Reihenfolge wieder aus, kompiliert die Ausgabe überhaupt nicht. Dieser Beitrag zeigt, wo die Daten liegen, wie Glass.NET die Tabellen GenericParam und GenericParamConstraint liest, wie es die Einschränkungen in die exakte von C# geforderte Reihenfolge sortiert, und ein durchgearbeitetes Beispiel mit einer kovarianten Schnittstelle und einer Methode mit mehreren Einschränkungen.
Lesen →Wie Glass Typweiterleitung und die ExportedType-Tabelle verfolgt
Wenn ein Typ von mscorlib nach System.Runtime wandert, behält das alte Assembly eine Weiterleitung: eine ExportedType-Zeile mit dem Weiterleitungs-Flag, die auf ein neues AssemblyRef zeigt. Eine Weiterleitung hat keine Member, deshalb darf ein Decompiler sie nicht als Typ darstellen: Er muss der Weiterleitung bis zur echten Definition folgen. Dieser Artikel zeigt, wo die Weiterleitung in den Metadaten liegt, wie Glass.NET eine Weiterleitungskette auflöst, wie es sich sauber verhält, wenn das Ziel-Assembly fehlt, und wie es [assembly: TypeForwardedTo(...)] wieder ausgibt, wenn man die Fassade selbst dekompiliert.
Lesen →Den WinForms-Designer beim Dekompilieren rekonstruieren
Eine kompilierte WinForms-App hat weder .Designer.cs noch .resx — der Designer-Code wurde als InitializeComponent() in einen einzigen Typ zusammengeführt, und die UI-Texte und -Bilder liegen in einem eingebetteten .resources-Stream. So rekonstruiert Glass.NET ein originalgetreues InitializeComponent() aus der Binärdatei, macht die ComponentResourceManager-Werte sichtbar und lässt dich die eingebetteten Ressourcen exportieren — alles statisch, alles kostenlos.
Lesen →Die IL-Ansicht lesen und Metadaten-Tokens in Glass navigieren
Eine ausführliche Erklärung zum Wechsel in die IL-Ansicht in Glass, zum Dekodieren von Metadaten-Tokens (0x06 MethodDef, 0x0A MemberRef, 0x70 UserString), zum Lesen des Methodenrumpf-Headers und zum Anklicken eines Tokens, um zu seiner Definition zu springen.
Lesen →Variablennamen und Zeilennummern aus PDBs wiederherstellen
Ein Decompiler rekonstruiert C# aus IL und Metadaten, doch Namen wie V_0 und V_1 sind verloren. So liest Glass portable PDBs (eingebettet, daneben liegend oder über Source Link bezogen), um echte Namen lokaler Variablen und Parameter wiederherzustellen, dekompilierten Code mit Originalquelldatei und -zeile zu annotieren und den tatsächlichen Quellcode abzurufen, und wie es elegant abbaut, wenn keine Symbole vorhanden sind.
Lesen →Lizenzberechtigungen in gRPC-Diensten durchsetzen
Ein gRPC-Dienst hat weder eine MVC-Filter-Pipeline noch ein [Authorize]-Attribut, an das man eine Lizenzprüfung hängen könnte — der einzige Punkt, der jeden Aufruf sieht, ist der Server-Interceptor. Dieser Beitrag schreibt einen LicensingInterceptor, der eine Keyright-Lizenz einmal validiert, jede gRPC-Methode auf eine erforderliche Berechtigung abbildet und mit dem richtigen Status fail-closed scheitert: FailedPrecondition ohne gültige Lizenz, PermissionDenied wenn die Lizenz die Berechtigung nicht trägt, ResourceExhausted wenn ein numerisches Limit erschöpft ist. Dazu ein gecachter heißer Pfad, der nie zum Ausstellungsdienst zurückreist, die DI-Registrierung via AddGrpc und die Streaming-Varianten.
Lesen →Node-Locking von Aktivierungen und Fingerabdruck-Drift überstehen
Eine node-locked Lizenz bindet einen Sitzplatz an eine Maschine. Die Bindung ist ein Maschinen-Fingerabdruck: ein stabiler, gesalzener Hash aus Hardware- und Betriebssystemsignalen, niemals aus rohen Hardware-Kennungen. Diese Analyse zeigt, wie das Keyright-SDK den Fingerabdruck berechnet und in ActivateAsync sendet, wie der Ausgabedienst verschiedene Fingerabdrücke als aktive Geräte zählt und das reale Betriebsproblem des Fingerabdruck-Drifts: Ein VM-Klon, eine neu aufgesetzte Platte, eine getauschte Netzwerkkarte oder ein RAM-Upgrade verändern den Fingerabdruck, die Maschine wirkt neu und die Sitzplätze sind erschöpft. Wir behandeln gewichtete Mehrsignal-Fingerabdrücke, Toleranzabgleich, Deaktivierung und Lease-Ablauf zur Rückgewinnung von Sitzplätzen sowie das Fail-Closed-Gating.
Lesen →Einen geleakten Lizenzschlüssel über alle Clients widerrufen
Ein Schlüssel wurde geteilt, auf einer Paste-Seite veröffentlicht oder aktiviert sich von drei Kontinenten gleichzeitig. Hier ist der praktische Leitfaden: wie Sie ihn in Keyright widerrufen, was Widerruf serverseitig bedeutet und — der Teil, den die meisten Teams falsch machen — wie ausgerollte SDK-Clients es tatsächlich erfahren und aufhören zu funktionieren.
Lesen →Das Keyright-SDK mit Resilienz in ASP.NET Core einbinden
Teams, die den Keyright-Client ad hoc instanziieren, laufen in einen der beiden klassischen HttpClient-Fehler: Socket-Erschöpfung durch einen Client pro Aufruf oder veraltetes DNS durch einen einzigen, dauerhaft gehaltenen statischen Client. Dieser Beitrag registriert den Keyright-Client über IHttpClientFactory als typisierten Client, damit Message-Handler korrekt gepoolt und rotiert werden, wählt die richtigen DI-Lebensdauern und legt eine Resilienz-Pipeline darüber — Timeout, Retry mit Jitter und einen auf einen Lizenzaufruf abgestimmten Circuit Breaker — sodass ein kurzer Aussetzer des Issuing-Service elegant degradiert statt hart zu scheitern.
Lesen →Eine Lizenz direkt von Test auf Bezahlt hochstufen
Wenn ein Kunde einen Test in eine Bezahlversion umwandelt oder von Standard auf Pro wechselt, sollte sich die bereits aktivierte Schlüsselzeichenkette nicht ändern. So aktualisieren Sie eine Lizenz serverseitig mit Keyright — Test-Flag entfernen, Ablauf verlängern, Entitlements hinzufügen — damit die bereitgestellte SDK-App die neue Zusage beim nächsten ValidateAsync übernimmt, ohne Reaktivierungsaufwand, sowie wie Sie das Revalidierungsintervall einstellen, den Upgrade-Aufruf idempotent halten und jede Entitlement-Änderung protokollieren.
Lesen →Eine Dapper-Schicht obfuskieren, ohne das Spalten-Mapping zu zerstören
Dapper ordnet die Spaltennamen des Ergebnissatzes zur Materialisierungszeit den öffentlichen Membern Ihres POCO nach Namen zu, ohne auf Groß-/Kleinschreibung zu achten. Benennen Sie diese Member mit einem Obfuskator um, und Dapper hört stillschweigend auf zuzuordnen – keine Ausnahme, nur eine Eigenschaft, die auf null oder 0 bleibt. Hier ist das vollständige Bild: wie Dappers Standard-Typehandler eine Spalte genau an einen Member bindet, warum Ihr SQL-Text in der Regel sicher ist, die Member Ihres POCO aber fragil sind, die Ausweichmöglichkeiten per benutzerdefiniertem Mapping und die präzise nebula.config.json-Keep-List, die die Ergebnis-POCOs fixiert, während der Rest der Datenschicht umbenannt wird.
Lesen →Eine MassTransit-Anwendung obfuskieren, ohne das Routing zu zerstören
MassTransit leitet die Identität einer Nachricht — ihren MessageUrn, etwa urn:message:Contoso.Ordering.Contracts:OrderSubmitted — aus dem .NET-Namespace und dem Namen des Vertragstyps ab und benennt damit den Exchange bzw. das Topic des Brokers und stempelt ihn in den messageType-Header des Umschlags. Producer und Consumer, oft getrennt deployt, müssen sich darauf einigen. Wenn du nach dem Build obfuskierst, ändert das Umbenennen des Vertragstyps oder seines Namespace den URN, sodass der Producer in einen anderen Exchange veröffentlicht und einen anderen messageType stempelt, und bestehende Consumer still aufhören zu empfangen. Dieser Artikel erklärt genau, wie der URN aus dem Typ aufgebaut wird, warum die Message-Contract-Assembly die fragile Oberfläche ist, und wie du die Namespaces, Namen und Eigenschaften der Verträge mit einer Nebula.NET-Keep-List fixierst, während du Consumer, Sagas und Internes umbenennst.
Lesen →Warum protobuf-net das Umbenennen überlebt
protobuf-net serialisiert anhand der numerischen Tags in [ProtoMember(N)], nicht anhand der Mitgliedsnamen — das Umbenennen eines protobuf-net-DTO ist daher auf der Leitung ungefährlich, anders als bei System.Text.Json oder DataContract, wo die Namen DER Vertrag sind. Hier erfahren Sie, warum das Umbenennen von Eigenschaften bei protobuf-net praktisch kostenlos ist, und welche vier Fälle dennoch brechen: implizite Feldnummerierung, Typnamen in ProtoInclude/AsReference, per Reflexion über Mitgliedsnamen aufgebaute Modelle und ProtoEnum-Namen.
Lesen →Einen Refit-REST-Client obfuskieren, ohne ihn zu zerstören
Refit baut aus einem C#-Interface einen HTTP-Client, aber die Gestalt auf der Leitung ergibt sich aus den Attributen — [Get("/users/{id}")], [Header], [Body], [Query] — nicht aus dem Typ- oder Methodennamen des Interfaces. Der Interface-Name, seine Methoden und die generierte Implementierung lassen sich daher frei umbenennen. Die einzige echte Gefahr sind die Parameternamen, die sich über ihren Namen an Pfad- und Query-Schlüssel binden; [AliasAs] entkoppelt sie, damit Nebula alles umbenennen kann.
Lesen →Einen WCF-Dienst verschleiern, ohne den Vertrag auf der Leitung zu brechen
Nebula benennt die internen Bestandteile Ihres WCF-Dienstes um und verschlüsselt sie, während eine Keep-Liste jeden [ServiceContract], [DataContract] und [DataMember] namentlich festpinnt — so bleiben die SOAP-Elementnamen, das WSDL und bestehende Clients Byte für Byte kompatibel.
Lesen →Was CallerArgumentExpression in Aufrufe einbrennt
Wenn du ArgumentNullException.ThrowIfNull(x) oder ein eigenes Guard.Against(x) aufrufst, übergibst du ein Argument. Der kompilierte IL schiebt zwei: deinen Wert und ein String-Literal mit dem exakten Quelltext deines ersten Arguments – weil der Parameter [CallerArgumentExpression] trägt. Das Attribut lebt in den Metadaten des Parameters; der erfasste Text lebt als schlichtes ldstr an jeder Aufrufstelle. Ein naiver Dekompiler gibt dir das überflüssige zweite Argument zurück. Dieser Beitrag liest den IL und den Attribut-Blob, erklärt, warum das Literal dort ist, und zeigt Schritt für Schritt, wie Glass.NET das Attribut erkennt, das Literal mit dem rekonstruierten Ausdruck abgleicht, das synthetisierte Argument unterdrückt und die Methodendeklaration mit intaktem Attribut wiederaufbaut.
Lesen →Wie Flags-Enums zu benannten Werten dekompilieren
Eine Flag-Kombination wie Read | Write wird schon vor dem IL zu einem einzigen Integer-Literal zusammengefaltet, sodass das von dir geschriebene | verschwindet. Diese Analyse liest den echten IL von Flag-Code, erklärt die Metadaten-Signale von FlagsAttribute und benannten Konstanten, mit denen ein Dekompiler einen rohen Integer in eine Summe benannter Member zerlegen kann, und zeigt, wie Glass.NET die Muster | & ~ und HasFlag rekonstruiert, statt dir (Permissions)3 zu hinterlassen.
Lesen →Wie explizites Struct-Layout und Unions dekompilieren
Explizites Struct-Layout ist eines der wenigen C#-Features, das ein Dekompilierer nicht aus den Formen des Codes wiederherstellen kann, denn es hinterlässt keinen Code – es lebt vollständig in den Metadaten. Der LayoutKind (Sequential/Explicit/Auto) ist ein Flag auf der Typdefinition, Pack und Size stehen in der ClassLayout-Tabelle, und der Byte-Offset jedes Felds steht in der FieldLayout-Tabelle. Teilen sich zwei Felder einen Offset, hast du eine Union im C-Stil: aliasierte Bytes, ein int, der dieselben vier Bytes sieht wie ein float. Ein einziger falscher Offset, und der dekompilierte Struct beschädigt stillschweigend jeden Interop- und Marshalling-Aufruf, der ihn berührt. Dieser Beitrag zeigt, wo die Layout-Daten liegen, wie Glass.NET die Tabellen ClassLayout und FieldLayout liest und [StructLayout(LayoutKind.Explicit, Pack = ..., Size = ...)] auf dem Typ und [FieldOffset(n)] auf jedem Feld wieder ausgibt, wie es eine Union an überlappenden Offsets erkennt und warum das Bewahren der exakten Offsets nicht verhandelbar ist.
Lesen →Wie Modulinitialisierer in .NET dekompilieren
Eine mit [ModuleInitializer] markierte Methode läuft vor allem anderen in der Assembly, aber das Attribut ist nicht das, was die Runtime aufruft. Der C#-Compiler erzeugt einen statischen Konstruktor auf dem speziellen Pseudotyp <Module>, der jeden Initialisierer der Reihe nach aufruft. Hier ist das exakte IL, das der Compiler erzeugt, die Metadaten-Signale, die den <Module>-cctor markieren und ihn von einem gewöhnlichen Typinitialisierer unterscheiden, und wie Glass.NET das Ganze zu den [ModuleInitializer]-Methoden zurückliest, die Sie geschrieben haben.
Lesen →Wie die Range- und Index-Operatoren von C# dekompilieren
Die Operatoren ^ und .. sind reiner Compiler-Zucker. a[^1] wird zu Arithmetik auf der Länge der Sammlung reduziert, a[1..^1] baut aus zwei System.Index-Werten einen System.Range und ruft RuntimeHelpers.GetSubArray auf, ein Span-Bereich wird zu Span<T>.Slice, und ein String-Bereich wird zu String.Substring. Ein naiver Dekompiler zeigt die rohen Konstruktoraufrufe und die Länge-minus-n-Arithmetik; Glass.NET erkennt diese Muster und faltet sie zurück zu ^ und .. — einschließlich des subtilen Falls, in dem span.Slice(1, 2) und span[1..3] byteidentisches IL erzeugen, sodass Glass die Lesart wählen muss, die einen verlustfreien Round-Trip ergibt.
Lesen →Wie Glass eine C#-switch-Anweisung aus einer IL-Sprungtabelle rekonstruiert
Ein C#-switch über einen dichten Ganzzahlbereich kompiliert nicht zu einer Kette von Vergleichen, sondern zu einem einzigen switch-IL-Opcode, der eine Tabelle von Sprungzielen trägt und durch den switch-Wert indiziert wird. Dieser Artikel zeigt, wie diese Sprungtabelle aussieht, wie der Compiler den Wert durch Subtraktion des kleinsten Falls normalisiert, warum dünn besetzte switch zu if/else-Ketten mit Binärsuche werden, und wie Glass.NET das resultierende Gewirr aus gotos in ein sauberes switch (x) { case 10: ... } zurückverwandelt.
Lesen →Lizenz-Entitlements vs. Feature Flags
Ein Feature Flag ist ein operativer Schalter, den Sie steuern; ein Lizenz-Entitlement ist eine signierte kommerzielle Berechtigung, für die der Kunde bezahlt hat. Verwechselt man beides, schaltet ein Kunde ein Flag um und schaltet frei, was er nie gekauft hat. Dieser Beitrag zieht die Grenze, zeigt die Fehlerbilder des falschen Werkzeugs, liefert eine Entscheidungstabelle und verdrahtet die kombinierte Keyright-Architektur: Entitlements als harte Schranke, Feature Flags darüber für das Rollout innerhalb dessen, worauf der Kunde Anspruch hat.
Lesen →Nach gleichzeitiger Nutzung lizenzieren mit Floating-Seats
Die knotengebundene Aktivierung bindet eine Lizenz an eine Maschine. Floating-Lizenzierung bindet sie an die gleichzeitige Nutzung: Sie kaufen 25 Seats, und beliebige 25 Ihrer 400 Installationen dürfen gleichzeitig laufen. Der Mechanismus ist ein Lease: Ein Client checkt einen Seat aus, hält ihn mit Heartbeats und gibt ihn beim Beenden zurück. Ein abgestürzter Client gibt nie zurück, also läuft sein Lease einfach ab und der Seat kehrt in den Pool zurück. So bauen Sie Concurrent-Seat-Lizenzierung auf einer selbstgehosteten Keyright-Instanz mit Lease-Checkout, serverseitiger Zählung, TTL-basierter Rückgewinnung und einer eleganten Behandlung des Falls „alle Seats belegt".
Lesen →Idempotenzschlüssel für wiederholungssichere Lizenzoperationen
Ein Lizenz-Schreibvorgang, der in einen Timeout läuft, lässt Sie im Dunkeln: Wurde der Sitzplatz verbraucht oder nicht? Wiederholen Sie, riskieren Sie, einen Kreditpool doppelt zu belasten oder einen Sitzplatz zweimal zu verbrennen; geben Sie auf, haben Sie vielleicht eine Lizenz verkauft, die Sie nie geliefert haben. Das ist das Problem der verlorenen Antwort, auf das jeder vernetzte Lizenz-Client trifft, und die Lösung ist ein Idempotenzschlüssel, der einen At-least-once-Transport in Exactly-once-Effekte verwandelt. So bleiben Aktivierung, Verbrauchszählung, Ausstellung und Deaktivierung auch bei Wiederholungen gegen Ihre selbstgehostete Keyright-Instanz korrekt.
Lesen →Eine .NET-App mit flüchtiger Maschinenidentität lizenzieren
Die knotengebundene Aktivierung bindet eine Lizenz an einen stabilen Maschinen-Fingerabdruck, doch Container erhalten bei jedem Neustart eine frische Identität, sodass naive Bindung Aktivierungen aufbraucht. So lizenzierst du eine containerisierte .NET-App mit Keyright: durch Einschleusen einer stabilen Deployment-Identität oder durch das Leasen gleichzeitiger Plätze für skalierte Replikas — und durch sauberes Fehlschlagen im geschlossenen Zustand beim Start.
Lesen →Ausgehende Lizenz-Event-Webhooks von Keyright
Hören Sie auf, die Lizenz-API abzufragen, um zu erfahren, was sich geändert hat. So pusht Keyright signierte Lifecycle-Events — aktiviert, widerrufen, erneuert, bald ablaufend — an Ihren eigenen Endpoint, und so verifizieren Sie die Signatur, überstehen At-least-once-Zustellung und weisen Replays auf der Empfängerseite ab.
Lesen →Kulanzfenster für einen vorübergehenden Lizenzserver-Ausfall
Eine Online-Lizenzprüfung, die sofort hart fehlschlägt, sobald Ihr Keyright-Ausstellungsdienst kurz nicht erreichbar ist, macht aus einem DNS-Aussetzer oder einem Routine-Deployment einen für Kunden sichtbaren Ausfall. Dieser Artikel zeigt, wie Sie vorübergehende Ausfälle mit einem konfigurierbaren Kulanzfenster über einem signierten, zwischengespeicherten Validierungsergebnis abfedern: indem Sie „Dienst nicht erreichbar" (vorübergehend, weiterlaufen) von „Lizenz widerrufen" (endgültig, sofort fail-closed) unterscheiden, die Kulanz über die vom Dienst selbst signierten Zeitstempel begrenzen, damit niemand sie durch Trennen des Netzes verlängert, jeden Cache-Lauf protokollieren und sauber fail-closed gehen, sobald das Fenster erschöpft ist.
Lesen →Eine .NET-AWS-Lambda obfuskieren, ohne den Handler zu zerstören
Die verwaltete .NET-Laufzeit von AWS Lambda findet Ihren Code über einen Handler-String der Form Assembly::Namespace.Type::Method, den sie bei jedem Kaltstart per Reflection auflöst. Obfuskieren Sie nach dem Build, verschiebt die Umbenennung den Handler-Typ oder die Methode weg von unter diesem String: Die Assembly ist gültig, aber Lambda kann den Einstiegspunkt nicht auflösen, und die Invocation schlägt fehl, bevor Ihr Code läuft. Dieser Beitrag erklärt, wo der Handler-String lebt, welche Symbole die verwaltete Laufzeit und der Lambda-Serializer über den Namen auflösen, wie Sie genau diese mit einer Nebula.NET-Keep-List fixieren und alles andere umbenennen, und wie Sie nebula protect in dotnet lambda package einbinden.
Lesen →Eine Azure-Functions-App obfuskieren, ohne die Funktionserkennung zu brechen
Der isolierte .NET-Worker findet Ihre Funktionen über einen quellcodegenerierten Metadaten-Provider, der den Einstiegspunkt jeder Funktion zur Compile-Zeit als Zeichenkettenliteral — "Namespace.Class.Method" — in die Assembly einbäckt. Verschleiern Sie danach, verschiebt das Umbenennen die Methode aus der Reichweite der Zeichenkette, sodass der Functions-Host Ihre App lädt und dann keine einzige Funktion mehr findet. Dieser Beitrag erklärt genau, welche Namen das isolierte Modell zur Laufzeit auflöst, wie man die Trigger-Methoden und Binding-DTOs mit Nebula.NET auf eine Keep-List setzt und wie man die Geschäftslogik, die der ganze Daseinsgrund der Funktion ist, mit Zeichenkettenverschlüsselung und Virtualisierung schützt.
Lesen →Ein globales .NET-Tool obfuskieren, ohne die Befehle zu zerstören
Ein dotnet tool ist ein NuGet-Paket, gegen das niemand kompiliert — Sie können also weit aggressiver umbenennen als bei einer Bibliothek. Hier erfahren Sie, wie Sie die DLL im Paket schützen und dabei den Einstiegspunkt, die Befehlsnamen und `dotnet tool install` funktionsfähig halten, mit Nebula.NET.
Lesen →Eine Hangfire-Anwendung obfuskieren, ohne die Jobs zu zerstören
Hangfire serialisiert jeden eingereihten, geplanten oder wiederkehrenden Job als voll qualifizierten Typnamen, Methodennamen und Parametertypen in seinen Speicher und löst das beim Ausführen durch einen Worker per Reflection wieder zu einem MethodInfo auf — möglicherweise auf einem späteren Deployment. Obfuskiert man nach dem Build, verschiebt die Umbenennung die Job-Klasse oder ihre Methode aus diesen gespeicherten Zeichenketten heraus, sodass jeder laufende und wiederkehrende Job mit einem Typ-nicht-gefunden-Fehler an der Deserialisierung scheitert. Dieser Beitrag erklärt genau, was Hangfire in seinen Speicher schreibt, warum wiederkehrende und lange aufgeschobene Jobs die schärfste Kante sind, und wie man die Job-Klassen, die aufgerufenen Methoden und ihre Parametertypen mit einer Nebula.NET-Keep-List fixiert und alles andere umbenennt.
Lesen →Stark typisierte Konfiguration obfuskieren, ohne die Bindung zu zerstören
Der Konfigurationsbinder ordnet die Schlüssel aus appsettings.json und Umgebungsvariablen per Reflexion den öffentlichen Eigenschaftsnamen Ihres Options-POCO zu. Benennen Sie diese Eigenschaften in einem Obfuskierungsdurchlauf um, werden die gebundenen Werte zur Laufzeit stillschweigend null oder der Standardwert — kein Kompilierfehler, keine Ausnahme, nur falsches Verhalten. Dieser Artikel liest, wie `services.Configure<T>` Schlüssel auf Eigenschafts-Setter auflöst, was der quellgenerierte Binder von .NET 8+ daran ändert und was nicht, wie Sie eine Keep-List in nebula.config.json aufbauen, die die öffentlichen Eigenschaftsnamen und den parameterlosen Konstruktor Ihrer Options-Klassen fixiert, während alles andere umbenannt wird, und wie Sie in Glass.NET bestätigen, dass die Options-Oberfläche überlebt hat.
Lesen →Eine SignalR-Anwendung obfuskieren, ohne die Hub-Methoden zu zerstören
SignalR verteilt jede Echtzeitnachricht, indem es eine Zeichenkette auf eine Methode abbildet. Ein Client ruft `connection.InvokeAsync("SendMessage", ...)` auf und registriert `hubConnection.On("ReceiveMessage", ...)`, und der Server löst diese Zeichenketten zur Laufzeit per Name auf Hub-Methoden auf. Benennt man eine öffentliche Hub-Methode oder ein Mitglied einer stark typisierten Client-Schnittstelle um, schlägt die Verteilung stillschweigend fehl: Die Verbindung bleibt bestehen, aber die Nachricht kommt nie an. Dieser Beitrag zeigt, wie der Dispatcher von SignalR die Zielzeichenkette der Invocation auf Ihre Hub-Methode abbildet, warum `[HubMethodName]` und `Hub<T>` ändern, welche Namen kritisch sind, wie man eine Keep-Liste in nebula.config.json aufbaut, die genau die auf der Leitung sichtbare Methodenoberfläche fixiert und dabei Hub-Rümpfe, interne Dienste und DTO-Interna umbenennt, und wie man in Glass.NET bestätigt, dass nur die vorgesehenen Namen überlebt haben.
Lesen →Wie Boxing und Unboxing in C# dekompilieren
Eine implizite Konvertierung von int nach object ist in C# unsichtbar, alloziert aber auf dem Heap — und die IL sagt es deutlich mit einem box-Opcode. Dieser Beitrag zeigt, woher box, unbox.any und das constrained.-Präfix kommen, warum generischer Code constrained. nutzt, um einer Boxing-Allokation auszuweichen, und wie Glass.NET lesbares C# rekonstruiert, während die IL die Allokation offenlegt, die der Quelltext verbirgt.
Lesen →Top-Level-Anweisungen in dekompiliertem C# lesen
Eine Datei mit Top-Level-Anweisungen hat keine sichtbare Klasse und kein sichtbares Main, die Assembly aber schon. Der C#-Compiler verpackt deine Anweisungen in eine interne Klasse namens Program und in eine Einstiegsmethode mit dem unaussprechlichen Namen <Main>$, markiert durch die Direktive .entrypoint. Hier steht genau, was der Compiler im synchronen und im async-Fall emittiert, warum der Einstiegspunkt die Methode ist, die du niemals von Hand schreiben kannst, wohin deine global usings verschwunden sind und wie Glass.NET das Ganze als das Top-Level-Programm zurückliest, das du geschrieben hast.
Lesen →.NET über die Kommandozeile oder einen KI-Assistenten dekompilieren
Glass.NET 1.3.0 bringt eine headless CLI und einen MCP-Server mit. Rekonstruieren Sie ein baubares C#-Projekt oder ein einzelnes Member mit glass export, erzeugen Sie eine SBOM, prüfen Sie die Echtheit eines NuGet-Pakets, vergleichen Sie zwei Builds und lassen Sie einen KI-Assistenten dekompiliertes C# über einen Model-Context-Protocol-Server mit glass mcp lesen — alles statische Analyse, alles kostenlos.
Lesen →Nutzung je Feature mit mehreren Kredit-Pools messen
Echte Produkte messen mehr als eine Sache — KI-Tokens, Render-Minuten, Exporte — und alles in einen einzigen Kredittopf zu werfen verschleiert die Kosten und blockiert unbeteiligte Funktionen, sobald eine erschöpft ist. So modellieren Sie mehrere unabhängige Kredit-Pools auf einer Keyright-Lizenz: die Form eines Pools, idempotentes Zählen pro Pool, das isoliert fail-closed verhält, die Abbuchungsreihenfolge vom inkludierten Kontingent zur Prepaid-Aufladung, atomare Abbuchungen über mehrere Pools für eine Operation, die zwei Zähler gleichzeitig verbraucht, und der pro-Pool-Abgleich, der auch offline funktioniert.
Lesen →Für immer die Versionen ausführen, die Sie bezahlt haben
Eine unbefristete Lizenz mit Wartungsfenster erlaubt es einem Kunden, jede während seiner aktiven Updates veröffentlichte Version für immer auszuführen – aber nicht die Versionen, die Sie nach deren Ablauf veröffentlichen. So modellieren Sie das in einer einzigen signierten Keyright-Lizenz: ein maintenance-through-Claim, das in Ihr Assembly eingebettete Veröffentlichungsdatum des Builds und der eine Vergleich, der niemals fehlgeschlossen werden darf.
Lesen →KI-Funktionen und autonome Agenten lizenzieren
Keyright 2.9.0 fügt erstklassige KI- und Agenten-Entitlements hinzu: Benennen Sie die Modelle, Endpoints und Tools, die ein Kunde aufrufen darf, begrenzen Sie einen autonomen Agenten mit einem Kreditbudget und einem Lease, und setzen Sie alles fail-closed und offline aus einer signierten Lizenz durch — mit einem gemessenen POST /v1/consume für laufende Nutzung. Hier sind die Form des Entitlements, das signierte JSON, die SDK-Helper in C#, Node, Python und Java sowie ein konkretes Szenario, das ein nicht lizenziertes Modell verweigert.
Lesen →Eine lokalisierte .NET-Anwendung obfuskieren, ohne die Ressourcen zu zerstören
Eine lokalisierte Anwendung löst ihre Übersetzungen zur Laufzeit per Name auf, und genau diese Art der Suche kann die Obfuskation stillschweigend zerstören. Die Überraschung: Die beiden gängigen Lokalisierungsstile verhalten sich beim Umbenennen gegensätzlich. Ein klassischer, vom Designer erzeugter .resx-Accessor ist sicher, weil der Basisname seines ResourceManager ein bereits eingebettetes String-Literal ist, während IStringLocalizer<T> fragil ist, weil die Factory den Basisname aus dem vollständigen Namen des Markertyps ableitet: Benennt man diesen Typ um, schlägt die Suche fehl, das Satellitenassembly wird nie konsultiert, und der Localizer gibt stillschweigend den Ressourcenschlüssel statt der Übersetzung zurück. Dieser Artikel liest, was jeder Stil ausgibt, zeigt, warum der eine überlebt und der andere nicht, und gibt die präzisen Nebula.NET-Beibehaltungsregeln, damit Ihre Übersetzungen in jeder Kultur weiter geladen werden.
Lesen →Eine WinUI-3-App obfuskieren, ohne das XAML zu zerstören
WinUI 3 kompiliert {x:Bind} zu einer generierten Bindungsklasse in Ihrer eigenen Assembly — ein typisierter Getter-Aufruf per Metadaten-Token plus ein literaler PropertyName-Vergleich —, sodass sich das gesamte View Model sauber umbenennen lässt. Die Fehler, die bleiben, sind die drei Stellen, an denen WinUI oder Ihr eigener Code noch über eine Zeichenkette geht: ein per Reflexion aufgelöster klassischer {Binding}-Pfad, eine per Type.GetType aus einem zusammengesetzten Namen gefundene Seite und ein Typ, den das Package.appxmanifest über seinen literalen Namen aktiviert. Dieser Beitrag liest den generierten Bindungscode, zeigt, warum {x:Bind} eine vollständige Umbenennung übersteht, während {Binding} leer zurückkommt, erklärt, welche benutzerdefinierten Abhängigkeitseigenschaftsnamen wirklich tragend sind, und gibt die Nebula-Konfiguration an, die die App einebnet, ohne die per Zeichenkette aufgelöste Oberfläche anzutasten.
Lesen →Ihre .NET-Obfuskierung in der CI verifizieren
Ein grüner Build ist kein Beweis, dass Ihre .NET-Assembly geschützt ist. Nebula.NET 2.2.0 erzeugt bei jedem Build einen stabilen, versionierten Schutzbericht und liefert `nebula verify` — eine CI-Schranke, die den Build mit einem eigenen Exit-Code fehlschlagen lässt, wenn Umbenennung, String-Verschlüsselung, Kontrollfluss oder Virtualisierung, die Sie angefordert haben, stillschweigend nicht angewendet wurden.
Lesen →Wie eine Blazor-WebAssembly-App dekompiliert
Eine Blazor-WebAssembly-App sendet Ihre .NET-Assemblies an den Browser — als webcil verpackt, aber mit vollständigem IL. Hier steht, wie man sie aus _framework zieht, in einem Dekompilierer liest und warum Ihr clientseitiges C# so offen liegt wie JavaScript.
Lesen →F#-kompilierte Assemblys in einem C#-Decompiler lesen
F# kompiliert zum selben IL wie C#, daher zeigt ein C#-Decompiler F#-Assemblys als C# an. Hier erfahren Sie, wie discriminated Unions, Records, Module und curried Funktionen erscheinen — und was Ihnen die CompilationMapping-Metadaten verraten.
Lesen →Wie P/Invoke und DllImport dekompilieren
P/Invoke-Deklarationen kompilieren zu pinvokeimpl-Methoden mit einer ImplMap. Hier steht, wie ein Dekompilierer [DllImport], MarshalAs und Aufrufkonventionen rekonstruiert — und wie man genau liest, welche nativen Funktionen eine unbekannte Assembly aufruft.
Lesen →Warum ReadyToRun-Assemblys weiterhin sauber dekompilieren
ReadyToRun-Images tragen vorkompilierten nativen Code — und dekompilieren dennoch so leicht zu C# wie jede Assembly, weil das IL weiterhin vorhanden ist. Hier steht, was R2R tatsächlich speichert, wie man es erkennt und warum ein Dekompilierer die native Seite ignoriert.
Lesen →Lizenzaktivierung über Desktop-Auto-Updates hinweg bewahren
Auto-Updater, die jede Version in einen neuen Ordner installieren, verlieren still Ihre zwischengespeicherte Aktivierung und erzwingen bei jedem Update eine Neuaktivierung. Hier steht, wo die signierte Lizenz zu speichern ist, damit sie überlebt — je Updater.
Lesen →Software auf flüchtigen CI- und Cloud-Build-Agenten lizenzieren
Knotengebundene Lizenzierung setzt stabile Maschinen voraus. CI-Runner und autoskalierte Agenten entstehen und werden ständig zerstört, also sieht jede Ausführung wie eine neue Maschine aus und verbraucht einen Sitzplatz. So lizenzieren Sie flüchtige Rechenleistung, ohne Ihr Sitzplatzkontingent zu erschöpfen.
Lesen →Eine ClickOnce-App obfuskieren, ohne den Start zu verhindern
ClickOnce-Manifeste speichern einen Hash jeder Datei. Obfuskieren Sie nach deren Erzeugung, weigert sich die App mit einem Validierungsfehler zu starten. Hier steht die genaue Build-Reihenfolge, die Obfuskierung und ClickOnce koexistieren lässt.
Lesen →Code obfuskieren, der zur Laufzeit Code erzeugt
Wenn Ihre Anwendung zur Laufzeit IL erzeugt — DynamicMethod, TypeBuilder, Expression.Compile — kann die Umbenennung sie auf eine Weise zerstören, vor der der Compiler nie warnt. Hier steht genau, welche Codegenerierungs-Muster die Obfuskierung überstehen und welche Keep-Regeln brauchen.
Lesen →Die Assemblys eines Unity-Spiels sicher obfuskieren
Wie Sie das C# eines Unity-Spiels obfuskieren, ohne Szenen, Prefabs oder den Inspector zu zerstören — was Mono und IL2CPP jeweils schützen und welche exakten Keep-Rules die Serialisierung und Reflection von Unity verlangen.
Lesen →Partner Lizenzschlüssel sicher ausstellen lassen
Vertrieb über OEMs und Reseller bedeutet, dass Partner Schlüssel an ihre Kunden ausstellen — doch Sie dürfen Ihre Admin-Zugangsdaten nicht herausgeben. So funktioniert gescoptes, zugeordnetes, gedeckeltes Provisioning, und so bleibt jeder partnerausgestellte Schlüssel nachvollziehbar und widerrufbar.
Lesen →Lizenzierung pro Kern für .NET-Serversoftware
Lizenzierung pro Kern steht und fällt damit, Kerne korrekt zu zählen. Hier erfahren Sie, warum Environment.ProcessorCount in die Irre führt, wie Sie in .NET physische Kerne und Container-CPU-Quotas auslesen und wie Sie ein Kernzahl-Recht in eine signierte Lizenz binden.
Lesen →Angreifer daran hindern, Ihre .NET-Assembly zu dumpen
Obfuskierung auf der Festplatte hilft nicht mehr, sobald Ihre Assembly geladen und ihre Zeichenketten im RAM entschlüsselt sind — ein Speicherabbild fängt das ab. So beschädigt Anti-Dump-Schutz das PE im Speicher, damit ein Abbild keine nutzbare Assembly ist.
Lesen →Einen geschützten .NET-Build in Produktion debuggen
Sobald Sie obfuskieren, wird normales Debugging schwerer: umbenannte Frames, kein brauchbares Schrittweise-Durchgehen, PDBs, die Sie nicht auszuliefern wagen. Doch ein geschützter Build muss keine Blackbox sein. Hier ist der Ops-Leitfaden: warum Sie keine vollständigen PDBs ausliefern sollten, wie Sie einen umbenannten Produktions-Stacktrace mit der geseedeten Map zurückübersetzen, die Sie behalten haben, warum Diagnose zuerst über Logs läuft, und wie Sie Exception-Meldungen und Telemetrie nützlich halten, ohne Interna preiszugeben.
Lesen →Eine Single-File- oder eigenständige .NET-App mit Glass.NET dekompilieren
Sie haben eine .NET-App veröffentlicht, ziehen die .exe in einen Decompiler und es kommt nichts Lesbares heraus. Das Problem ist nicht der Decompiler — es ist, dass dotnet publish mehrere Formate hat und die meisten Ihnen kein verwaltetes Assembly dort liefern, wo Sie es erwarten. Hier steht, wo Ihr IL in einem eigenständigen, Single-File-, ReadyToRun- oder Native-AOT-Build wirklich liegt und wie Sie es in Glass.NET öffnen.
Lesen →Eingebettete Ressourcen aus einem .NET-Assembly mit Glass.NET extrahieren und lesen
Eine DLL trägt mehr als Code. In dieselbe Datei gebacken sind eingebettete .resources und ResX-Zeichenfolgen, lokalisierte Satellitenzeichenfolgen, ganze Dateien wie Config, JSON, SQL und Zertifikate sowie Zeichenfolgen- und Byte-Konstanten. So findet und liest man all das in Glass.NET — dem kostenlosen, rein statischen Decompiler, der das Assembly nie ausführt — und exportiert es auf die Platte, um es außerhalb des Werkzeugs zu prüfen.
Lesen →Sehen Sie mit Glass.NET, wovon ein .NET-Assembly abhängt und was es aufruft
Bevor Sie eine fremde DLL ausliefern, wollen Sie ihre externe Oberfläche kennen: welche Assemblys und Pakete sie referenziert, für welches Framework sie kompiliert ist, welche nativen Bibliotheken sie per P/Invoke aufruft und wo sie ins Netzwerk, ins Dateisystem oder zu einem anderen Prozess greift. So prüfen Sie all das statisch in Glass.NET — dem kostenlosen Decompiler, der die Binärdatei liest und nie ausführt.
Lesen →Unbekannten .NET-Fremdcode mit Glass.NET verstehen
Sie hängen von einer DLL ab, für die Sie keinen Quellcode haben — ein verwaistes Paket, eine interne Bibliothek, deren Autor weg ist, ein Anbieter-SDK mit dünner Doku — und müssen wissen, wie sie wirklich funktioniert. Hier ist ein konkreter Untersuchungsablauf in Glass.NET, dem kostenlosen, rein statischen .NET-Decompiler, der das inspizierte Assembly nie ausführt.
Lesen →Ihren Aktivierungs-Endpunkt vor Missbrauch schützen
Ihr Aktivierungs-Hotpath — /v1/activate und /v1/validate — ist absichtlich nicht authentifiziert: Es ist der Pfad, den die Apps Ihrer Kunden mit einem Lizenzschlüssel aufrufen, ohne Admin-Token. Sie verteidigen ihn also mit Lizenzlogik und Edge-Kontrollen, nicht mit Authentifizierung. Hier ist das mehrschichtige Vorgehen: Platzlimits und Node-Locking als natürliche Drossel, Erkennung doppelter Aktivierungen bei geteilten Schlüsseln und geklonten VMs, Widerruf eines geleakten Schlüssels, ein Rate-Limit oder eine WAF auf Ihrem eigenen Reverse-Proxy vor /v1/*, und strukturierte Lizenzprotokolle, die den Schlüssel schwärzen.
Lesen →Selbstgehostetes Keyright vollständig air-gapped betreiben
Selbstgehostetes Keyright braucht zur Laufzeit kein ausgehendes Internet. Es prüft seine eigene Selbstlizenz offline gegen Delta1s eingebetteten öffentlichen Schlüssel — ohne Phone-home, fail-closed bei Manipulation — und die Apps Ihrer Kunden validieren offline zwischen Aktivierungen. So installieren Sie die Selbstlizenz als Datei, deaktivieren die GeoIP-Abfrage, holen das Image in Ihre private Registry, betreiben es gegen Ihr eigenes Postgres und handhaben nutzungsbasierte Lizenzierung mit air-gapped Credit-Blöcken.
Lesen →Eine selbstgehostete Keyright-Instanz sichern und wiederherstellen
Selbstgehostetes Keyright ist eine zustandslose App, deren gesamter Zustand in Ihrem PostgreSQL liegt — Notfallwiederherstellung ist damit eigentlich Postgres-Sicherung plus das Absichern zweier Geheimnisse, die Sie erzeugen. Hier steht, was wirklich gesichert werden muss, welches Geheimnis den Unterschied zwischen einer Wiederherstellung und einer toten Datenbank ausmacht, und eine Wiederherstellungsübung, die einen Lizenzserver zurück auf den Aktivierungspfad bringt.
Lesen →Eine selbstgehostete Keyright-Instanz sicher aktualisieren
Ein Upgrade von selbstgehostetem Keyright ist unspektakulär, weil die App zustandslos ist und ihre eigenen Schema-Migrationen beim Start ausführt — kein SQL von Hand. Trotzdem wollen Sie ein sicheres Vorgehen: zuerst Postgres sichern, in einer Nicht-Produktivumgebung testen, das Image-Tag anpinnen und hinter Ihrem Load Balancer Knoten für Knoten aktualisieren. Hier ist die Abfolge, inklusive warum Rollback das Wiederherstellen der DB-Sicherung bedeutet und nicht das Herabstufen gegen eine bereits migrierte Datenbank.
Lesen →Auswählen, was in Nebula vom Umbenennen auszunehmen ist
Jeder Obfuskator lässt Sie Namen von der Umbenennung ausnehmen, und der erste Reflex, wenn etwas bricht, ist, zu viel auszunehmen. Eine Keep-List ist eine entworfene, minimale Grenze, keine Abstellkammer für alles, was gebrochen ist. Hier ist die Disziplin: was wirklich unbenannt bleiben muss (öffentliche API, Reflexionsziele, serialisierte DTOs, Options-Klassen, DI-Scanning, XAML, Einstiegspunkte eines Hosts), wie Sie es in nebula.config.json ausdrücken, wie Sie jeden Eintrag auf das geringste Mögliche verengen und wie Sie das Ergebnis in Glass.NET beweisen.
Lesen →Eine .NET-Lösung aus mehreren Projekten einheitlich obfuskieren
Eine Lösung mit einem Dutzend Klassenbibliotheken und einer App ist kein Dutzend Obfuskierungs-Probleme — es ist eines. Schützen Sie jedes Projekt isoliert, und Sie schützen transitive Kopien doppelt, brechen InternalsVisibleTo zwischen Ihren eigenen Assemblys und enden mit einem Haufen Umbenennungs-Maps, die nicht zusammenpassen. Hier ist der Leitfaden: entscheiden Sie, was Sie wirklich ausliefern, und schützen Sie nur das, führen Sie einen einzigen Durchlauf über die Publish-Ausgabe aus, steuern Sie jedes Assembly aus einer einzigen gemeinsamen nebula.config.json, benennen Sie die ganze Lösung um, damit Friend-Zugriff und Querverweise synchron bleiben, halten Sie eine geseedete Map pro Version und verdrahten Sie alles in die CI, damit jeder ausgelieferte Build identisch geschützt ist.
Lesen →Eine .NET-App obfuskieren, die auf AutoMapper und MediatR baut
Diese drei Bibliotheken sind das Rückgrat eines modernen ASP.NET-Core-Dienstes, und alle drei lösen zur Laufzeit Dinge auf — über Typ und über Eigenschaftsnamen — mittels Konvention und Assembly-Scanning. Deshalb verhalten sie sich unter der Umbenennung sehr unterschiedlich. AutoMapper paart Member über Eigenschaftsnamen, also hören umbenannte DTOs still auf zu mappen; MediatR findet Handler über die Form der Schnittstelle, also überlebt es meist unberührt; FluentValidation entdeckt Validatoren über die Form, meldet Fehler aber über Eigenschaftsnamen, also hält die Entdeckung, während Ihre PropertyName-Strings undurchsichtig werden. Hier steht genau, was in jedem bricht, die minimale Keep-Regel für jedes, eine konsolidierte nebula.config.json und wie Sie es mit Integrationstests und Glass.NET beweisen.
Lesen →Zwei Versionen eines .NET-Assemblys mit Glass.NET vergleichen
Sie haben die v1.2.0 und die v1.3.0 einer DLL und müssen genau wissen, was sich geändert hat — neue APIs, eine still veränderte Methode, ein neuer Netzwerkaufruf — ohne den Quellcode und ohne einen der beiden Builds auszuführen. So vergleichen Sie zwei Assembly-Versionen in Glass.NET, dem kostenlosen, rein statischen .NET-Decompiler.
Lesen →Selbstgehostetes Keyright über mehrere Knoten betreiben
Ihr Lizenzserver sitzt auf dem Aktivierungspfad Ihrer Kunden, er sollte also kein Single Point of Failure sein. Selbstgehostetes Keyright ist ein zustandsloser ASP.NET-Core-Dienst — der gesamte Zustand liegt in Ihrem PostgreSQL — Hochverfügbarkeit bedeutet damit nur, zwei oder drei Replicas hinter einem Load Balancer ohne Session-Affinität zu betreiben. So geht es genau.
Lesen →Selbstgebaute Lizenzschlüssel zu Keyright migrieren
Ein Schritt-für-Schritt-Migrationsplan, um von einem selbstgebauten Schlüsselsystem zu Keyright zu wechseln: inventarisieren, was Sie haben, signierte Lizenzen für bestehende Kunden ausstellen, einen Client veröffentlichen, der während eines Übergangsfensters beide Formate liest, und dann den alten Pfad stilllegen — alles, ohne einen einzigen Kunden zur Reaktivierung zu zwingen.
Lesen →Einen kopflosen .NET-Worker-Service schützen
Ein .NET-Worker-Service ist die am leichtesten aggressiv zu obfuskierende Art von App und die, deren Obfuskierung man am leichtesten ganz vergisst. Er wird als DLL auf den Server eines Kunden ausgeliefert, läuft kopflos als Windows-Dienst oder systemd-Unit und trägt Ihre Integrationsgeheimnisse und Ihre Geschäftslogik bei fast keiner zu schützenden Reflexionsoberfläche — was bedeutet, dass Sie nahezu alles umbenennen können. Dieser Beitrag behandelt, warum ein Hintergrund-Worker ein verlockendes Ziel für Reverse Engineering ist, die wenigen Nähte des Generic Host, die noch Namen lesen (Options-Binding, Assembly-Scanning, serialisierte DTOs), und wie Sie Nebula.NET in den Publish-Schritt einklinken, damit das ausgelieferte Binary umbenannt, seine Strings verschlüsselt und dort virtualisiert ist, wo es zählt.
Lesen →Eine Alternative zu SmartAssembly im Jahr 2026
SmartAssembly verbindet .NET-Obfuskierung mit automatischen Fehler- und Funktionsnutzungsberichten. Hier ist ein ehrlicher Vergleich mit Nebula.NET: worin jedes stark ist, welche modernen Ziele zählen und wie Sie an Ihrem eigenen Binary entscheiden.
Lesen →Hat Ihre Obfuskierung wirklich funktioniert? Prüfen Sie es in Glass.NET
Ein erfolgreicher Build ist kein Beweis, dass Ihr Code geschützt ist. Öffnen Sie das obfuskierte Assembly in Glass.NET — dem kostenlosen, rein statischen .NET-Decompiler — und lesen Sie es so, wie es ein Angreifer tun wird: bestätigen Sie, dass Umbenennung, String-Verschlüsselung, Kontrollfluss und Virtualisierung gehalten haben, und dass Sie Ihre öffentliche API nicht überschützt haben.
Lesen →Wie C#-Ausdrucksbäume dekompilieren
Dasselbe `x => x + 1` kompiliert auf zwei völlig verschiedene Arten, je nachdem, welchem Typ es zugewiesen wird. Als Delegat ist es eine versteckte Methode und ein ldftn; als Expression<Func<int, int>> ist es ein Geflecht aus Aufrufen von Expression.Parameter, Expression.Constant, Expression.Add und Expression.Lambda, in dem Member per ldtoken referenziert werden. Hier steht genau, was der Compiler für einen Ausdrucksbaum emittiert — erfasste Variablen als Constant einer Closure, Zeichenkettenvergleich mit seinem op_Equality, verschachtelte Lambdas in Quote verpackt — und wie ein Decompiler die Factory-Aufrufe zu der Lambda zurückfaltet, die Sie geschrieben haben.
Lesen →Eine .NET-App unter Linux und macOS lizenzieren
Die meisten Anleitungen zur Lizenzierung sind für Windows geschrieben, und das Keyright-SDK verbirgt das stillschweigend: dieselben Aufrufe von Validate() und ActivateAsync() funktionieren auf Linux und macOS. Aber die drei Dinge, auf die ein Lizenzierungs-SDK angewiesen ist — ein benutzerbezogener Datenordner, eine stabile Maschinenidentität und eine App, die oft genug neu gestartet wird, um ihre Lease aufzufrischen — sehen abseits von Windows alle anders aus. Die Lease landet in ~/.local/share, wohin eine Mac-App in der Sandbox oder ein systemd-Dienst mit ProtectHome= nicht schreiben kann. Der Maschinen-Fingerabdruck ist an /etc/machine-id oder der IOPlatformUUID verankert statt an einem Registrierungswert, und ein Golden Image, in dem die machine-id nicht geleert wurde, macht eine ganze Flotte zu einer Maschine. Und ein Daemon, der einmal im Quartal startet, bekommt nie die Auffrischung beim Start, auf die sich eine Desktop-App verlässt, sodass seine 14-Tage-Lease abläuft, während der Prozess noch läuft. Dieser Beitrag geht durch, wohin das SDK auf jeder Plattform schreibt, woraus der Fingerabdruck gebaut wird und welche zwei machine-id-Fallen es gibt, eine systemd-Unit mit StateDirectory= und LoadCredential=, die dem SDK ein Zuhause gibt, die Lease-Auffrischungsschleife, die ein lang laufender Dienst braucht, den Dateimodus, den die Lease auf einem Mehrbenutzer-Host verdient, und die Prüfschleife, die das alles belegt.
Lesen →Newtonsoft.Json-Typen obfuskieren, ohne das JSON zu zerstören
Newtonsoft.Json liest Ihr DTO über die Namen seiner Member per Reflexion — Customer wird auf dem Draht zu "Customer", weil die Property buchstäblich Customer heißt — sodass in dem Moment, in dem ein Obfuskator sie in a umbenennt, das JSON, das Ihr Dienst erzeugt, zu { "a": … } wird und jeder Konsument und jedes gespeicherte Dokument bricht, lautlos, zur Laufzeit. Json.NET hat keinen Quellcode-Generator zur Kompilierzeit, um diesem Reflexions-Durchlauf zu entkommen, daher ist das Festnageln der Namen mit [JsonProperty] keine Optimierung, sondern der gesamte Vertrag. Und es verbirgt eine zweite, schlimmere Falle: TypeNameHandling schreibt den assembly-qualifizierten Namen Ihres Typs als $type in das Dokument, sodass das Umbenennen eines Typs jede polymorphe Nutzlast bricht, die ein anderer Build je geschrieben hat — ein Fehler, den kein Attribut behebt. Dieser Beitrag legt fest, an welche Namen Json.NET bindet, warum [JsonProperty] und [EnumMember] die Drahtnamen zu Konstanten machen, die der Renamer nicht anfassen kann, warum der Deserialisierungs-Konstruktor eine zweite Namensbindung ist und warum TypeNameHandling einen stabilen ISerializationBinder statt einer Keep-Regel braucht. Er endet mit dem Round-Trip-Test, ausgeführt gegen den geschützten Build, der aus "die Serialisierung ist kaputt" einen fehlgeschlagenen Test statt einer Kunden-E-Mail macht.
Lesen →Wie C#-Zeichenketteninterpolation dekompiliert
Eine interpolierte Zeichenkette hat kein eigenes IL — der Compiler wählt eine von drei völlig verschiedenen Absenkungen, je nach Ziel-Framework, den Typen der Lücken und ob eine Methode sich für einen Handler entschieden hat. Hier steht genau, was `$"..."` als string.Concat, als string.Format und als DefaultInterpolatedStringHandler-Tanz erzeugt, dazu der Fall des benutzerdefinierten Handlers, bei dem die Zeichenkette nie gebaut wird, und wo ein Decompiler jede Form zu `$"..."` zurückfalten kann.
Lesen →Eine MSIX-paketierte Windows-App lizenzieren
MSIX ist heute der Weg, auf dem Windows-Desktop-Apps installiert werden — über winget, über Unternehmensbereitstellung, über den Store — und es ändert stillschweigend drei Dinge, auf die ein Lizenzierungs-SDK angewiesen ist. Schreibzugriffe auf %LocalAppData% werden in einen paketspezifischen Ordner umgeleitet, den die App nie in einem Pfad zu sehen bekommt. Das Deinstallieren des Pakets löscht diesen Ordner, sodass die zwischengespeicherte Aktivierungs-Lease, die lokale Testphasen-Uhr und der Uhrmanipulations-Zustand verschwinden, während der Platz auf dem Lizenzierungsdienst gebunden bleibt. Und das Installationsverzeichnis ist schreibgeschützt — genau dort, wo eine mitgelieferte Standortlizenz liegen sollte. Dieser Beitrag geht durch, was das Keyright-SDK schreibt und wo es unter einer paketierten App landet, warum der Maschinen-Fingerabdruck überlebt, wenn der Cache es nicht tut, was ein Deinstallations-/Neuinstallationszyklus mit der Platzzählung macht (nichts, dank idempotenter Aktivierung — es sei denn, der Kunde wollte umziehen), wie Sie die Paketidentität erkennen und dem SDK explizite Pfade geben, wie Sie eine Lizenz im Paket ausliefern, wann Sie die Schreibvirtualisierung im Manifest deaktivieren, und die Testschleife, die das alles belegt.
Lesen →Wie Nullable-Werttypen in C# dekompilieren
int? sieht aus wie ein Typ mit einem null darin, und in der IL ist es keines von beidem: es ist das generische Struct System.Nullable<int>, zwei Felder und nirgendwo ein null, und jede Operation, die die Sprache Sie darauf schreiben lässt, wird vom Compiler in Aufrufe auf diesem Struct umgeschrieben. a + b auf zwei int?-Werten wird zu einer HasValue-Konjunktion, zwei GetValueOrDefault-Aufrufen, einem add und einem newobj — oder einem initobj für das null-Ergebnis. a == b wird zu einem Wertvergleich, der per UND mit einem HasValue-Vergleich verknüpft ist. a == null wird zu einem einzigen HasValue-Aufruf. a ?? 5 wird zu einer Bedingung über HasValue. Und das Boxen eines int? tut etwas, das kein anderes Struct tut: die box-Anweisung liefert entweder ein geboxtes int oder eine null-Referenz, sodass Nullable<T> auf dem Heap nie existiert. Dieser Beitrag liest jede dieser Absenkungen in IL und folgt einem Decompiler dabei, sie zurück in die Operatoren zu falten, die der Autor geschrieben hat — warum das HasValue-und-GetValueOrDefault-Muster als Einheit erkannt werden muss, warum int? aus dem Signatur-Blob kommt und nicht aus einem Attribut (anders als string?), wie unbox.any auf einer null-Referenz stillschweigend ein leeres Nullable erzeugt, und was ein Decompiler falsch macht, wenn er die Absenkung statt der Sprache wiedergibt.
Lesen →Eine Keyright-Site-Lizenz an eine Domain binden
Ein Unternehmen, das vierhundert Arbeitsplätze kauft, will keine vierhundert Aktivierungen, und Sie wollen nicht, dass der Schlüssel, der sie alle freischaltet, auf dem Laptop eines Auftragnehmers das Haus verlässt. Die klassische Antwort ist eine Standortlizenz — ein Schlüssel für die ganze Organisation — und die Frage, die niemand aufschreibt, lautet: Woran ist der Schlüssel gebunden, wenn nicht an eine Maschine? Dieser Beitrag baut eine Standortlizenz auf Keyright als signierte Berechtigung, die die DNS-Domäne des Kunden nennt, optional durch die Windows-Domänen-SID fixiert: woher diese beiden Identitäten stammen (IPGlobalProperties.DomainName, nicht Environment.UserDomainName, und SecurityIdentifier.AccountDomainSid), warum der Suffix-Vergleich der richtige Vergleich für eine Gesamtstruktur mit untergeordneten Domänen ist, wie das Gate auf einem nicht beigetretenen Laptop geschlossen fehlschlägt, wie der Kunde Ihnen die Werte ohne Umweg über die IT liefert, und das ehrliche Bedrohungsmodell: ein Domänenname ist ein Richtlinienzaun, den ein entschlossener Angreifer durch Umbenennen einer VM umgehen kann, eine Domänen-SID hebt die Hürde bis zum Klonen eines Domänencontrollers, und keines von beiden ersetzt eine Platzzählung, wenn Sie wirklich eine brauchen.
Lesen →Warum Umbenennen Code bricht, der dynamic verwendet
Ein statischer Aufruf überlebt das Umbenennen, weil er über ein Metadaten-Token aufgelöst wird und der Obfuskator das Token zusammen mit dem Member umschreibt. Ein dynamic-Aufruf überlebt nichts: der C#-Compiler senkt settings.Timeout in eine Call-Site ab, deren Binder den String "Timeout" erhält, und zur Laufzeit durchsucht Microsoft.CSharp den tatsächlichen Typ des Empfängers nach einem Member mit exakt diesem Namen. Benennen Sie Timeout in a um, und die Site fragt weiter nach "Timeout", die Suche scheitert, und die App wirft RuntimeBinderException auf einer Zeile, die sauber kompilierte und auf dem ungeschützten Build jeden Test bestand. Dieser Beitrag liest die IL einer dynamic-Site, um zu zeigen, wo der Name lebt (ein ldstr, das Binder.GetMember und Binder.InvokeMember in einem versteckten <>o__-Container speist), erklärt, warum String-Verschlüsselung weder hilft noch schadet, warum kein Renamer das sicher automatisch beheben kann (der Typ des Empfängers ist erst bekannt, wenn der Aufruf läuft), welche dynamic-Operationen nach Namen binden und welche nicht (Indexer über Item, Operatoren über op_-Namen, ExpandoObject-Schlüssel nie), das Double-Dispatch-per-dynamic-Muster, das stillschweigend einen ganzen Visitor zerlegt, und die drei Korrekturen in Reihenfolge der Präferenz: dynamic durch ein Interface ersetzen, nur die Member fixieren, die eine Site erreicht, mit [Obfuscation(Exclude = true)], oder ein exclude-Eintrag in nebula.config.json — plus der eine Test, der es auf dem geschützten Build fängt.
Lesen →Wie Array-Initialisierer in C# dekompilieren
Schreiben Sie int[] x = { 1, 2, 3, 4, 5 }, und Sie erwarten vielleicht fünf stelem-Instruktionen, eine pro Element. Für ein kleines Array bekommen Sie ungefähr das, aber jenseits eines Schwellenwerts hört der C#-Compiler auf, Elemente einzeln zu speichern, und tut etwas Seltsameres: Er allokiert das Array und ruft dann RuntimeHelpers.InitializeArray mit einem Handle auf ein statisches Feld auf, dessen Bytes das ganze Array dicht gepackt sind, und dieses Feld hat im IL überhaupt keinen Initialisierer – seine Daten liegen in einer Datensektion der PE-Datei, auf die eine FieldRVA-Metadatenzeile zeigt, typisiert als synthetische Struktur in einer versteckten Klasse, deren einzige Eigenschaft ihre Bytelänge ist. Ein Decompiler kann das Literal nicht aus dem IL ablesen, weil das IL nur ein memcpy enthält; er muss das InitializeArray-Muster erkennen, das Feld-Token auflösen, der FieldRVA zu den rohen Bytes folgen, den Elementtyp aus dem vorangehenden newarr nehmen und den Little-Endian-Blob wieder in { 1, 2, 3, 4, 5 } aufteilen. Dieser Beitrag geht IL und Metadaten für ein blob-initialisiertes Array durch, zeigt, was Glass.NET rekonstruiert, erklärt, warum ein String-Array diesen Weg nie nimmt, und behandelt den ReadOnlySpan-of-byte-Fall, in dem es gar kein Array gibt – nur ein Feld-Handle und ein CreateSpan.
Lesen →Wie eine decimal-Konstante in .NET dekompiliert
Jedes andere numerische Literal in C# — 42, 3.14, 1_000_000L — landet im IL als ldc-Instruktion oder in der Constant-Tabelle der Metadaten, als Wert, den die Laufzeit direkt lädt. decimal kann das nicht: Es ist ein 128-Bit-Struct, kein primitiver Typ, für den die CLR einen Lade-Opcode hat. Eine const decimal oder ein decimal-Standardparameter hat also keinen nativen Platz, und der Compiler löst das mit einem Trick, über den jeder stolpert, der rohes IL liest — er kodiert die Zahl in ein [DecimalConstantAttribute], dessen fünf Konstruktorargumente (Skalierung, Vorzeichen und drei 32-Bit-Ganzzahlen) den exakten Wert buchstabieren. Dieser Beitrag folgt einem Decompiler durch diese Rekonstruktion: warum die Constant-Tabelle decimal ablehnt, wie die Argumente des Attributs auf die vier ints abgebildet werden, aus denen ein decimal gebaut wird, warum ein const-decimal-Feld in keinem Konstruktor einen Feldinitialisierer hat, worin sich ein decimal-Standardparameter von einem int-Standardparameter unterscheidet, und warum das Verwechseln des Attributs mit einer gewöhnlichen Annotation aus 3.14m ein new decimal(314, 0, 0, false, 2) statt eines Literals macht.
Lesen →Woran man eine Extension-Methode beim Dekompilieren erkennt
Eine Extension-Methode existiert zur Laufzeit nicht als Extension. Sie ist eine schlichte statische Methode, deren erster Parameter zufällig markiert ist, und ein Aufruf – text.Trim().Count() – kompiliert zu einem gewöhnlichen statischen Aufruf, Enumerable.Count(string.Trim(text)), ohne Punktsyntax, ohne Receiver, ohne irgendetwas, das verriete, dass er je fluent geschrieben wurde. Das Einzige, was der Compiler zurücklässt, ist ein [Extension]-Attribut: an der Methode, damit der erste Parameter mit this dargestellt werden kann, und an der umgebenden statischen Klasse, damit ein Werkzeug überhaupt weiß, dass es dort nachsehen soll. Ein Decompiler muss dieses Attribut lesen, entscheiden, dass ein statischer Aufruf, dessen Ziel es trägt, als Member-Aufruf auf seinem ersten Argument ausgegeben werden soll, und die Präzedenz richtig hinbekommen, damit eine Kette aus zehn LINQ-Operatoren als Kette zurückkommt und nicht als zehn Ebenen tief verschachtelte statische Aufrufe. Dieser Beitrag geht das IL für eine definierte Extension-Methode und für eine Aufrufstelle durch, zeigt, was Glass.NET rekonstruiert, erklärt, warum das Attribut – nicht der Aufruf – die maßgebliche Wahrheit ist, und behandelt die neuere Extension-Block-Form von C# 14, deren Member zu denselben statischen Methoden unter einer anderen Haut kompilieren.
Lesen →Wie volatile Felder in .NET dekompilieren
Das Schlüsselwort volatile hat keine eigene Laufzeit. Es kompiliert zu zwei separaten Metadaten-Stücken, die an verschiedenen Orten leben: einem Required Modifier, modreq(IsVolatile), der in die Signatur des Feldes eingeschweißt ist, und einem ein Byte langen volatile.-Prefix, der vor jedem ldfld und stfld steht, das das Feld anrührt. Ein Decompiler muss beide lesen, sich mit sich selbst darüber einig werden, welcher maßgeblich ist, und das Ergebnis dann nicht mit den beiden Dingen verwechseln, die in C# identisch aussehen, aber völlig unterschiedlich kompilieren – Volatile.Read auf einem gewöhnlichen Feld, was ein schlichter Aufruf ohne Prefix und ohne Modifier ist, und Interlocked.Increment auf einem volatile-Feld, das das Feld per Adresse nimmt und daher den Modifier trägt, aber nicht den Prefix. Dieser Beitrag geht das IL für alle drei durch, zeigt, was Glass.NET aus jedem rekonstruiert, erklärt, warum das Feldreferenz-Token selbst den modreq tragen muss, da der Zugriff sonst nicht einmal auflöst, und behandelt den einen Fall, den C# nicht buchstabieren kann – einen volatile.-Prefix ohne volatile-Feld dahinter – und den Aufruf, den Glass dafür emittiert.
Lesen →Welchen HTTP-Status sollte eine fehlgeschlagene Lizenzprüfung zurückgeben?
Wenn eine lizenzierte API entscheidet, dass ein Aufrufer nicht laufen darf, ist das Schlimmste, was sie tun kann, ein nackter 500 mit Stacktrace — und das Zweitschlimmste ein 200 mit { "ok": false }, den kein Client je bemerkt. Dieser Beitrag arbeitet den HTTP-Vertrag heraus, den ein Lizenz-Gate seinen Aufrufern tatsächlich schuldet: warum ein Lizenzfehler kein 401 ist (der Aufrufer ist einwandfrei authentifiziert — es ist die Lizenz, die abgelaufen ist), wann 403 richtig ist und wann 402 Payment Required mehr aussagt, wie man den maschinenlesbaren Grund in einem RFC-9457-Body vom Typ application/problem+json mit Erweiterungsmembern transportiert, auf die ein Client verzweigen kann, und welcher eine Response-Header — niemals der Schlüssel — eine CLI oder einen Schwesterdienst reagieren lässt, ohne Prosa zu parsen. Das Gate wird als ASP.NET-Core-IEndpointFilter gebaut, der Keyrights LicenseStatus über IProblemDetailsService auf Statuscodes abbildet, Retry-After ergänzt, wenn der Lizenzdienst kurz nicht erreichbar ist und das Kulanzfenster noch offen steht, und endet mit einem WebApplicationFactory-Test, der den Status, den Problemtyp und die Abwesenheit des signierten Schlüssels im Body prüft.
Lesen →Lizenzstatus auf einen ASP.NET-Core-Health-Check abbilden
Ein headless .NET-Dienst hat keinen Info-Dialog, in dem er seine Lizenz anzeigen könnte, also ist der einzige Ort, an dem Operatoren den Lizenzstatus je zu sehen bekommen, das Monitoring-Dashboard – und das heißt, die Lizenz muss zum Health-Check werden. Die naive Variante verdrahtet die Lizenz direkt mit der Readiness-Probe, ein abgelaufener Schlüssel liefert plötzlich 503, der Orchestrator nimmt die Instanz aus der Rotation und killt sie anschließend, der Ersatz kommt mit demselben abgelaufenen Schlüssel hoch, und Sie haben aus einem Abrechnungsereignis eine Neustartschleife gebaut. Dieser Beitrag liest, was die drei HealthStatus-Werte für einen Orchestrator tatsächlich bedeuten, bildet den LicenseStatus von Keyright so darauf ab, dass ein gültiger, aber bald ablaufender Schlüssel Degraded statt Unhealthy ist, hält den Lizenzstatus vollständig von der Liveness-Probe fern, damit ein Ablauf nie einen Kill auslöst, cacht die Validierung, damit eine sekündliche Probe nicht jedes Mal eine Signatur neu verifiziert, und stellt die Details, die Operatoren brauchen, über das Daten-Dictionary des Health-Checks bereit. Er endet mit dem Tag-Layout, das den Lizenz-Endpoint von Readiness und Liveness trennt, und dem Test, der beweist, dass ein abgelaufener Schlüssel degradiert, ohne den Prozess mitzureißen.
Lesen →Ein Lizenzschlüssel für viele Apps und Produkt-Bundles
Sie liefern einen Designer, einen Renderer und eine CLI aus, und Ihr Kunde möchte einen Schlüssel für alle drei, nicht drei. Die naheliegende Abkürzung – jeder App denselben Product-Slug geben und den Rest die Signatur erledigen lassen – ist genau die Abkürzung, die Ihre teuerste App klammheimlich zum Preis Ihrer günstigsten verkauft, denn ein Schlüssel, der für die Produktlinie verifiziert, verifiziert in jeder App der Linie. Dieser Beitrag liest, was der Product-Claim einer Keyright-Lizenz tatsächlich prüft (es ist eine Audience-Prüfung, keine Feature-Prüfung), legt die drei Wege dar, eine Suite zu lizenzieren, zeigt das Loch im Shared-Slug-Entwurf mitsamt dem exakten Gate, das es öffnet, und baut die Variante, die hält: ein Slug für die Linie, die App-Zugehörigkeit als namensraumierte Entitlements und ein Gate in jeder App, das fragt „bin ich in diesem Bundle?“, bevor es irgendetwas anderes fragt. Er endet mit dem Upgrade-Pfad vom Einzel-App-Schlüssel zum Suite-Schlüssel und dem Zwei-Client-Fallback für Teams, die bereits einen Slug pro App ausgeliefert haben.
Lesen →Strukturiertes Logging von Lizenzprüfungen, ohne den Schlüssel
Die Lizenzprüfung ist das eine Ereignis, das entscheidet, ob Ihre Software laufen darf, und sie wird fast immer entweder gar nicht geloggt oder als Desaster – ein log.LogInformation("license: {License}", info), das das ganze Objekt serialisiert und den signierten Schlüssel, die Signatur und die E-Mail-Adresse des Lizenznehmers in eine Datei schreibt, die an einen Log-Aggregator verschickt und in einem Support-Ticket geteilt wird. Dieser Beitrag baut den Mittelweg: ein einziges strukturiertes Event pro Verifikation, ausgegeben über eine Source-generierte LoggerMessage, damit die Redaktionsregel an genau einer Stelle lebt, mit dem Schlüssel reduziert auf einen kurzen Fingerprint, der einem Operator das Korrelieren erlaubt, ohne je das Geheimnis mitzuführen. Er bildet den LicenseStatus von Keyright auf Log-Level ab, sodass eine ungültige Lizenz ein Error ist, auf den Sie alarmieren können, und eine gesunde Lizenz stille Information bleibt, vergibt einen stabilen EventId-Bereich, damit ein Dashboard Lizenzfehler ohne String-Matching zählen kann, legt einen Logging-Scope um die Verifikation, damit jede nachgelagerte Zeile den Fingerprint trägt, hält das Event vom Hot Path pro Request fern und endet mit dem Test – einer FakeLogger-Assertion –, der beweist, dass der rohe Schlüssel nie die Senke erreicht.
Lesen →Warum Assembly-Scanning-DI beim Umbenennen bricht
Sehr viele .NET-Apps schreiben ihre DI-Registrierungen nie aus. Sie scannen beim Start eine Assembly – mit Scrutor oder einer handgeschriebenen Reflection-Schleife – und registrieren jeden Typ, dessen Name auf „Service“, „Handler“ oder „Repository“ endet. Diese Konvention ist ein String-Vergleich gegen den Typnamen, und Renaming-Obfuskierung ändert jeden einzelnen dieser Namen, sodass das Prädikat t.Name.EndsWith("Handler") nichts mehr trifft, die Services stillschweigend nie registriert werden und die App beim ersten Request „Unable to resolve service for type ...“ wirft – ein Laufzeitfehler bei grünem Build, weit entfernt von der Zeile, die ihn verursacht hat. Dieser Beitrag trennt die zwei Arten, wie ein Scan einen Typ finden kann: über seinen Namen, der ein Rename nicht überlebt, und über seine Gestalt – zuweisbar an ein Marker-Interface, mit einem Attribut dekoriert, von einer Basisklasse abgeleitet –, die es überlebt, weil das Metadaten-Token-Identitäten sind, die der Rename auf beiden Seiten konsistent umschreibt. Er zeigt die Scrutor-Registrierungen, die brechen, und die äquivalenten, die überleben, erklärt, warum AsImplementedInterfaces unproblematisch ist, das Namensprädikat aber nicht, zieht die Linie, die Nebula zieht, liefert sowohl das empfohlene Refactoring als auch die Exclude-Regel für den Fall, dass Sie nicht refaktorieren können, und endet mit einem Startup-Smoke-Test, der den obfuskierten Build schnell scheitern lässt statt erst beim ersten Request.
Lesen →Eine COM-sichtbare .NET-Assembly sicher obfuskieren
Eine COM-sichtbare .NET-Assembly wird von Code konsumiert, der nicht weiß, dass sie .NET ist — ein VBA-Makro, ein VBScript, ein alter C++-Host — und dieser Konsument bindet sich an sie über einen Vertrag aus drei Dingen, die nicht dort liegen, wo ein C#-Entwickler die öffentliche API aufbewahrt: eine GUID auf der Klasse und der Schnittstelle, ein DispId auf jedem Mitglied und eine ProgID, die standardmäßig der namespace-qualifizierte Typname ist. Obfuskieren Sie sie wie eine Bibliothek, und die GUIDs überleben (sie sind Attributkonstanten), aber die ProgID verschiebt sich in dem Moment, in dem Sie die Klasse umbenennen, und ein spätgebundener Client, der CreateObject("Acme.Widget") macht und Mitglieder per Namen über IDispatch aufruft, bricht sowohl an der verschobenen ProgID als auch an den umbenannten Mitgliedsnamen. Dieser Beitrag liest, was ein COM-Client auf jeder Stufe tatsächlich auflöst — von ProgID zu CLSID zu IDispatch-Mitglied —, zieht die Linie zwischen dem, was Nebula umbenennt (die Implementierung, die Engine), und dem, was festgenagelt ist (die GUIDs, die DispIds, die von der Spätbindung genutzten Mitgliedsnamen, die ProgID), zeigt das Layout mit [ProgId] und expliziter Schnittstelle, das die festgenagelte Oberfläche verkleinert, liefert die Konfiguration und endet mit der Registrieren-und-Aufrufen-Prüfung sowohl in einem spätgebundenen Skript als auch in einem frühgebundenen tlb-Client.
Lesen →Ein binäres PowerShell-Modul sicher obfuskieren
Ein binäres PowerShell-Modul ist eine gewöhnliche .NET-Assembly, die PowerShell per Reflection lädt, und es ist etwas Eigentümliches zu obfuskieren, weil sein öffentlicher Vertrag nicht dort liegt, wo C#-Entwickler ihn erwarten. Der Cmdlet-Name – Get-Widget – stammt aus dem [Cmdlet]-Attribut, sodass die Klasse, die ihn implementiert, in alles Mögliche umbenannt werden kann. Aber die Parameternamen – -Name, -Force, -Path – sind buchstäblich die Namen Ihrer öffentlichen Eigenschaften: Benennen Sie sie um, und jedes Skript, jede Tab-Vervollständigung und jede Get-Help-Seite bricht. Dasselbe gilt für die Objekte, die das Cmdlet in die Pipeline schreibt, deren Eigenschaftsnamen die Spaltenüberschriften von Format-Table und die Ziele von Select-Object sind. Dieser Beitrag liest genau, worauf die PowerShell-Laufzeit per Reflection zugreift, wenn sie ein Modul importiert und Parameter bindet, zieht die Linie zwischen dem, was Nebula umbenennen darf (die Cmdlet-Klasse, die Engine dahinter), und dem, was festgenagelt ist (Parameter-Eigenschaften, Ausgabe-Eigenschaften, die Attribute), zeigt das Layout „schlankes Cmdlet, fette Engine“, das die festgenagelte Oberfläche klein hält, liefert die Konfiguration und endet mit der Importieren-und-Aufrufen-Prüfung, die tatsächlich beweist, dass das geschützte Modul funktioniert.
Lesen →System.Text.Json-Typen obfuskieren, ohne das JSON zu zerstören
Das reflexionsbasierte System.Text.Json liest Ihr DTO über seine Property-Namen — Order wird auf dem Draht zu "order", weil die Property buchstäblich Order heißt — und das bedeutet: Sobald ein Obfuskator diese Property in a umbenennt, wird das JSON, das Ihr Dienst erzeugt, zu { "a": …, "b": … }, und jeder Konsument und jeder Round-Trip bricht, lautlos, zur Laufzeit, wo kein Build-Schritt es fangen kann. Dieser Beitrag legt genau fest, an welche Namen der Serializer bindet und an welche nicht: warum eine nackte Auto-Property eine Tretmine ist, warum [JsonPropertyName("order")] die Lösung ist, die den Drahtnamen zu einer Konstante macht, die der Renamer nicht anfassen kann, warum ein parametrisierter [JsonConstructor] Parameter über den Namen auf Properties abbildet, sodass auch die Konstruktorargumente festgenagelt sind, wie sich [JsonExtensionData] und Enum-[JsonStringEnumMemberName] verhalten, und warum der quellgenerierte JsonSerializerContext das Bild komplett verändert. Er zeigt die Nebula-Konfiguration, die den Vertrag intakt hält — Namen attributieren, Member umbenennen lassen — und den Round-Trip-Test, der beweist, dass ein geschützter Build immer noch deserialisiert, was er serialisiert hat.
Lesen →Wie Default-Interface-Methoden dekompilieren
Eine Default-Interface-Methode bricht die älteste Regel, die ein Decompiler über Interfaces kennt – dass sie Signaturen enthalten, keine Bodys. Seit C# 8 kann ein Interface eine funktionierende Implementierung mitbringen, und eine Klasse, die das Interface implementiert, kann überhaupt nichts beisteuern und erhält das Verhalten trotzdem. Das stellt Glass.NET vor drei Rätsel: eine virtuelle Instanzmethode mit Body, die in einem Interface sitzt (nicht abstrakt, keine Klassenmethode), eine Klasse, deren Metadaten weder Override noch MethodImpl enthalten und die sich dennoch verhält, als hätte sie eines, und eine Aufrufstelle, die über den Interface-Typ gehen muss, weil das Member auf der Klasse unsichtbar ist. Dieser Beitrag liest die IL für alle drei – das newslot virtual mit Body, das fehlende MethodImpl, das callvirt gegen das Interface – und zeigt, wie Glass die Default-Implementierung rekonstruiert, die implementierende Klasse korrekt leer lässt und den Interface-Cast beibehält, den die Sprache tatsächlich verlangt.
Lesen →Wie Ausnahmefilter in C# dekompilieren
Ein catch-Block mit einem Typ gehört zum Einfachsten, was ein Dekompiler liest — eine Handler-Klausel mit einem Typ-Token, fertig. Ein catch mit einer when-Klausel gehört zum Kniffligsten, denn es ist eine völlig andere Art von Ausnahme-Region. Der Filter hat kein Typ-Token; der Typtest wandert in einen getrennten IL-Block, der läuft, während der Stack noch abgewickelt wird, die when-Bedingung auswertet und in einem endfilter endet, das 1 zurückgibt, um den Handler auszuführen, oder 0, um die Suche fortzusetzen. catch (IOException e) when (e.HResult == 5) zu rekonstruieren bedeutet, diese Zwei-Block-Struktur zu erkennen, das Ausnahmeobjekt, das die Runtime auf den Stack gelegt hat, in die Variable e zu heben, den Typtest aus dem Filter als catch-Typ herauszuziehen und den Rest als when-Ausdruck zu lesen — und dann zu wissen, dass Ausnahmen, die innerhalb des Filters geworfen werden, verschluckt werden, was eine echte, im IL sichtbare Sprachgarantie ist. Dieser Artikel liest das genaue IL, das ein gefilterter catch emittiert, geht das endfilter-Protokoll durch und zeigt, wie Glass.NET die Klausel wieder aufbaut.
Lesen →Wie die fixed-Anweisung in C# dekompiliert
Es gibt keine fixed-Anweisung in IL. Was der C#-Compiler stattdessen emittiert, ist eine lokale Variable mit dem Modifizierer pinned in ihrer Signatur, ein paar Instruktionen, die aus dem, was Sie gepinnt haben, einen Zeiger berechnen — mit Prüfungen, die Sie nie geschrieben haben —, und ein Store, der die Lokale am Ende des Blocks löscht. Es gibt kein try/finally, denn ein Pin ist eine Eigenschaft der Lebensdauer einer Lokalen und keine Code-Region. Der Initialisierer wird je nachdem, was Sie gepinnt haben, auf vier verschiedene Arten abgesenkt: Ein Array bekommt eine Null-oder-leer-Prüfung und ein ldelema von Element null, ein String bekommt entweder die alte OffsetToStringData-Arithmetik oder einen Aufruf von GetPinnableReference, ein Span oder jeder Typ mit einer GetPinnableReference-Methode bekommt diesen Aufruf auf seiner Adresse, und &field oder &local bekommt ein schlichtes ldflda oder ldloca. Dieser Beitrag liest die echte IL für jede Form, erklärt, warum ein leeres Array einen Nullzeiger statt einer Ausnahme liefert, und zeigt, wie Glass.NET an der gepinnten Lokalen ansetzt, um die Maschinerie in das einzeilige fixed zurückzufalten, das Sie geschrieben haben.
Lesen →Wie optionale und benannte Argumente dekompilieren
Ein optionaler Parameter kostet an der Aufrufstelle, die Sie geschrieben haben, zur Laufzeit nichts — der Standardwert wird nicht in der Methode gespeichert, sondern vom Compiler in jeden Aufrufer eingesetzt. Im IL gibt es daher keine Spur eines Standardarguments außer am Aufruf selbst: ein Literal, das dort gepusht wird, wo Sie nichts geschrieben haben. Der Standardwert selbst liegt weit entfernt, in der Constant-Metadatentabelle, die am Parameter hängt, neben einem Optional-Flag; ein Decompiler, der die Methode liest, muss ihn dort nachschlagen, um = 0 oder = null auszugeben. Benannte Argumente sind noch merkwürdiger: Sie verschwinden vollständig, wenn sie in Reihenfolge stehen, und stehen sie außer der Reihe, schreibt der Compiler sie in geordnete positionale Pushes um — es sei denn, ihre Auswertung außer der Reihe hätte Nebeneffekte; dann lagert er jedes Argument zunächst in ein Temporary aus, um die Links-nach-rechts-Auswertung zu bewahren, und hinterlässt einen Block von Stores, der wie von Ihnen geschriebener Code aussieht. Dieser Beitrag liest IL und Metadaten für beides, zeigt die Zeilen der Constant-Tabelle hinter einem Standardwert, geht die Umordnungs-Temporaries durch und erklärt, wie Glass.NET die optionalen Standardwerte rekonstruiert und entscheidet, wann ein benanntes Argument es wert ist, ausgegeben zu werden.
Lesen →Clock Skew bei der Lizenzprüfung
Ein Kunde aktiviert um 9:00 Uhr eine Lizenz, und Ihre App lehnt sie als „noch nicht gültig“ ab. Nichts ist gefälscht, nichts ist abgelaufen – die Uhr seines Laptops geht vier Minuten gegenüber der Maschine nach, die den Schlüssel ausgestellt hat, sodass der NotBefore-Claim in seiner Zukunft liegt. Dieser Beitrag behandelt das Problem der ehrlichen Uhr (nicht den Angreifer, der die Uhr zurückdreht – das ist ein anderer Beitrag): die wenigen Minuten Uneinigkeit zwischen der Uhr des Ausstellers und der Uhr des Verifiers, die eine korrekte Lizenz im denkbar schlechtesten Moment in einen Scheinfehler verwandeln – direkt nach dem Kauf. Er liest die drei Zeitangaben einer Keyright-Lizenz (IssuedAt, NotBefore, Expiry), zeigt den naiven Vergleich, der dabei bricht, und baut die toleranzbewusste Verifikation: eine kleine symmetrische Toleranz auf NotBefore und Expiry, warum diese Toleranz in ihrer Absicht asymmetrisch ist, und warum verstrichene Zeit innerhalb einer Sitzung von einer monotonen Uhr kommen sollte – nicht von der Wanduhr, der Sie gerade das volle Vertrauen entzogen haben.
Lesen →Eine .NET-Komponentenbibliothek lizenzieren
Eine Komponentenbibliothek hat zwei Zielgruppen, und nur eine davon ist Ihr Kunde. Der Entwickler, der Ihre PDF-Engine oder Ihr Diagramm-Steuerelement kauft, hält die Lizenz; die Endanwender, die die damit gebauten Apps ausführen, haben nie von Ihnen gehört, dürfen nie nach einem Schlüssel gefragt werden und arbeiten auf Maschinen, die Sie nicht aktivieren können. Das ändert, wo eine Lizenz geprüft wird und was in der ausgelieferten Binärdatei mitreist. Dieser Beitrag baut mit Keyright das Design, auf das die meisten Hersteller von Steuerelementen hinauslaufen: eine unbefristete, nicht an eine Maschine gebundene Entwicklerlizenz, die zur Build-Zeit von einem MSBuild-Target in Ihrem NuGet-Paket verifiziert, als signiertes Attribut in die Assembly des Kunden eingebettet und zur Laufzeit offline erneut gegen den öffentlichen Schlüssel in Ihrer Bibliothek verifiziert wird — mit einer updates-until-Berechtigung statt eines Ablaufdatums, damit die App des Kunden nie stehen bleibt, einem Audience-Claim, damit eine aus einer App herausgelöste Lizenz keine andere freischaltet, und einem als Wasserzeichen tauglichen Lizenznehmernamen, der in jede Binärdatei signiert ist, die sie verwendet.
Lesen →Eine Lizenz unter Native AOT verifizieren
Native AOT und vollständiges Trimming belohnen genau das, was eine Lizenzprüfung ohnehin sein sollte: eine reine Funktion über Bytes. Doch die Bequemlichkeiten, die ein SDK auf dem JIT angenehm machen — ein reflectionbasierter JSON-Serialisierer, das Laden eines Schlüssels per Name, das Ermitteln des Signaturalgorithmus aus einem String — sind genau das, was der Trimmer entfernt und wofür der AOT-Compiler keinen Code erzeugen will. Dieser Beitrag nimmt eine Offline-Verifikation von Keyright und macht sie durchgängig AOT-sauber: den öffentlichen Schlüssel als ReadOnlySpan<byte> einbetten, der ohne Allokation zu einem Zeiger in die Datensektion kompiliert, ihn mit ImportSubjectPublicKeyInfo importieren und mit ECDsa.VerifyData verifizieren — beides trim-sicher — und die signierte Payload mit einem Utf8JsonReader statt eines Reflection-Serialisierers lesen, sodass der gesamte Pfad weder RequiresDynamicCode noch RequiresUnreferencedCode trägt und null Trim-Warnungen erzeugt. Er liest das IL der Span-über-statische-Daten-Optimierung, zeigt den einen JsonSerializer-Aufruf, der das Publish vergiftet hätte, und erklärt, warum ein Lizenzverifizierer der Teil Ihrer Anwendung ist, der sich am leichtesten nach AOT bringen lässt.
Lesen →Verlängerungshinweise, die Ihre Nutzer nicht nerven
Ein Countdown-Banner lässt sich auf zwei entgegengesetzte Arten falsch machen: Es nervt einen Perpetual-Kunden, der nichts zu verlängern hat, oder es schweigt, bis ein Abonnement bereits abgelaufen ist und die App fail-closed auf Free zurückgefallen ist. Beide Fehler stammen aus demselben Irrtum — die Meldung aus der rohen Lizenzdatei zu berechnen statt aus dem validierten Ergebnis. Dieser Artikel baut den Verlängerungshinweis richtig auf, aus Keyrights LicenseInfo: Kind unterscheidet eine Perpetual-Lizenz von einem Abonnement und einer Testversion, DaysRemaining und IsExpiringSoon entscheiden, wann gesprochen wird, und die Tatsache, dass ein abgelaufenes Abonnement zu Free validiert, bedeutet, dass der Hinweis feuern muss, solange die Lizenz noch gültig ist, nicht danach. Er liest die kleine Logik hinter Kind, zeigt, warum eine Perpetual-Lizenz ein null ExpiryUtc hat und niemals einen Countdown zeigen darf, und verdrahtet ein Banner, das den leise ablaufenden Kunden verlängert und alle anderen in Ruhe lässt.
Lesen →Ein F#-Assembly obfuskieren, ohne die Unions zu zerstören
F# kompiliert zu demselben IL wie C#, also kann ein Umbenenner es obfuskieren — aber F# stützt sich auf eine Schicht vom Compiler emittierter Metadaten, für die C# kein Gegenstück hat, und ein Umbenenner, der sie nicht versteht, zerbricht still Dinge, die trotzdem kompilieren. Eine diskriminierte Union ist für die CLR kein Summentyp; sie ist eine abstrakte Klasse mit einer verschachtelten Unterklasse pro Fall, einem Tag-Integer und einem Attribut [CompilationMapping(SourceConstructFlags.SumType)], das die Reflection von FSharp.Core liest, um die Fälle wiederherzustellen. Benennen Sie die Fall-Typen blind um oder entfernen Sie dieses Attribut als „ungenutzte Metadaten", und FSharpType.GetUnionCases gibt nichts zurück, die Ausgabe mit %A benennt Ihre Fälle nicht mehr, und jeder F#-bewusste Serialisierer verliert die Form — alles bei sauberer Kompilierung. Dieser Artikel liest das IL, das eine Union, ein Record und ein Modul wirklich emittieren, zeigt genau, welche Namen und Attribute tragend sind, weil FSharp.Core sie zur Laufzeit beobachtet, und konfiguriert Nebula so, dass es die Logik umbenennt und zugleich den Reflection-Vertrag bewahrt, von dem F# abhängt.
Lesen →readonly structs und ref-Returns sicher obfuskieren
Ein readonly struct, ein in-Parameter und ein ref readonly-Return sind nicht bloß Bequemlichkeiten im Quellcode — sie sind in den Metadaten als Custom Modifier und compilergenerierte Attribute kodiert, die der C#-Compiler zurückliest, um zu entscheiden, ob eine Aufrufstelle eine versteckte defensive Kopie anlegt, welche Überladung gewinnt und ob ein Wert überhaupt per Referenz übergeben werden darf. Ein modreq(InAttribute) auf einem Parameter ist Teil seiner Signatur, sodass sein Wegfall die Identität der Methode ändert und das Binden bricht; wird IsReadOnlyAttribute von einem Struct entfernt, beginnt jeder in-Aufruf darauf zu kopieren; wird IsByRefLike entfernt, lässt sich ein ref struct boxen. Ein Obfuskator, der all das als dekorative Metadaten behandelt, die man umbenennen oder verwerfen kann, erzeugt Assemblies, die zwar noch laden, sich aber anders verhalten — oder die sich gegen Aufrufer, die er nicht kontrolliert, nicht mehr binden lassen. Dieser Beitrag liest das IL jedes dieser Features, zeigt genau, welche Teile Signatur und welche Attribut sind, geht die drei Wege durch, auf denen ein unachtsamer Renamer sie beschädigt, und erklärt, wie Nebula die modreqs und die bekannten Compiler-Attribute unverändert bewahrt und dennoch alles umbenennt, was wirklich Ihnen gehört.
Lesen →Einen Roslyn-Source-Generator sicher obfuskieren
Ein Source-Generator ist ein seltsames Objekt für die Obfuskierung: eine .NET-Standard-2.0-Assembly, die der Compiler per Reflection lädt und innerhalb des Builds Ihres Kunden ausführt – und zugleich der Ort, an dem Ihre wertvollste Compile-Zeit-Logik lebt, genau der Code also, den Sie ausliefern und lieber keinem Decompiler überlassen würden. Die gute Nachricht: Roslyn findet Generatoren über ein Attribut, nicht über ihren Namen, sodass Nebula den Generatortyp und seine gesamte private Oberfläche umbenennen kann, ohne dass die Erkennung davon berührt wird. Die fixierten Teile sind klein und klar umrissen: Das [Generator]-Attribut muss erhalten bleiben, der öffentliche parameterlose Konstruktor muss öffentlich bleiben (der Compiler instanziiert ihn mit Activator.CreateInstance), und die Interface-Methode, die er aufruft, muss ihren Slot behalten. Dieser Beitrag liest nach, worauf der GeneratorDriver tatsächlich reflektiert, zieht die Grenze zwischen dem, was umbenannt werden darf, und dem, was tragend ist, zeigt die Nebula-Konfiguration und räumt mit dem einen Missverständnis auf, das viele verkehrt herum haben – den Generator zu obfuskieren obfuskiert nicht den Code, den er erzeugt.
Lesen →Virtuelle und Interface-Member sicher obfuskieren
Eine private Methode umzubenennen ist eine lokale Änderung. Eine virtuelle Methode umzubenennen ist es nicht, denn ihr Name ist Teil davon, wie die CLR den Dispatch verdrahtet: Ein Override belegt seinen Basis-Slot erneut, indem beim Laden des Typs Name und Signatur abgeglichen werden, eine implizite Interface-Implementierung wird auf dieselbe Weise gefunden, und nur eine explizite Implementierung wird durch eine MethodImpl-Zeile gebunden, die Tokens statt Text trägt. Macht man die Gruppierung falsch, bekommt man entweder eine TypeLoadException, sobald der Typ geladen wird — oder, schlimmer, gar nichts, während sich der Override stillschweigend löst und stattdessen die Basisimplementierung läuft. Dieser Beitrag liest die IL jeder Bindung, zeigt, welche namensbasiert und welche tabellenbasiert sind, geht die drei Arten durch, auf die ein naiver Renamer sie zerstört, und erklärt, wie Nebula eine virtuelle Methode mit jedem Override und jeder Implementierung gruppiert, mit der sie verbunden ist — über Typen und Interfaces hinweg —, sodass der gesamte Slot auf einen Namen umbenannt oder intakt gelassen wird, wenn ein Mitglied davon in eine Assembly hineinreicht, die Sie nicht kontrollieren.
Lesen →Was ein Decompiler aus anonymen Typen wiederherstellt
Ein anonymer Typ hat keinen Namen, den Sie geschrieben haben, aber er ist eine echte Klasse in den Metadaten — eine generische, die der Compiler synthetisiert, benannt etwa <>f__AnonymousType0`2, mit einer readonly-Eigenschaft pro Member, einem Konstruktor, der sie alle entgegennimmt, und überschriebenen Equals, GetHashCode und ToString. Der Trick, der sie wiederverwendbar macht, ist, dass die generierte Klasse generisch über ihre Eigenschaftstypen ist, sodass zwei new { }-Stellen mit denselben Eigenschaftsnamen in derselben Reihenfolge einen Backing-Typ teilen, der mit verschiedenen Typargumenten instanziiert wird. Dieser Beitrag liest die generierte Klasse und die newobj-Aufrufstelle im IL, zeigt, wo die Eigenschaftsnamen tatsächlich leben (auf den Eigenschaften des generierten Typs, nicht auf den <Name>j__TPar-Typparametern), geht das strukturelle Equals und das Hash-kombinierende GetHashCode durch, die der Compiler schreibt, und erklärt, wie Glass.NET das Muster erkennt und zurück in new { Name = ..., Total = ... } faltet, statt Ihnen einen unaussprechlichen generischen Typ zu hinterlassen.
Lesen →Wie Glass Schleifen und Bedingungen aus Sprüngen rekonstruiert
IL hat kein while, kein for, kein else — es hat Basisblöcke und Sprunganweisungen: br, brtrue, brfalse, switch. Eine for-Schleife und eine Goto-Spaghetti-Umschreibung derselben Schleife können zu identischem IL kompilieren, also kann ein Decompiler die Struktur nicht zurücklesen; er muss sie rekonstruieren. Dieser Beitrag geht die reale Pipeline durch, die Glass.NET ausführt: die Methode an jedem Sprung und jedem Sprungziel in Basisblöcke zerlegen, einen Kontrollflussgraphen bauen, Dominatoren berechnen, um zu finden, welcher Block welchen beherrscht, natürliche Schleifen aus Rückwärtskanten zum Block, der sie dominiert, erkennen und die Vorwärtssprünge in if/else strukturieren — und erklärt dann den ehrlichen harten Fall, den irreduziblen Kontrollfluss, wo keine saubere Schleife existiert und ein Decompiler entweder Code duplizieren oder auf Labels und goto zurückfallen muss.
Lesen →Wie foreach zurück nach C# dekompiliert
Es gibt kein foreach in IL. Der C#-Compiler senkt es in eine von drei völlig verschiedenen Formen ab, je nachdem, worüber Sie iterieren — ein Aufruf von GetEnumerator mit einer while-Schleife und einem versteckten try/finally, das den Enumerator freigibt, eine Struct-Enumerator-Variante ganz ohne Dispose oder, über ein Array oder einen Span, eine schlichte indexgezählte for-Schleife ohne jeden Enumerator. Ein Decompiler sieht nur den abgesenkten Code und muss erkennen, welches Muster er vor sich hat, um foreach statt der Maschinerie auszugeben. Dieser Beitrag liest die echte IL für jeden Fall, zeigt, warum das Dispose in einem finally steht, das der Quelltext nie geschrieben hat, warum der Struct-Enumerator es überspringt und wie Glass.NET die Form — das Trio GetEnumerator/MoveNext/get_Current, das try/finally, die IDisposable-Prüfung — zuordnet, um die Schleife wiederherzustellen, die Sie tatsächlich geschrieben haben.
Lesen →Einen Signaturalgorithmus für Lizenzschlüssel wählen
Ein Lizenzschlüssel ist eine signierte Payload, und der Signaturalgorithmus, den Sie wählen, ist kein austauschbares Detail — er entscheidet, wie lang der Schlüssel ist, den Ihr Kunde eintippen muss, wie schnell jeder Start ihn verifiziert und ob ein einziger Fehler in Ihrem Ausstellungscode den privaten Schlüssel preisgeben kann. RSA-2048-Signaturen sind 256 Bytes groß, was einen tippbaren Schlüssel in eine Wand aus Base32 verwandelt; ECDSA P-256 ist ein Drittel davon, trägt aber eine Nonce, die bei Wiederverwendung einem Angreifer Ihren Schlüssel ausliefert; Ed25519 ist 64 Bytes groß, deterministisch und hat keine Nonce, die man falsch machen könnte. Dieser Beitrag wägt die drei auf den Achsen ab, die für Offline-first-Lizenzierung wirklich zählen — Signatur- und Public-Key-Größe, Verifikationskosten beim Kaltstart, Determinismus und Fehlermodi und wie jeder in System.Security.Cryptography aussieht — und erklärt, warum Keyright standardmäßig mit Ed25519 signiert.
Lesen →Ihren öffentlichen Lizenz-Verifikationsschlüssel pinnen
Deine App verifiziert eine Lizenz, weil eine Signatur gegen einen im Assembly eingebetteten öffentlichen Schlüssel stimmt. Doch dieser Schlüssel sind Daten: eine Base64-Konstante, die jeder Angreifer, der deine DLL bearbeiten kann, findet und durch einen von ihm kontrollierten Schlüssel überschreibt — so verifizieren nun seine selbst signierten Lizenzen und deine ist vergessen. Das ist der Austausch des Vertrauensankers und der Angriff mit der größten Hebelwirkung auf Offline-First-Lizenzierung. Dieser Beitrag zeigt den Angriff auf IL-Ebene — das ldstr, das den Schlüssel lädt, den einen Byte-Bereich, den ein Patch berührt — und hebt dann seine Kosten: Fingerabdruck des Schlüssels gegen einen in den Kontrollfluss verwobenen Wert statt allein, Prüfung an mehr als einer Stelle, mehrere Schlüssel per AdditionalPublicKeysBase64, damit ein einziger Tausch nicht reicht, und Verbindung der Client-Prüfung mit Strong-Naming, Anti-Tamper und Report-Home, sodass ein manipulierter Build zugleich schwerer herzustellen und sichtbar ist, wenn er ausgeliefert wird.
Lesen →Einen Lizenzschlüssel entwerfen, den Menschen tippen können
Eine Keyright-Lizenz besteht aus signierten Bytes, aber was ein Kunde von einer Rechnung abliest, in einen Aktivierungsdialog tippt oder am Telefon diktiert, ist eine Zeichenkette — und Base64 ist eine furchtbare Zeichenkette für diese Aufgabe. Sie unterscheidet Groß- und Kleinschreibung, sie verwendet + und /, die in E-Mails und Shells verstümmelt werden, und ein einziges falsch getipptes Zeichen erzeugt einen Signaturfehler ohne jeden Hinweis darauf, wo der Fehler lag. Dieser Beitrag baut die Transportkodierung, die Keyright tatsächlich verwendet: Crockford-Base32, damit das Alphabet ein Telefonat und eine Umschalttaste übersteht, Segmente aus fünf Zeichen, damit das Auge die Position verfolgen kann, und ein Mod-37-Prüfsymbol, das jeden Einzelzeichenfehler und fast jede Vertauschung fängt, bevor Sie je die teure Signaturprüfung ausführen. Er zeigt das echte Kodieren und Dekodieren in C#, die Normalisierung, die einen schlampig getippten Schlüssel wieder in kanonische Bytes verwandelt, und warum die Prüfziffer ein Ergonomie-Feature ist und niemals ein Sicherheitsmerkmal.
Lesen →Enums obfuskieren, ohne die Namen preiszugeben
Benenne einen Enum und seine Member um, und ein Decompiler druckt immer noch LicenseTier.Pro, nicht a.b — denn ein Enum ist eine versiegelte Klasse, deren Member öffentliche const-Literalfelder sind, und sobald dein Code ToString() oder Enum.Parse aufruft, liest die Laufzeit diese Feldnamen zur Laufzeit direkt aus den Metadaten. Sie in a, b, c umzubenennen ist legal und kostet dich nichts außer dem Einen, das du wolltest: Ein Hin-und-Zurück über den Namen bricht, weil "Pro" nicht mehr zu einem Feld namens a passt. Dieser Beitrag liest das IL, zu dem ein Enum kompiliert, zeigt, wo die Namen leben (die Field-Tabelle und der #Strings-Heap, nicht die Werte), geht genau durch, was beim Umbenennen bricht — ToString, Enum.Parse, [Flags]-Formatierung, String-JSON-Serialisierung, Enum.GetNames — und wie Nebula die Enum-Behandlung eingrenzt, sodass die Werte, die deine Logik steuern, geschützt sind, während die Namen, von denen dein Protokoll abhängt, intakt bleiben.
Lesen →Generics obfuskieren, ohne die Reflection zu brechen
Ein generischer Typparameter wie TResult ist ein Name in den Metadaten — eine Zeile in der GenericParam-Tabelle mit einem String in #Strings —, sodass ein Umbenenner ihn in T0 verwandeln kann und ein Decompiler getreu T0 ausgibt, was genau das harmlose Ergebnis ist, das Sie wollen. Aber Generics sind der Ort, an dem naives Umbenennen stillschweigend Dinge zerbricht, denn die CLR identifiziert eine Instanziierung über Position und Arität, nicht über den Namen, während Ihr Reflection-Code einen Typparameter über seinen Namen identifiziert. Dieser Beitrag liest, wozu eine generische Methode und Klasse tatsächlich kompilieren — die Tabellen GenericParam und GenericParamConstraint, die MethodSpec und TypeSpec, die eine Instanziierung per Index festhalten —, zeigt, warum das Umbenennen des Parameters kostenlos ist, das Umbenennen eines Constraint-Typs aber nicht, und geht die Reflection-Aufrufe durch (Type.GetGenericArguments().Name, MakeGenericType, GetMethod auf einem offenen Generic), die Namen zurücklesen und brechen, wenn ein Umbenenner das Falsche anfasst.
Lesen →Wie Nebula einen Namen über viele Member wiederverwendet
Ein naiver Umbenenner gibt jedem Member einen eindeutigen kurzen Namen — a, b, c, d — und hört dort auf. Er lässt Potenzial liegen, denn .NET identifiziert ein Member nicht über seinen Namen. Eine Methode wird durch ihren Namen zusammen mit ihrer Signatur identifiziert, ein Feld durch seinen Namen und seinen deklarierenden Typ, und die Laufzeit bindet jeden Aufruf über ein Metadaten-Token, das beim Laden aufgelöst wird — nicht durch erneutes Abgleichen von Zeichenketten. Das bedeutet, Sie können Dutzende nicht zusammenhängender Methoden auf den einen Namen a umbenennen, solange ihre Signaturen sich unterscheiden, und die Assembly lädt, verifiziert und läuft trotzdem. Dieser Beitrag liest die MethodDef- und String-Heap-Metadaten, um zu zeigen, warum Kollisions-Umbenennung zulässig ist, geht die exakten Regeln durch, die sie begrenzen — Kollisionen gleicher Signatur, virtuelle Override-Ketten, explizite Interface-Implementierungen — und erklärt, wie Nebula Namen auf eine winzige wiederverwendete Menge verdichtet, die sowohl den String-Heap schrumpft als auch die Ausgabe eines Decompilers in eine unlesbare Wand identisch benannter Member verwandelt.
Lesen →Wie C#-Events in .NET dekompilieren
Eine Zeile C# — public event EventHandler Changed; — wird in der Assembly zu vier Dingen: einem privaten Delegatenfeld, einem add_Changed- und einem remove_Changed-Accessor sowie einer Zeile in der Event-Tabelle, die sie über MethodSemantics zusammenbindet. Die Accessoren sind auch keine einfachen Zuweisungen: Seit C# 4 emittiert der Compiler eine lock-freie Interlocked.CompareExchange-Schleife um Delegate.Combine und Delegate.Remove, und ältere Binärdateien tragen stattdessen eine [MethodImpl(Synchronized)]-Variante. Ein Decompiler muss beide Formen erkennen, um die vier Teile wieder zu einer Deklaration zu falten, ein explizites add/remove beizubehalten, wenn der Autor eines geschrieben hat, und die ?.Invoke-Auslösestelle statt des dup/brtrue-Tanzes darzustellen, zu dem sie kompiliert. Hier sind die Metadaten, die IL und das, was Glass.NET daraus macht.
Lesen →Wie Null-Conditional-Operatoren dekompilieren
Der Null-Conditional-Operator liest sich wie ein einziges aufgeräumtes Symbol — order?.Customer?.Name —, aber es gibt keine ?.-Instruktion in IL. Der C#-Compiler senkt ihn zu gewöhnlichen Nullprüfungen und Verzweigungen ab, und das Detail, das eine Kette sauber dekompilierbar macht, ist, dass jedes Glied zum selben gemeinsamen Ziel kurzschließt, nicht in eine eigene Verschachtelung. Dieser Beitrag liest die echte IL einer zweigliedrigen Kette, zeigt, warum der erste Empfänger mit einem nackten brtrue geprüft wird, während ein Zwischenergebnis per dup und pop behandelt wird, geht das Nullable-Lifting durch, das s?.Length in ein int? mit initobj auf der Null-Seite und einem Nullable..ctor auf der anderen verwandelt, behandelt die ??- und ??=-Absenkungen, die dieselbe Kurzschlussform teilen, und erklärt, wie Glass.NET das Muster erkennt und die Verzweigungen zurück in ?. und ?? faltet, statt Ihnen ein Labyrinth aus Labels zu hinterlassen.
Lesen →Wo params-Collections das Array verstecken
Zwanzig Jahre lang bedeutete ein params-Parameter in IL genau eines: Der Aufrufer baute ein newarr und füllte es. C# 13 hat params auf beliebige Collection-Typen verallgemeinert, und der Paradefall — params ReadOnlySpan<T> — allokiert überhaupt nichts auf dem Heap. Der Aufrufer legt die Argumente in einen compilergenerierten Inline-Array-Puffer auf dem Stack und wickelt einen Span darum; params List<T> läuft stattdessen über einen Collection Builder. Das Erkennungsmerkmal beim Dekompilieren liegt vollständig an der Aufrufstelle, nicht in der Signatur. Hier steht, was jede Form emittiert, wie ein Decompiler den Puffer wieder zu einem schlichten Aufruf zusammenfaltet und warum ein params ReadOnlySpan<T>, das ein newarr zeigt, ein kalter Fallback-Pfad ist, der Beachtung verdient.
Lesen →Wie ein switch über Zeichenketten in C# dekompiliert
Ein switch über einen Integer kompiliert zu einer einzigen switch-IL-Instruktion. Ein switch über eine Zeichenkette kann das nicht — es gibt keine Sprungtabelle für Text —, also schreibt der C#-Compiler ihn, sobald Sie mehr als eine Handvoll Fälle haben, stillschweigend in einen zweistufigen Dispatch um: die Zeichenkette mit einem synthetisierten ComputeStringHash hashen, nach dem Hash zu einem Kandidaten verzweigen und dann mit einem ordinalen String.Equals bestätigen, bevor zum Zweig gesprungen wird. Dieser Beitrag liest das echte IL eines großen Zeichenketten-switch, zeigt den FNV-Helfer <PrivateImplementationDetails>.ComputeStringHash und den zweiten dichten switch über einen Fallindex, erklärt, warum die Gleichheitsprüfung nicht optional ist, und geht durch, wie Glass.NET die ganze Form erkennt und sie zu switch (s) { case "...": } zurückfaltet, statt Ihnen eine Seite voller Hash-Konstanten zu hinterlassen.
Lesen →Die Lizenz-Signaturprüfung cachen, ohne zu veralten
Eine signierte Keyright-Lizenz wird mit einer RSA-Signaturprüfung verifiziert, und diese Prüfung kostet echte Mikrosekunden. Wer Validate() bei jeder Anfrage aufruft, hat Public-Key-Kryptographie ohne Grund auf seinen Hot Path gelegt — die Signatur hat sich seit dem Start nicht geändert. Aber man kann das Ergebnis auch nicht einfach für immer cachen, denn die Antwort ist zeitabhängig: ein Entitlement kann um zwölf Uhr ablaufen, ein Lease kann eingezogen werden, eine Verlängerung kann den Plan erweitern. Dieser Beitrag trennt die beiden Hälften einer Lizenzprüfung — die teure, cachebare Signaturverifikation und die billige, zwingend pro Aufruf stattfindende Auswertung der Lizenz zum aktuellen Zeitpunkt —, misst, was jede davon kostet, und zeigt eine zweistufige Memoisierung, die die Kryptographie vom Hot Path fernhält, ohne jemals eine Antwort zu liefern, die eine Minute veraltet ist.
Lesen →Berechtigungen als ASP.NET-Core-Autorisierungsrichtlinien
Die meisten Anwendungen prüfen die Lizenz einmal beim Start und verstreuen IsEnabled-Aufrufe im gesamten Code. In einem ASP.NET-Core-Dienst ist das ein Fehler: Sie haben bereits eine Autorisierungs-Pipeline, die genau die Frage „Darf dieser Aufrufer das tun?" beantwortet, und eine lizenzierte Berechtigung ist exakt diese Frage. Hier zeigen wir, wie Sie Keyright-Berechtigungen auf das Autorisierungssystem abbilden: eine Requirement, die eine Berechtigung benennt, ein Handler, der die validierte Lizenz liest, ein Policy-Provider, der Richtlinien bei Bedarf erzeugt, und [Authorize(Policy = "ent:export")] auf den Endpunkten, die es brauchen — alles fail-closed, alles offline.
Lesen →Headless-Lizenzaktivierung für ein .NET-CLI-Tool
Ein Kommandozeilenwerkzeug hat keinen Einstellungsbildschirm, läuft häufig auf einer Maschine, vor der kein Mensch sitzt, und wird von Skripten gesteuert, die nur Exit-Codes lesen. Das sprengt das Desktop-Lizenzierungsskript — Schlüssel in einen Dialog einfügen, Lease zwischenspeichern, weitermachen. Hier erfahren Sie, wie Sie ein dotnet-Tool oder einen Build-Task mit Keyright ohne UI lizenzieren: ein `license`-Unterbefehl, der aktiviert und berichtet, die sechs Orte, an denen das SDK nach einer Lizenz sucht, und welches CLI-Idiom auf welchen davon abbildet, Fail-closed-Gating, das niemals nachfragt, wenn stdin kein Terminal ist, und das Problem flüchtiger CI-Runner, gelöst mit einer Offline-Lizenzdatei, die in KEYRIGHT_LICENSE mitgeführt wird, statt mit einem Seat pro Job.
Lesen →Warum async-Zustandsmaschinen das Umbenennen überleben
Dekompilieren Sie eine obfuskierte Assembly und das Erschreckendste, was Sie sehen, ist ein MoveNext voller abgeflachtem Kontrollfluss und Feldern namens <>1__state. Man nimmt an, das Umbenennen müsse den async-Code zerstört haben. Hat es nicht — denn jedes Binding zwischen einer async-Methode, ihrem generierten Zustandsmaschinen-Typ und dem AsyncTaskMethodBuilder ist ein Metadaten-Token, keine Namenssuche, also ändert das Umbenennen des Typs und seiner Felder zu a und b nichts, was die Laufzeit liest. Doch es gibt eine Sache, die ein nachlässiger Obfuskator wirklich brechen kann: MoveNext, SetStateMachine, Current und Dispose sind Schnittstellenmethoden, und sie umzubenennen, ohne das Schnittstellen-Binding (das MethodImpl) umzuschreiben, lässt den Builder eine Methode aufrufen, die IAsyncStateMachine nicht mehr implementiert. Dieser Beitrag liest die echte Absenkung einer async-Methode und eines Iterators, zeigt, welche Namen frei sind und welches Binding erhalten bleiben muss, und erklärt den Kompromiss der Metadaten-Härtung: Entfernen Sie das AsyncStateMachine-Attribut für einen Release-Build und wissen Sie, dass es async-Einzelschrittdebugging kostet, nicht Korrektheit.
Lesen →Custom Attributes obfuskieren, ohne die Reflection zu brechen
Ein Custom Attribute ist kein Kommentar, den der Compiler wegwirft — es ist eine Zeile in der CustomAttribute-Metadatentabelle, die per Token auf einen Konstruktor zeigt und einen Blob aus positionalen und benannten Argumenten trägt. Diese Struktur entscheidet exakt, was Obfuskierung anfassen darf und was nicht. Benennen Sie die Attributklasse um, und das tokenbasierte GetCustomAttribute<T>() funktioniert weiter, weil Tokens sich nicht für Namen interessieren; benennen Sie sie um, und das stringbasierte GetCustomAttributes().First(a => a.GetType().Name == "FeatureGate") bricht, weil es einen Namen gelesen hat, den Sie gerade gelöscht haben. Benannte Argumente sind der subtile Teil: Sie referenzieren ein Feld oder eine Property per Namensstring im Blob, sodass ein Renamer, der das eine ohne das andere verschiebt, eine Assembly erzeugt, die beim Laden eine TypeLoadException wirft. Dieser Beitrag liest die echten Metadaten, zeigt, welche Reflection-Muster ein Umbenennen überleben und welche nicht, und erklärt, wie Nebula Attributverwendungen konsistent hält und dabei trotzdem die Namen entfernt, die ein Angreifer lesen würde.
Lesen →Eine Assembly obfuskieren, deren Tests weiterhin bestehen müssen
Das Umbenennen von Internals ist der Punkt, an dem Obfuskierung ihren Wert beweist — doch [InternalsVisibleTo] macht einige dieser Internals stillschweigend zu einem Vertrag. Ein Testprojekt, eine Geschwister-Assembly oder ein generiertes Mock greift namentlich auf Ihre internen Typen zu, und dieser Name existiert nur zur Compile-Zeit. Obfuskieren Sie den Produzenten allein, kompiliert der Friend nicht mehr — oder schlimmer: Ein reflexionsbasiertes Mock schlägt zur Laufzeit fehl. Hier erfahren Sie genau, was [InternalsVisibleTo] in den Metadaten tut, warum Nebula.NET den Einzel-Assembly-Fall für Sie bewahrt und wie Sie eine echte Friend-Assembly grün halten, indem Sie das Paar gemeinsam obfuskieren.
Lesen →Source-generierten Code sicher obfuskieren
Source-Generatoren laufen innerhalb des Compilers und emittieren gewöhnliches C# in Ihre Assembly, sodass die von ihnen erzeugte IL nicht von Code zu unterscheiden ist, den Sie selbst getippt haben. Die für die Obfuskierung nützliche Konsequenz: Generatoren lösen Namen zur Compile-Zeit auf. Ein System.Text.Json-Kontext hält "Name" als String-Literal fest und erreicht die Eigenschaft über einen Delegaten, der Konfigurations-Binder verzweigt über literale Schlüssel, und ein GeneratedRegex ist reine Typidentität. Benennen Sie alles um, und JSON, gebundene Optionen und Regex funktionieren weiter — anders als ihre reflexionsbasierten Gegenstücke. Was Generatoren zurücklassen, sind Literale: das Regex-Muster, das Log-Nachrichten-Template und ein nameof(), das Ihren ursprünglichen Methodennamen in eine EventId einbrennt. Hier erfahren Sie, was jeder Generator emittiert, was Nebula.NET sicher umbenennt und was Sie verschlüsseln oder ausschließen sollten.
Lesen →Einen Lizenzschlüssel über vier Runtimes verifizieren
Eine Produktlinie ist selten eine einzige Sprache — eine .NET-Desktop-App, eine Node-CLI, ein Python-Datenwerkzeug, ein JVM-Dienst, alles als ein Produkt verkauft. Die bequeme Antwort gibt jedem seine eigene Lizenzierung und lässt den Kunden mit vier Schlüsseln jonglieren. Die bessere: Ein einziger Mandant signiert eine Lizenz mit einem privaten RSA-Schlüssel, jede Komponente bettet denselben öffentlichen Schlüssel ein, und vier SDKs verifizieren offline das identische signierte Lizenz- und Lease-Format. Dieser Beitrag zeigt denselben Ablauf aus Initialisieren-Validieren-Begrenzen in C#, JavaScript, Python und Java nebeneinander, erklärt, warum der Maschinen-Fingerabdruck byteweise kompatibel über alle hinweg ist, sodass ein Platz jede Komponente auf einer Maschine abdeckt, und behandelt die zwei Dinge, die wirklich pro Komponente sind — der lokale Lease-Cache und der Lizenzauflösungspfad — sowie, wie eine Schlüsselrotation die ganze Linie auf einmal durchläuft.
Lesen →Wie init-only- und required-Member dekompilieren
init und required sind zwei der kleinsten aussehenden Schlüsselwörter in C# und zwei der am leichtesten für einen Decompiler zu verlierenden. Ein init-Accessor ist nur ein set-Accessor, dessen Signatur einen required-Modifikator trägt — modreq(IsExternalInit) — und ein Decompiler, der den Modifikator nicht betrachtet, zeigt ihn als gewöhnliches set, und reicht dir stillschweigend einen Typ, dessen Eigenschaften nach der Konstruktion neu zugewiesen werden können. required ist schlimmer: es sind drei getrennte Attribute, die zusammenarbeiten — RequiredMemberAttribute an jedem Mitglied, RequiredMemberAttribute am Typ und CompilerFeatureRequired am Typ — plus ein SetsRequiredMembers an jedem Konstruktor, der sie erfüllt, und ein Decompiler, der sie fallen lässt, produziert Code, dessen Aufrufer nicht mehr gezwungen sind, irgendetwas zuzuweisen. Dieser Beitrag liest das IL und die Metadaten beider Features, zeigt die exakte Byte-Ebenen-Form des modreq und der Attribut-Blobs, geht durch, wie Glass.NET init, required und [SetsRequiredMembers] rekonstruiert, und erklärt, warum das Überspringen des Schritts den öffentlichen Vertrag eines Typs stillschweigend ändert.
Lesen →Wie Operatorüberladungen in C# dekompilieren
Ein benutzerdefinierter Operator ist eine statische Methode mit reserviertem Namen und dem specialname-Flag — op_Addition, op_Implicit, op_Equality — und ihn auf eine Operatordeklaration zurückzuführen sieht nach einem Tabellen-Lookup aus. Drei Dinge machen es schwerer als die Tabelle. Benutzerdefinierte Konvertierungen dürfen allein über den Rückgabetyp überladen werden, was legales IL und illegales C# ist: Zwei op_Explicit-Methoden mit identischen Parametern unterscheiden sich nur darin, was sie zurückgeben, sodass ein Decompiler, der sie als gewöhnliche Methoden ausgibt, Quelltext erzeugt, der nicht kompiliert. C# 11 fügte checked-Operatoren hinzu — op_CheckedAddition, op_CheckedExplicit —, die mit dem Schlüsselwort checked wiedergegeben und mit ihrem unchecked-Zwilling gepaart werden müssen, sonst dekompiliert jede Aufrufstelle checked(a + b) zu einem Methodenaufruf. Und op_True/op_False, op_Increment und die Instanz-Operatoren für zusammengesetzte Zuweisungen aus C# 14 kompilieren jeweils zu Aufrufmustern, die zurück in Syntax gefaltet statt als Aufrufe angezeigt werden müssen. Dieser Beitrag liest das IL für jeden Fall, zeigt die Aufrufstellen, die die Rekonstruktion steuern, und geht durch, wie Glass.NET sie wieder in die Operatoren verwandelt, die der Autor geschrieben hat.
Lesen →Wie C#-11-ref-structs im IL dekompilieren
Ein ref-Feld ist das erste Mal, dass ein C#-Feld eine Referenz statt eines Werts speichert, und es kompiliert zu Metadaten, die frühere Dekompilierer nie lesen mussten. Die Signatur des Feldes trägt einen byref-Elementtyp — ELEMENT_TYPE_BYREF innerhalb einer FIELD-Signatur, was vor .NET 7 unzulässig war — und die ref-Sicherheitsregeln, die es daran hindern, das zu überleben, worauf es zeigt, sind in modreq und Attributen kodiert, nicht in ausführbarem IL. scoped ist das lauteste davon: es ist ein ScopedRefAttribute auf einem Parameter, ganz ohne Laufzeitwirkung, das ein Dekompilierer entweder als das Schlüsselwort scoped anzeigt oder fallen lässt, womit er stillschweigend den ref-Sicherheitsvertrag der Methode verändert. Dieser Beitrag liest die rohen Signaturen und Attribut-Blobs eines ref-Feldes, einer ref-struct, die eines enthält, und eines scoped-ref-Parameters, zeigt, wo im Metadatensatz die ref-Escape-Regeln leben, und geht durch, wie Glass.NET ref, ref readonly, scoped und die Notausstieg-Angabe [UnscopedRef] rekonstruiert, damit der dekompilierte Quellcode mit derselben Sicherheit kompiliert, die der Autor geschrieben hat.
Lesen →Wie das neue lock von C# dekompiliert
Zwanzig Jahre lang wurde lock (obj) zu Monitor.Enter/Exit mit einem lockTaken-Flag abgesenkt. C# 13 hat das geändert: lock auf einem System.Threading.Lock wird zu EnterScope() und einem Scope-ref struct abgesenkt, das in einem finally freigegeben wird — eine völlig andere IL-Form. Hier erfahren Sie genau, was jede Form erzeugt, wie ein Decompiler sie auseinanderhält und beide zurück in lock faltet, und das eine Dekompilierungs-Indiz, das einen stillen Fehler entlarvt: ein Lock, das zu object geboxt wurde und stillschweigend auf Monitor zurückfällt.
Lesen →Doppelte Aktivierungen erkennen, wenn eine VM geklont wird
Ein Geräte-Fingerabdruck identifiziert ein Gerät — und eine geklonte VM ist konstruktionsbedingt dasselbe Gerät zweimal. Snapshot-Wiederherstellung, Golden Images und automatisch skalierte Instanzen reproduzieren genau die Hardware- und Betriebssystemattribute, die eine Gerätebindung zu einem Hash zusammenfasst, sodass zwei laufende Kopien einen identischen Fingerabdruck präsentieren und die Gerätebindung sie nicht auseinanderhalten kann. Die Lösung ist kein besserer Fingerabdruck; es ist eine Aktivierungsidentität, die der Server besitzt, plus ein Instanz-Nonce pro Lauf, den der Client nicht sinnvoll klonen kann, sodass sich zwei Kopien einer Aktivierung in dem Moment verraten, in dem beide nach Hause telefonieren. Dieser Beitrag liest das SDK und die Serverrichtlinie für genau das: warum der Fingerabdruck ausgehebelt wird, wie ein Aktivierungseintrag und eine Laufzeit-Instanz-ID eine legitime Migration von einem live laufenden Klon trennen, und wie Keyright zwischen „der Neueste gewinnt" und „markieren und halten" entscheidet, ohne einen Kunden auszusperren, der einfach umgezogen ist.
Lesen →Ablauf je Berechtigung mit Keyright
Eine Lizenz hat üblicherweise ein einziges Ablaufdatum, echte Verträge aber selten: Ein Basisplan verlängert sich jährlich, während ein Test-Add-on 30 Tage läuft und eine Aktionsfunktion mit dem Quartal endet. Ein einziges Datum in die gesamte Lizenz einzubacken zwingt Sie entweder dazu, zu viel zu gewähren oder ständig neu auszustellen. So geben Sie jeder Berechtigung in einer einzigen signierten Keyright-Lizenz ihren eigenen Ablauf — die Form der Nutzdaten, das SDK, das eine Uhr pro Funktion offline liest, die Durchsetzung an der Fähigkeitsgrenze und die Kulanzregeln, die verhindern, dass ein abgelaufenes Add-on die ganze App lahmlegt.
Lesen →Lizenzdurchsetzung zuerst im Audit-Modus ausrollen
Das beängstigendste Deployment jedes Lizenzierungsprojekts ist das, welches die Durchsetzung von aus auf an schaltet. Bis dahin hat das Tor niemandem Nein gesagt; in dem Moment, in dem es das tut, wird jeder falsch bereitgestellte Schlüssel, jede um einen Tag abweichende Uhr, jeder Kunde, der hinter einem nicht vorhergesehenen Proxy aktiviert hat, zu einem Support-Ticket — alle auf einmal, in der Produktion. Dieser Beitrag zeigt, wie man den großen Umschaltmoment mit dem Audit-Modus vermeidet: ein Tor, das die Lizenz genau so auswertet, wie es im Durchsetzungsmodus tun wird, die Entscheidung protokolliert, die es getroffen hätte, und den Aufruf dann trotzdem durchlässt. Du führst es über deinen gesamten installierten Bestand aus, liest die Population, die blockiert worden wäre, korrigierst die Daten und schaltest erst dann auf Durchsetzung um — pro Kohorte, gesteuert von einem Modus, den die signierte Lizenz transportiert, damit kein Client ihn ausschalten kann. Mit einem Entscheidungsdatensatz, einem Durchsetzungsmodus-Enum, das die Nutzlast signiert, einem gestaffelten Rollout und den Metriken, die dir sagen, dass das Blockieren sicher ist.
Lesen →Eine Lizenz deaktivieren und auf eine neue Maschine übertragen
Einen Seat freizugeben klingt wie die einfache Hälfte des Node-Lockings — der Kunde klickt auf „dieses Gerät deaktivieren" und der Seat ist wieder verfügbar. Doch eine Deaktivierung ist eine Behauptung, die der Client über seinen eigenen Zustand aufstellt, und der Client ist die eine Partei, der Sie nicht vertrauen können. Online geht es um Reihenfolge und Wiederholungen: auf dem Server freigeben, bevor oder nachdem lokal gelöscht wird, und was passiert, wenn eines von beiden fehlschlägt. Offline geht es um den Nachweis: Eine Maschine ohne Netz muss dem Kunden etwas aushändigen, das den Server überzeugt, dass ein Seat wirklich aufgegeben wurde. Und bei toten Maschinen — dem Laptop, der in den See gefallen ist — geht es um Missbrauch: Jede erzwungene Freigabe ist eine Gelegenheit, Seats zu vervielfachen. Dieser Beitrag liest das Keyright-SDK und die Server-Richtlinie für alle drei Fälle: die idempotente Online-Freigabe, die HMAC-Deaktivierungsquittung, die an das Instanzgeheimnis der Aktivierung gebunden ist, warum die Lease-TTL begrenzt, was ein lügender Client gewinnen kann, und die Transfer-Abkühlphase und die rollierenden Limits, die verhindern, dass „ich habe meine Maschine verloren" zum Seat-Generator wird.
Lesen →Eine Avalonia-App obfuskieren, ohne die Bindings zu zerstören
Avalonia ist nicht WPF mit anderem Logo, und der Unterschied zählt in dem Moment, in dem Sie es obfuskieren. Avalonia kompiliert Ihr .axaml zur Build-Zeit nach IL, sodass ein kompiliertes Binding ein typisierter Property-Accessor ist, der den Getter per Metadaten-Token referenziert — er übersteht eine vollständige Umbenennung unverändert —, während ein Reflection-Binding eine Zeichenfolge ist, die die Runtime per Name auflöst und die stillschweigend leer zurückkommt. Was zuerst bricht, ist keines von beiden: Es ist der ViewLocator in der Standard-MVVM-Vorlage, der eine View findet, indem er den Typnamen des View-Models nimmt, „ViewModel" durch „View" ersetzt und Type.GetType aufruft — eine Konvention, die eine Umbenennung in einen „Not Found"-TextBlock oder eine InvalidCastException verwandelt. Dieser Beitrag liest, was der XAML-Compiler für ein kompiliertes Binding tatsächlich erzeugt, zeigt, warum INotifyPropertyChanged nach der Umbenennung weiterhin passt, geht die beiden von Avalonia generierten Typen durch, die die Runtime mit Assembly.GetType über ihre wörtlichen Namen findet, und liefert die Nebula-Konfiguration und die DataTemplate-basierte View-Zuordnung, mit denen Sie die gesamte App flachlegen können, ohne die Teile anzufassen, die Avalonia per Name auflöst.
Lesen →Einen gRPC-Dienst obfuskieren, ohne das Drahtprotokoll zu brechen
gRPC legt zwei Arten von Namen in deine Assembly, und die Obfuskierung muss sie als Gegensätze behandeln. Die Namen, die über die Leitung reisen — der Dienstpfad, der Methodenpfad, die Feldnummern in einer Protobuf-Nachricht — sind ein Vertrag, von dem jeder Peer abhängt, und sie umzubenennen bricht die Interoperabilität so sicher wie das Ändern einer URL. Die Namen, die den Prozess nie verlassen — deine C#-Methodennamen, die Eigenschaftsnamen deiner Nachrichten, deine DI-Registrierungen — sind frei zu verschwinden. Der Haken ist, dass die Art eines gegebenen Namens vollständig davon abhängt, ob du Contract-First mit protoc oder Code-First mit protobuf-net.Grpc gegangen bist, denn Code-First leitet die Leitungsidentität per Reflexion aus deinen .NET-Namen ab und verwandelt die freien Namen zurück in tragende. Dieser Beitrag liest den generierten Code und die Metadaten, um genau zu zeigen, wo die Leitungsidentität in jedem Stil lebt, warum Protobuf-Feldnummern Nachrichtenmitglieder sicher umbenennbar machen und wie Nebula die Vertragsoberfläche fixiert, während es alles dahinter umbenennt.
Lesen →Einen Plugin-Host obfuskieren, ohne die Plugins zu zerstören
Ein Plugin-Host hat eine gespaltene Persönlichkeit, die die Obfuskierung genau respektieren muss. Die Vertrags-Assembly — die Schnittstellen, abstrakten Basisklassen und Attribute, gegen die Drittanbieter-Plugins kompilieren — ist eine veröffentlichte ABI: benenne eines ihrer Mitglieder um, und jedes bereits ausgelieferte Plugin gegen die alten Namen scheitert beim Binden, genauso wie das Umbenennen einer öffentlichen API ihre Aufrufer bricht. Aber der Host, der diese Plugins lädt, ist dein wertvollster Code und das, was du am meisten umbenennen willst. Beide leben in einer Lösung, und ein gewöhnlicher Obfuskierungslauf kann sie nicht auseinanderhalten. Dieser Beitrag liest die genauen Bindungspunkte — die Schnittstellen- und Methodentypnamen, die ein AssemblyLoadContext beim Laden auflöst, die [Export]/[Import]-Vertragsnamen, die MEF abgleicht, und die Attributtypnamen, nach denen ein Host scannt —, zeigt, warum jeder auf der ABI liegt und überleben muss, und wie Nebula die Vertragsoberfläche über ihre Form fixiert, während es den Host dahinter plattmacht.
Lesen →Eine WinForms-App obfuskieren, ohne Ressourcen zu verlieren
WinForms hat eine Falle, die WPF nicht hat: Der Designer verdrahtet jedes Formular mit einem eingebetteten .resources-Stream, dessen Name vom vollständigen Namen des Formulartyps abgeleitet wird, und bindet Steuerelemente über Eigenschaftsnamen als Zeichenfolge an Daten. Benennen Sie das Falsche um, und Ihre Symbole verschwinden oder ein gebundenes Feld bleibt leer — zur Laufzeit, ohne Kompilierfehler. Hier erfahren Sie genau, was der Designer ausgibt, warum das Umbenennen eines Form-Typs ComponentResourceManager bricht und wie Sie einen WinForms-Build mit Nebula.NET schützen, sodass die Interna gehärtet werden und der Designer weiterhin funktioniert.
Lesen →Wie Funktionszeiger in C# dekompilieren
Ein delegate* ist kein Delegate – es gibt kein Objekt, keine Invoke-Methode, keine Allokation. Es kompiliert zu einer rohen Codeadresse, die auf den Stack geschoben wird, und einer calli-Anweisung, die darüber aufruft. Ein Dekompilierer hat also nichts, worauf er sich stützen könnte: keinen Typnamen, keine Methode, der er folgen kann, nur einen indirekten Aufruf und eine eigenständige Signatur, die er lesen muss, um die Argumenttypen und die Aufrufkonvention zu kennen. Und die Konvention – managed, Cdecl, Stdcall, Thiscall – ist kein Schlüsselwort im IL; sie ist als modopt-Typen codiert, die an die Signatur angebolzt sind. Hier erfahren Sie genau, wie ein Funktionszeiger abgelegt wird, wie calli seine eigene Signatur benennt, wo die unmanaged-Konvention wirklich lebt, und wie Glass.NET das delegate* rekonstruiert, das Sie geschrieben haben.
Lesen →Wie Inline Arrays und stackalloc in C# 12 dekompilieren
Inline Arrays in C# 12 geben Ihnen einen Puffer fester Größe vom Werttyp, der inline in seinem umgebenden Struct lebt – das, was C `int buf[8]` nannte –, aber im IL ist es ein Struct mit einem einzigen Feld, dekoriert mit [InlineArray(8)], zugegriffen über Runtime-Intrinsics und Span<T> statt über eine Array-Instruktion. stackalloc wiederum kompiliert zu einem rohen localloc, das ein naiver Dekompiler als Zeiger und einen Haufen stind-Opcodes zeigt. Irren Sie sich bei einem von beiden, und der Dekompiler gibt unsafe-Zeigerarithmetik aus, wo die Quelle einen sauberen Indexer hatte, oder erfindet ein Array, das nie alloziert wurde. Hier ist genau, was der Compiler für einen [InlineArray]-Typ ausgibt, wie der Elementzugriff zu einem PrivateImplementationDetails-Helfer über einem Span absteigt, wie localloc und der Span(void*, int)-Konstruktor im IL aussehen, und wie Glass.NET beides zurück in die Inline-Array-Deklarationen und stackalloc-Ausdrücke liest, die Sie tatsächlich geschrieben haben.
Lesen →Wo Nullable Reference Types in den Metadaten leben
string und string? sind für die Runtime derselbe Typ — System.String, eine TypeRef, kein Unterschied in irgendeiner Signatur. Das Fragezeichen existiert nur zur Compilezeit, und der Compiler muss es irgendwo in die Assembly schmuggeln, damit die Konsumenten deiner Bibliothek die richtigen Warnungen bekommen. Er tut das mit zwei eingebetteten Attributen, NullableAttribute und NullableContextAttribute, einem Byte-Vokabular aus drei Werten, einer Preorder-Verflachung generischer Typbäume in Byte-Arrays und einem aggressiven Kompressionsschema, das weglässt, was dem umgebenden Standard entspricht. Dieser Beitrag liest diese Bytes direkt aus dem IL, zeigt die exakte Blob-Kodierung für die Ein-Byte- und die Array-Form, geht durch, wie ein Decompiler ?, notnull und class? daraus rekonstruiert, und erklärt, warum das Überspringen dieses Schritts den öffentlichen Vertrag einer Bibliothek still ändert.
Lesen →Wie statische abstrakte Interface-Member dekompilieren
C# 11 ließ Interfaces statische abstrakte Member deklarieren, und die BCL nutzte das, um generische Mathematik zu bauen – schreiben Sie Sum<T>(span) einmal, und es läuft über int, double oder Ihren eigenen Typ. Doch das Feature stützt sich auf eine Ecke der ECMA-Spezifikation, die die meisten Dekompiler nie behandeln mussten: einen constrained-Aufruf an eine *statische* Interface-Methode, zur Laufzeit zum Typargument aufgelöst. Macht man es falsch, gibt der Dekompiler einen Aufruf an eine Methode aus, die keinen Empfänger zu haben scheint, oder erfindet einen Cast, der nicht da ist. Hier ist genau, was der Compiler für T.Zero und a + b über eine generische Einschränkung ausgibt, warum das Präfix constrained. auf einem nicht-virtuellen statischen Aufruf der ganze Trick ist, und wie Glass.NET es zurück in die Operatoren und statischen Member liest, die Sie tatsächlich geschrieben haben.
Lesen →Eingebettete Ressourcen verschlüsseln: die Daten, die Ihr Obfuskator vergisst
Sie haben jeden Typ umbenannt, jede Zeichenkette verschlüsselt und die heißen Methoden virtualisiert – und dann hat jemand Ihr Assembly in einem Ressourcen-Viewer geöffnet und Ihr eingebettetes SQL, Ihr Lizenzschlüsselmaterial und den vollständigen Text Ihrer Fehlermeldungen direkt aus dem .resources-Blob gelesen. Verwaltete Ressourcen sind kein Code, daher rührt der Schutz auf Methodenebene sie nie an; sie liegen im Manifest als längenpräfixierte Werte, die jeder auslesen kann. So werden eingebettete Ressourcen tatsächlich in einer PE gespeichert, warum die Umbenennung sie unberührt lässt, und wie Nebula sie zur Buildzeit verschlüsselt und über einen Resolver transparent entschlüsselt, sodass Ihre Aufrufe an ResourceManager und GetManifestResourceStream unverändert weiterlaufen.
Lesen →Lizenz-Heartbeats und Lease-Reaping für gleichzeitige Seats
Eine Floating-Lizenz verkauft N Plätze, die ein Team teilt, also muss der Server wissen, wie viele *gerade jetzt* in Gebrauch sind. Das ist einfach, bis ein Client auf die falsche Art stirbt – ein Absturz, eine verworfene VM, ein herausgerissenes Netzwerkkabel – und seinen Platz nie zurückgibt. Zählen Sie beim Checkout, und der Platz ist für immer verloren; Ihr Kunde zahlt für zehn und kann sechs ausführen. Die Lösung besteht darin, Checkout/Checkin nicht mehr als zusammengehöriges Paar zu behandeln und jeden Platz als Lease mit einer Lebensdauer (TTL) zu betrachten, die der Client per Heartbeat am Leben halten muss. Hier ist das Lease-und-Heartbeat-Protokoll in Keyright: das signierte Lease mit kurzer TTL, die Erneuerungsschleife auf dem Client, der Reaper, der tote Plätze auf dem Server zurückfordert, und die Uhren- und Gnadenregeln, die die Zählung ehrlich halten, ohne ein instabiles Netzwerk zu bestrafen.
Lesen →Die Lizenz-Payload versionieren, ohne Clients zu brechen
Eine signierte Lizenz ist eine Menge von Claims, in Bytes eingefroren, und sobald du einen Client auslieferst, der sie liest, wird dieses Byte-Layout zu einem Vertrag, den du nicht einseitig ändern kannst. Dann verlangt das Produktmanagement einen neuen Claim — ein Sitz-Limit, eine Regionssperre, eine Funktionsliste — und du stellst fest, dass die Hälfte deiner Installationsbasis einen Parser ausführt, der ihn noch nie gesehen hat. Dieser Beitrag zeigt, wie sich Lizenz-Payloads im Keyright-Stil sicher weiterentwickeln: eine von der Signatur abgedeckte Schema-Version, ein Open-World-Parsing, das unbekannte Claims verifizierbar hält, eine Liste kritischer Claims, damit ein alter Client ablehnt, was er nicht durchsetzen kann, statt es still zu ignorieren, eine Schema-Aushandlung bei der Aktivierung, damit die ausstellende Seite nie etwas ausgibt, das ein Client nicht lesen kann, und die Golden-File-Tests, die verhindern, dass eine Formatänderung unbemerkt in die Produktion gelangt.
Lesen →Lizenzen an eine Person binden, nicht an eine Maschine
Die Maschinenbindung beantwortet die Frage „Welcher Rechner ist das?" – doch viele Produkte werden pro *Platz* verkauft, nicht pro Kiste. Ein Entwickler mit Laptop, Desktop und CI-Runner ist ein zahlender Nutzer, nicht drei Aktivierungen. Die Named-User-Lizenzierung dreht den Anker um: Die Lizenz gehört einer Identität, und Geräte hängen als Blätter unter einem von Ihnen kontrollierten Limit an ihr. Hier erfahren Sie, wie Sie in Keyright einen signierten Identitätsanspruch modellieren, eine Anmeldung gegen ein kurzlebiges, gerätegebundenes Lease eintauschen, ein Gerätelimit durchsetzen, ohne den Nutzer an eine Kiste zu fesseln, und einem Nutzer erlauben, ein Gerät aus einem vollen Platz zu entfernen – mit dem echten C# zum Ausstellen, Binden und Verifizieren.
Lesen →Die .NET-Funktionen, die Ihre umbenannten Member verraten
Sie haben jeden Typ und jede Methode umbenannt, dann das obfuskierte Binary geöffnet und Ihre Originalnamen in reinen String-Literalen gefunden. Der Schuldige ist kein Fehler im Obfuscator – es ist der Compiler. nameof(OrderService) backt das Literal "OrderService" zur Compile-Zeit in die IL, lange bevor die Umbenennung läuft, und [CallerMemberName] macht dasselbe mit dem ursprünglichen Methodennamen als Standardwert eines Parameters. Benennen Sie den Member um, und das Literal sagt weiterhin den alten Namen, sodass ein Decompiler Ihre Zuordnung gratis liest und jede Reflection, die den Laufzeitnamen erwartet, still bricht. Hier erfahren Sie, woher diese Literale in der IL genau stammen, warum die Umbenennung sie allein nicht anfassen kann und wie die String-Verschlüsselung und die umbenennungsbewusste Behandlung von Nebula.NET das Leck schließen.
Lesen →Eine ASP.NET-Core-App obfuskieren, ohne sie zu zerstören
ASP.NET Core findet fast alles zur Laufzeit über Namen: Controller-Typen über ihr Suffix, Aktionen über den Methodennamen, Routen aus den Token [controller] und [action], Query- und Formularparameter über Parameternamen, JSON-Eigenschaften über Eigenschaftsnamen, Hub-Methoden über Zeichenketten, Options-Klassen über Konfigurationsschlüssel. Benenne eines davon um und die App kompiliert weiter, startet weiter und liefert 404 oder ein leeres DTO. Dieser Beitrag kartiert jede reflexionsgesteuerte Naht einer ASP.NET-Core-App — MVC, Minimal APIs, Razor-Views und Tag Helper, SignalR, das Options-Pattern, Hosted Services —, zeigt, wie umbenannte Metadaten tatsächlich aussehen, und baut eine nebula.config.json, die die Services und die Domäne umbenennt und härtet, während sie genau die Oberfläche fixiert, die das Framework beobachtet.
Lesen →P/Invoke-Code obfuskieren, ohne die Interoperabilität zu brechen
Umbenennung ist das Rückgrat der Obfuskierung, und sie bricht genau dort, wo Ihr verwalteter Code aufhört, in sich geschlossen zu sein – an der Grenze zum nativen Code. Eine [DllImport]-Methode, ein Delegat, den Sie zu einem Funktionszeiger marshallen, ein Struct, das Sie über die Grenze schieben: Jedes trägt einen Namen oder ein Layout, von dem etwas außerhalb der CLR abhängt, und benennen Sie es blind um, scheitert der Aufruf zur Laufzeit mit einer MarshalDirectiveException oder einem stillschweigend beschädigten Struct. Deshalb überlebt native Interop die Obfuskierung nur, wenn das Werkzeug den Marshaller versteht: welche Namen tragend sind, warum EntryPoint den verwalteten Namen vom nativen entkoppelt, wie Feldreihenfolge und StructLayout erhalten bleiben müssen, und wie Nebula alles rund um die Grenze umbenennt und die Grenze selbst unangetastet lässt.
Lesen →Eine aktivierte Lizenz sicher auf dem Client speichern
Die Aktivierung gibt dem Client ein signiertes Lease; dann kommt die Frage, die niemand einplant: Wo legt man es ab? In eine einfache Datei geschrieben, editiert ein Benutzer das Ablaufdatum; schlecht verschlüsselt, hat man die App aus Versehen an eine einzige Maschine gebunden. Der Cache dient der Verfügbarkeit, nicht der Authentizität: Die Signatur entscheidet weiterhin, ob ein Lease echt ist, also hat der Speicher nur drei Aufgaben: einen Neustart überstehen, beiläufiges Editieren abwehren und ein Lease verweigern, das von einer anderen Maschine kopiert wurde. Hier erfahren Sie, wie Sie ein gecachtes Lease mit DPAPI versiegeln, wo es das gibt, es per HMAC an das Gerät binden, damit ein editierter oder transplantierter Cache erkannt wird, und warum Sie dem gecachten Ablaufdatum niemals mehr vertrauen dürfen als dem signierten.
Lesen →Wie das dynamic-Schlüsselwort dekompiliert
Eine Zeile C# mit dynamic kompiliert zu einer gecachten Call-Site, einem Binder, einem Array von Argument-Info-Flags und einem Aufruf über ein Delegate-Feld — ein Dutzend Member generiertes Gerüst für einen einzigen Methodenaufruf. Hier ist, was der Compiler für dynamischen Dispatch tatsächlich ausgibt, wie ein naiver Decompiler Ihnen die rohe CallSite-Maschinerie zeigt und wie Glass.NET das Muster erkennt und Ihnen die eine Zeile zurückgibt, die Sie geschrieben haben.
Lesen →Wie lokale Funktionen in C# dekompilieren
Eine lokale Funktion ist keine Lambda, und der Compiler beweist es im IL. Es gibt keine Delegate-Allokation und keine Closure-Klasse — eine lokale Funktion ohne Capture wird zu einer gewöhnlichen statischen Methode mit einem gemangelten Namen wie <Run>g__Add|0_0, und eine, die captured, wird zu einer Methode, die ihre erfassten Variablen per ref in einem Werttyp-Display-Struct empfängt, sodass nichts auf dem Heap landet. Hier ist genau, was der C#-Compiler für beide Arten ausgibt, wie ein Dekompiler, der das Muster nicht erkennt, dir die gemangelte Methode und das ref-Struct übergibt, und wie Glass.NET es in die lokale Funktion zurückfaltet, die du geschrieben hast.
Lesen →Einen interpolierten String-Handler zurück zum Quelltext lesen
Modernes C# kompiliert $"Hello {name}" nicht mehr zu string.Format — es wird zu einem DefaultInterpolatedStringHandler mit AppendLiteral- und AppendFormatted-Aufrufen abgesenkt. Hier sehen Sie genau, wie das in IL aussieht, wie Glass.NET die Sequenz per Mustererkennung zurück in einen interpolierten String mit intakter Format- und Ausrichtungsangabe verwandelt — und den einen Fall, in dem es das ehrlicherweise nicht kann.
Lesen →Wo Tupel-Elementnamen in den Metadaten leben
Ein ValueTuple hat kein Feld namens count oder name — das sind Item1 und Item2, und das Typsystem weiß nichts von deinen Namen. Die Namen, die du geschrieben hast, leben in einem [TupleElementNames]-Attribut, das der Compiler an die Methodensignatur, das Feld oder die Eigenschaft anhängt, als Array von Zeichenketten mit null an den namenlosen Stellen. Ein Dekompiler, der dieses Attribut ignoriert, gibt dir Item1/Item2; einer, der es liest, stellt (int count, string name) wieder her. Hier erfährst du genau, wie Tupelnamen kodiert werden, warum sie auf Signaturen überleben, aber auf lokalen Variablen verschwinden, und wie Glass.NET sie wieder einsetzt.
Lesen →Container und automatisch skalierte .NET-Dienste mit Keyright lizenzieren
Maschinengebundene Lizenzierung setzt eine Maschine voraus: einen stabilen Rechner mit einem Fingerabdruck, dem ein Platz zugewiesen werden kann. Ein Container hat nichts davon — das Image ist über alle Replikate identisch, der Host ist flüchtig, und ein Autoscaler startet und stoppt Instanzen schneller, als ein Aktivierungsablauf folgen kann. So lizenzierst du einen horizontal skalierten .NET-Dienst mit Keyright: einmal an der Deployment-Grenze aktivieren, eine signierte Lizenz in jedes Replikat ausliefern, offline ohne Aufruf pro Instanz validieren und vorab entscheiden, ob ein Platz ein Deployment oder eine laufende Instanz bedeutet.
Lesen →Eine Lizenzschranke entwerfen, die fail-closed ist
Ein einzelner Validate()-Aufruf ist der einfache Teil der Lizenzierung. Der schwierige Teil ist die Architektur: wo in Ihrer App die Prüfung lebt, wie oft sie läuft, was Sie zwischen den Läufen cachen und — die Frage, die entscheidet, ob ein Bug einen zahlenden Kunden aussperrt oder Ihre Software verschenkt — welche Fehler fail-closed und welche fail-open behandelt werden. Hier ist ein ausfallsicheres License Gate für .NET auf Basis von Keyright, mit einer Entscheidungstabelle Status für Status und einem gecachten Snapshot, der offline weiterlebt.
Lesen →Wie eine Lizenz entscheidet, welche Versionen sie ausführen darf
Eine unbefristete Lizenz gilt für immer; „ein Jahr Updates" nicht — und beide stecken im selben Schlüssel. Release-Abdeckung ist die Art, wie eine Lizenz erklärt, welche Versionen sie ausführen darf: als signierte Versionsbereichs- und Zeitfenster-Grants, die der Build lokal, offline und ohne Reaktivierung prüft. Hier erfährst du, wie ein Abdeckungs-Grant geformt ist, wie das Berechtigungsdatum (nicht das Installationsdatum) über einen Hotfix entscheidet, wie der signierte Block mit dem Lease mitreist und wie dein Build ihn ohne einen einzigen Netzwerkaufruf auf dem heißen Pfad durchsetzt.
Lesen →Eine EF-Core-App obfuskieren, ohne die Datenschicht zu zerbrechen
EF Core bildet deine CLR-Typen anhand ihrer Namen auf Tabellen ab. Benenne eine Entität oder eine Eigenschaft mit einem Obfuskator um, und standardmäßig wandert das von EF erwartete Schema mit — dein DbContext sucht nun eine Tabelle namens "a" mit einer Spalte "c", Migrationen passen nicht mehr und zeichenkettenbasierter Eigenschaftszugriff wirft zur Laufzeit. Die Lösung ist nicht, deine gesamte Datenschicht von der Obfuskierung auszunehmen. Sie besteht darin, genau zu verstehen, welche Namen EF zur Laufzeit liest, dein Mapping explizit zu machen, um das Schema von den CLR-Namen zu entkoppeln, und Nebula.NET dann die Member frei umbenennen zu lassen. Hier ist das vollständige Bild, mit den Umbenennungsregeln und den EF-Mustern, die es sicher machen.
Lesen →Eine Multi-Target-Assembly mit einer Konfiguration obfuskieren
Eine Bibliothek, die net48;net8.0 anvisiert, wird zu zwei verschiedenen Assemblies gebaut, mit zwei verschiedenen Referenzmengen und manchmal zwei verschiedenen IL-Varianten. Nur eine davon zu schützen liefert einen unobfuskierten Build aus. So behandelt Nebula.NET jedes Zielframework als eigenen Obfuskierungslauf mit einer gemeinsamen Policy — und das sind die Pro-TFM-Fallstricke, die zuschnappen, wenn Sie es nicht tun.
Lesen →Ein .NET-Assembly nach der Obfuskierung neu signieren
Das Umbenennen schreibt dein Assembly neu, was den starken Namen und die Authenticode-Signatur ungültig macht, mit denen es gebaut wurde — ein geschützter Build, der unsigniert ausgeliefert wird oder schlimmer mit einer nun gebrochenen Signatur, lädt nicht oder scheitert an der Prüfung. Nebula.NET signiert als letzten Pipeline-Schritt für dich neu: eine neue Starker-Name-Signatur über dem obfuskierten Image, assembly-übergreifende Public-Key-Token neu geschrieben, damit voneinander abhängige Assemblys sich noch auflösen, dann eine Authenticode-Signatur obendrauf. Hier ist die genaue Reihenfolge, wie du den Schlüssel einem Build-Server gibst, ohne ihn einzuchecken, und was InternalsVisibleTo kaputtmacht, wenn du es vergisst.
Lesen →Obfuskierte Namen über Releases hinweg stabil halten
Standardmäßig benennt jeder Obfuskierungslauf von Grund auf neu, sodass eine Methode, die in 1.4.0 „a" hieß, in 1.4.1 zu „q" wird und jede archivierte Deobfuskierungs-Map in dem Moment verrottet, in dem Sie ausliefern. seedMapFile von Nebula.NET fixiert die Ausgabe an ihrem Platz: Unveränderte Member behalten den obfuskierten Namen vom letzten Release, nur neuer Code bekommt neue Namen. So funktioniert die Symbol-Map, warum stabile Namen Crash-Symbolisierung und Binär-Diffs handhabbar machen, und wie Sie inkrementelle Obfuskierung in CI verdrahten.
Lesen →Code testen, der hinter einer Lizenzprüfung liegt
Ihre bezahlten Funktionen liegen hinter einem Lizenz-Gate — aber wie testen Sie sie ohne laufenden Lizenzdienst, ohne echten Schlüssel und ohne Abhängigkeit von der Systemuhr? Hier ist eine zweischichtige Strategie für Keyright: eine dünne Nahtstelle, die Sie für schnelle Unit-Tests mocken, und eine Handvoll eingecheckter, mit einem Testschlüssel signierter Fixtures, die den echten SDK-Verifikationspfad vollständig offline und deterministisch in CI durchlaufen.
Lesen →Eine DLL mit Glass.NET zurück in ein baubares Projekt verwandeln
Dekompiliertes C# in einem Fenster zu lesen ist eine Sache; ein .csproj zu bekommen, das Sie öffnen, greppen, refaktorieren und kompilieren können, eine andere. So rekonstruiert der Projekt-Export von Glass.NET ein ganzes Assembly — Quelle, Referenzen, Ressourcen —, was er sauber bewältigt, wo vom Compiler erzeugter Code Nachhilfe braucht, und wie Sie ihn von der CLI aus skripten.
Lesen →Signaturschlüssel für Lizenzen rotieren, ohne Kunden auszusperren
Ihre Lizenzschlüssel und Leases sind nur so vertrauenswürdig wie der Schlüssel, der sie signiert. So rotieren Sie diesen Signaturschlüssel ohne Ausfallzeit zu einem neuen: überlappendes Vertrauen mit AdditionalPublicKeysBase64, ein gestaffelter Rollout, und wie Leases und Offline-Dateien den Übergang sicher machen.
Lesen →Erkennen, wann ein geschützter .NET-Build angegriffen wird
Anti-Tamper- und Anti-Debug-Wächter reagieren auf der Maschine des Nutzers — aber Sie erfahren nie, dass sie ausgelöst haben. Das Report-home von Nebula.NET (tamperReportUrl, Pro) POSTet ein minimales Ereignis an Ihren eigenen Endpunkt in dem Moment, in dem ein Wächter auslöst, sodass ein Angriff auf einen ausgelieferten Build zu einem verwertbaren Signal wird. So funktioniert es und so bauen Sie den Empfänger.
Lesen →Warum Lizenzsignaturen kanonische Signierung brauchen
Eine Signatur wird über Bytes berechnet, nicht über Felder — wenn Ihr ausstellender Dienst und Ihr Client das Lizenz-Payload also auch nur geringfügig anders serialisieren, schlägt die Verifikation bei einer völlig echten Lizenz fehl. So kanonisieren Sie ein Payload ein einziges Mal (stabile Feldreihenfolge, kulturinvariante Zahlen- und Datumsformatierung, UTF-8, base64url), damit eine Signatur in .NET, Node, Python und Java identisch verifiziert.
Lesen →Collection-Ausdrücke und primäre Konstruktoren dekompilieren
Collection-Ausdrücke und primäre Konstruktoren lesen sich wie einzelne syntaktische Ideen, doch der Compiler senkt sie je nach Zieltyp und je nachdem, ob ein Parameter erfasst wird, zu sehr unterschiedlichem IL ab. Hier steht genau, was `[1, 2, 3]`, Spreads und ein primärer Konstruktor erzeugen und wo ein Decompiler den Zucker zurückfalten kann gegenüber dort, wo er nur die abgesenkte Form zeigen kann.
Lesen →.NET-Apps mit Native AOT und Single-File obfuskieren
Die Veröffentlichung als Single-File oder mit Native AOT ist Verpackung und Kompilierung, keine Schutzmaßnahme. Hier steht, was jeder Modus wirklich mit Ihrem Code macht, warum Single-File-Apps weiterhin vollständig wiederherstellbares verwaltetes IL ausliefern, was Native AOT verbirgt und was nicht – und warum die Obfuskierung auf dem IL laufen muss, bevor das Bundle gebaut oder der AOT-Compiler es entfernt.
Lesen →Ihre Lizenzprüfungen automatisch härten
Die Methode, die Ihre Lizenz prüft, ist das Ziel mit dem höchsten Wert in Ihrer ganzen App — knacken Sie sie, und alles andere ist hinfällig. Nebula.NET kann die Methoden finden, die Ihr Lizenz-SDK aufrufen, und automatisch den stärksten Schutz, den Ihre Edition erlaubt, genau auf diese Methoden anwenden, sodass das Tor gehärtet wird, ohne dass Sie es von Hand auflisten. So funktioniert die Auto-Protection.
Lesen →Wenn await und yield sich eine Zustandsmaschine teilen
Eine async-IAsyncEnumerable-Methode mischt await und yield return — der Compiler erzeugt also eine einzige Zustandsmaschine, die zugleich eine Async-Zustandsmaschine und ein Iterator ist. Hier steht die Form, zu der sie abgesenkt wird, wie das Zustandsfeld sowohl Await-Fortsetzungen als auch Yield-Punkte treibt und wie ein Decompiler das Muster erkennt, um await foreach wiederaufzubauen.
Lesen →C#-Pattern-Matching und switch-Ausdrücke dekompilieren
Ein switch-Ausdruck ist kein Konstrukt in IL — er wird zu einer Kette aus Typprüfungen, Null-Prüfungen und Sprüngen reduziert, die mit einer geworfenen SwitchExpressionException für den nicht abgedeckten Fall endet. Hier steht genau, was der Compiler für Typ-, Eigenschafts-, relationale und logische Muster ausgibt, und wie ein Decompiler die Form wieder zu einem switch zusammensetzt.
Lesen →Wie eine using-Anweisung in C# dekompiliert
Eine using-Anweisung hat kein eigenes IL — der Compiler senkt sie zu einem try/finally ab, das Dispose aufruft, und await using zu einem try/finally, das DisposeAsync awaited. Hier steht genau, wie dieser generierte Code aussieht, die Feinheiten von Null-Prüfung und Struct-Enumerator, und wie ein Decompiler ihn zurück in using klappt.
Lesen →Was .NET-Obfuskierung zur Laufzeit kostet
Nicht jeder .NET-Schutz hat dieselben Laufzeitkosten. Umbenennen ist kostenlos; String- und Konstanten-Verschlüsselung fügen ein winziges Decodieren pro Nutzung hinzu; Kontrollfluss-Abflachung fügt Verteilungs-Overhead hinzu; Methoden-Verschlüsselung und Virtualisierung sind pro Aufruf schwer. Hier steht das ehrliche Kostenmodell jeder Transformation und wie man Schutz eingrenzt, um das Wichtige zu verteidigen, ohne einen heißen Pfad zu bremsen.
Lesen →Was Ihre App tun sollte, wenn der Lizenzserver ausgefallen ist
Eine Lizenzprüfung, die hart scheitert, sobald der Server nicht erreichbar ist, macht Ihren Ausfall — oder das wackelige WLAN des Kunden — zu seinem Ausfall. Hier steht, wie man Kulanzfenster entwirft, fail-open vs. fail-closed pro Stufe wählt und verhindert, dass eine vorübergehende Netzwerkstörung zahlende Kunden aussperrt.
Lesen →Referenz-Obfuskierung in .NET: den Aufrufgraphen verbergen
Benennen Sie alles um, und ein Decompiler liest Ihre Absicht trotzdem aus den Aufrufen, die Sie tätigen: File.ReadAllText, RSA.Create, Ihr eigenes CheckLicense. Referenz-Obfuskierung (Proxy-Aufrufe) leitet diese Aufrufe über generierte Proxys, sodass die Aufrufstelle ihr Ziel nicht mehr nennt. So funktioniert es in IL, was es abwehrt und was es kostet.
Lesen →So testen Sie die Lizenzierungs-Integration Ihrer Software
Lizenzierungsfehler gehen in Produktion, weil der einzige Pfad, den jemand durchläuft, „gültiger Schlüssel, Server erreichbar, Uhr korrekt" lautet. So bringen Sie Ablauf, Widerruf, Offline-Kulanz und Platzlimits unter automatisierte Tests: injizieren Sie die Uhr, faken Sie den Lizenz-Client und steuern Sie jeden Grenzfall aus xUnit, damit die CI die Aussperrungen vor Ihren Kunden findet.
Lesen →Eine zeitlich begrenzte Demo Ihrer .NET-App veröffentlichen
Manchmal wollen Sie einen Build, der nach einem Datum einfach aufhört zu funktionieren — eine Konferenzdemo, eine Evaluierungskopie, eine Vorabversion, die nicht ewig in Produktion laufen darf. Nebula.NET kann ein Ablaufdatum in den Assembly selbst einbacken, durchgesetzt aus einem Modul-Initialisierer, bevor Ihr Code läuft, mit einer Reaktion Ihrer Wahl. So funktioniert es und wann Sie es statt serverbasierter Lizenzierung verwenden.
Lesen →Anatomie eines signierten Lizenzschlüssels: warum er nicht gefälscht werden kann
Ein guter Lizenzschlüssel ist keine zufällige Zeichenkette, die gegen eine Liste geprüft wird — er ist ein signierter Claims-Payload, den die App offline mit einem öffentlichen Schlüssel verifizieren kann, den sie ausliefert. Hier steht, was in einem signierten Schlüssel lebt, warum die Privat/Öffentlich-Trennung ihn unfälschbar macht, wie die Verifikation ohne Server funktioniert und wogegen die Signatur schützt und wogegen nicht.
Lesen →.NET-Assemblies mit Wasserzeichen versehen, um Build-Lecks zurückzuverfolgen
Obfuskierung hindert einen Leser daran, Ihren Code zu verstehen; sie tut nichts, um Ihnen zu sagen, welcher Kunde ihn durchgestochen hat. Ein Wasserzeichen pro Lizenznehmer tut es — ein verdeckter, eindeutiger Marker, der in jeden Build eingebacken ist, gewöhnliches Kopieren übersteht und ein durchgestochenes Assembly dem Konto zuordnet, dem es ausgestellt wurde. Hier steht, was ein gutes Wasserzeichen sein muss, wo es lebt und wie es Obfuskierung und Lizenzierung ergänzt.
Lesen →Die Konstanten verbergen, die Decompiler in .NET lesen
Die String-Verschlüsselung bekommt die Aufmerksamkeit, aber die numerischen Literale in Ihrem Code — Schwellenwerte, Opcodes, magische Zahlen, Offsets — kompilieren zu ldc-Instruktionen, die ein Decompiler sofort liest. Hier steht, wie numerische Konstanten Logik verraten, wie die Konstanten-Verschlüsselung sie durch zur Laufzeit decodierte Werte ersetzt und wo sie neben der String-Verschlüsselung und dem Kontrollfluss-Schutz einzuordnen ist.
Lesen →Was ein Decompiler in C#-Records offenlegt
Ein Record ist eine Klasse plus ein präziser Satz compilergenerierter Member — Wertgleichheit, eine Klonmethode, ein Deconstruct, ein PrintMembers/ToString, init-only-Setter. Ein Decompiler erkennt diesen Fingerabdruck und baut das Schlüsselwort record wieder auf. Hier steht genau, was der Compiler für einen Record ausgibt und wie das Muster zurückgelesen wird.
Lesen →Wie yield return zu einer Zustandsmaschine wird
Eine Iteratormethode mit yield return hat keine direkte IL-Darstellung — der Compiler schreibt sie in eine generierte Klasse um, die IEnumerator implementiert und innerhalb eines MoveNext-switch fortsetzt. Hier steht die Form dieser Zustandsmaschine, wie ein Decompiler sie erkennt und wie yield return und yield break aus dem generierten Code wiedergewonnen werden.
Lesen →Das Laufzeit-Patching, das Ihre Integritätsprüfung übersieht
Eine Anti-Tamper-Prüfung, die die DLL auf der Festplatte hasht, erkennt eine gepatchte Datei — aber keine zur Laufzeit im Speicher umgeschriebene Methode. Bibliotheken wie Harmony leiten Ihre Methoden um, ohne die Datei zu berühren, und genau so funktionieren moderne Lizenz-Umgehungen und Cheats. Hier steht, wie In-Memory-Patching funktioniert und was es wirklich erkennt.
Lesen →Wie Lizenzierung Uhrmanipulation übersteht
Tests und Abonnements laufen an einem Datum ab — aber die Geräteuhr wird vom Angreifer kontrolliert, und sie zurückzustellen ist der älteste Trick, um eine abgelaufene Lizenz wiederzubeleben. Hier steht, warum Sie der lokalen Zeit nicht trauen können, und die Hochwassermarken- und Server-Zeit-Techniken, die den Ablauf verteidigen, ohne ehrliche Nutzer zu bestrafen.
Lesen →Einen Maschinen-Fingerabdruck entwerfen, der stabil, aber nicht brüchig ist
Node-Locking bindet eine Lizenz an ein Gerät, was bedeutet, dass Sie einen Fingerabdruck brauchen, der einzigartig genug ist, um eine Maschine zu identifizieren, und doch stabil genug, um ein RAM-Upgrade zu überstehen. Hier steht, wie man ihn aus gewichteten Hardware-Signalen baut, mit Toleranz abgleicht, zum Schutz der Privatsphäre hasht und die VM- und Hardware-Wechsel-Fälle behandelt, über die naive Implementierungen stolpern.
Lesen →Was Anti-Debugging in .NET kann und was nicht
Ein Debugger ist, wie ein Angreifer Ihre entschlüsselten Strings beobachtet und einen Breakpoint auf Ihre Lizenzprüfung setzt. Hier sind die verwalteten, nativen und zeitbasierten Wege, wie eine .NET-App einen erkennen kann — mit echtem Code — und eine ehrliche Einordnung, warum Anti-Debugging ein Bremsschwelle ist, keine Mauer.
Lesen →Einen Test in eine bezahlte Lizenz umwandeln — ohne Neuinstallation
Ein Testnutzer, der zahlt, sollte an Ort und Stelle zum lizenzierten Nutzer werden: dieselbe Installation, dieselben Daten, kein erneut einzugebender Schlüssel. So funktioniert eine saubere Test-zu-Kauf-Umwandlung: den Schlüssel an Ort und Stelle hochstufen, die zwischengespeicherten Berechtigungen auffrischen und den Testablauf so gestalten, dass Zahlen einfach wiederherstellt, was da war.
Lesen →Wozu Lambdas und Closures dekompilieren
Dekompilieren Sie eine Methode mit einer Lambda, und Sie finden einen Typ namens <>c__DisplayClass mit Ihren lokalen Variablen als Feldern. Hier steht, wie der C#-Compiler Closures in Klassen verwandelt, warum eine erfassende Lambda alloziert und eine nicht-erfassende nicht, und was der generierte Code über einen Closure-Bug verrät.
Lesen →Was ein Decompiler ohne PDB wiederherstellt
Eine Release-DLL wird ohne ihr PDB ausgeliefert, und dennoch rekonstruiert ein Decompiler lesbares C#. Hier ist die Aufteilung: Was in den Assembly-Metadaten lebt (und überlebt), was nur im PDB lebt (lokale Namen, Zeilennummern) und wie ein Decompiler die Lücke füllt, wenn die Symbole fehlen.
Lesen →Obfuskierte .NET-Stacktraces lesen
Umbenennungs-Obfuskierung verwandelt Ihre Produktions-Stack-Traces in eine Wand aus a, b, c — es sei denn, Sie bewahren die Umbenennungs-Map auf. Hier steht, wie die Map funktioniert, wie Sie aus einem obfuskierten Crash einen lesbaren Trace wiederherstellen und wie Sie die Map sicher halten, ohne sie auszuliefern.
Lesen →Wie .NET-Metadaten-Tabellen funktionieren — und wie ein Decompiler sie liest
Jede .NET-Assembly trägt eine kleine relationale Datenbank ihrer eigenen Struktur in sich: die Metadaten-Tabellen. Hier steht, was TypeDef, MethodDef und die codierten Indizes tatsächlich enthalten, wie ein Metadaten-Token eine Zeile adressiert und wie ein Decompiler die Tabellen durchläuft, um eine DLL wieder in Typen und Methoden zu verwandeln.
Lesen →Einen Lizenzschlüssel stilllegen, online und offline
Eine Lizenz auszustellen ist einfach; eine nach Rückerstattung, Leak oder Rückbuchung zu stoppen ist die schwierigere Hälfte. So funktioniert Widerruf wirklich: der Online-Check-in, der in den gesperrten Zustand fällt, signierte Widerrufslisten, die Offline-Clients erreichen, und wie man das Expositionsfenster begrenzt, das man nie ganz schließen kann.
Lesen →Was Obfuskierung kaputt macht: Reflection, Serialisierung und was auszuschließen ist
Wenn Sie eine funktionierende App zum ersten Mal obfuskieren, kann sie auf überraschende Weise brechen: Das JSON kommt falsch heraus, Reflection liefert null, das Data-Binding hört auf. Die Ursache ist immer dieselbe: Etwas hat ein umbenanntes Mitglied über seinen Namen aufgelöst. Hier steht genau, was bricht, warum, und wie man die richtigen Dinge ausschließt, ohne den Schutz zu schwächen.
Lesen →Lizenzauslieferung mit Fulfillment-Webhooks automatisieren
Eine bezahlte Bestellung sollte eine Lizenz ohne menschliches Zutun erzeugen. So funktionieren Fulfillment-Webhooks von Anfang bis Ende: die Signatur über den rohen Body prüfen, die Auslieferung pro Bestellung idempotent machen und die Ereignisse Bezahlung, Rückerstattung und Stornierung auf Ausstellen, Widerrufen und Verlängern abbilden.
Lesen →Wozu async/await dekompiliert
Dekompilieren Sie eine async-Methode, und Sie sehen kein async/await — Sie sehen eine vom Compiler generierte Struktur mit einem switch in MoveNext(). Hier steht, wie der C#-Compiler async in eine Zustandsmaschine überführt, wie man den Typ <Methode>d__N liest, den ein Decompiler zeigt, und wie ein guter Decompiler das Original rekonstruiert.
Lesen →Warum umbenanntes .NET sich noch wie Quellcode liest
Das Umbenennen von Bezeichnern ist die schwächste Obfuskierungsschicht: Ein Decompiler auf nur umbenanntem Code zeigt Ihre Logik, Ihre Strings und Ihre Konstanten weiterhin unverändert. Hier steht, was das Umbenennen verbirgt und was nicht — und die Schichten (String-Verschlüsselung, Konstanten-Maskierung, Kontrollfluss-Glättung und Virtualisierung), die .NET wirklich schwer lesbar machen.
Lesen →Berechtigungen und Feature-Flags, gesteuert von der Lizenz
Wie Sie Funktionen freischalten und numerische Limits je nach Lizenzstufe durchsetzen: signierte Berechtigungsvorlagen, das Lesen von Flags und Limits offline in Ihrer App, Durchsetzung an der Grenze jeder Fähigkeit und das Ändern dessen, was eine Stufe freischaltet, ohne eine neue Version zu veröffentlichen.
Lesen →