Was eine Strong-Name-Signatur wirklich beweist
Ein PublicKeyToken in einer Assembly-Referenz sieht aus wie ein Manipulationssiegel und ein Herausgeberstempel, ist aber keines von beidem. Hier ist genau, was Glass.NET aus der Assembly-Tabelle und dem #Blob-Heap liest, um den öffentlichen Schlüssel anzuzeigen, das 8-Byte-Token abzuleiten und eine voll signierte Assembly von einer verzögert signierten zu unterscheiden — und warum die Signatur im modernen .NET beim Laden nie geprüft wird.
Sie öffnen eine Assembly in Glass.NET, und die Identitätszeile lautet MyLib, Version=1.0.0.0, Culture=neutral, PublicKeyToken=a5b2c8d4e6f70819. Man liest dieses Token leicht als zwei Garantien auf einmal: dass die Bytes seit dem Build des Herausgebers unverändert sind und dass der Herausgeber der ist, der er zu sein behauptet. Ein Strong Name ist keines von beidem. Er ist ein Identitätsetikett mit kryptografischer Form, und zu verstehen, was er genau behauptet — und was nicht —, ist ein kurzer Rundgang durch die Assembly-Tabelle, den #Blob-Heap und einen einzigen SHA-1-Hash.
Die eigentliche Frage
Hinter diesem einen Token verbergen sich zwei verschiedene Tatsachen. Die erste ist die Herleitung: Woher stammen diese acht Byte, und wovon sind sie ein Fingerabdruck? Die zweite ist die Durchsetzung: Prüft beim Laden dieser Assembly tatsächlich etwas eine Signatur gegen diese Bytes? Die meiste Verwirrung um Strong Names entsteht aus der Annahme, die Antwort auf die zweite Frage laute „ja, immer“. Im modernen .NET lautet sie „nein, nie“. Glass beantwortet beide Fragen allein aus den Metadaten und achtet darauf, die zweite nicht zu überzeichnen.
Woher das Token kommt
Eine Strong-Name-Assembly speichert ihren vollständigen öffentlichen Schlüssel im Manifest. In ILDASM-artiger Syntax sieht die definierende Assembly so aus:
.assembly MyLib
{
.publickey = (00 24 00 00 04 80 00 00 94 00 00 00 06 02 00 00
00 24 00 00 52 53 41 31 00 04 00 00 01 00 01 00 ... )
.hash algorithm 0x00008004
.ver 1:0:0:0
}
Dieser .publickey-Blob ist der echte Schlüssel: eine SNK-Public-Key-Struktur, die mit einem Header und dem ASCII-Tag RSA1 beginnt. Er liegt im #Blob-Heap und wird von der PublicKey-Spalte der einzeiligen Assembly-Tabelle referenziert. Eine Assembly, die MyLib referenziert, wiederholt nicht den ganzen Schlüssel; sie speichert nur das 8-Byte-Token:
.assembly extern MyLib
{
.publickeytoken = (A5 B2 C8 D4 E6 F7 08 19)
.ver 1:0:0:0
}
Das Token ist ein Hash des Schlüssels, überall gleich berechnet:
using System.Security.Cryptography;
static string PublicKeyToken(byte[] fullPublicKey)
{
byte[] hash = SHA1.HashData(fullPublicKey); // 20 bytes
byte[] token = hash[^8..]; // last 8 bytes
Array.Reverse(token); // stored little-endian, shown reversed
return Convert.ToHexString(token).ToLowerInvariant();
}
Bilden Sie den SHA-1 über den gesamten Public-Key-Blob, behalten Sie die letzten acht Byte, kehren Sie sie um und geben Sie sie als Hex aus. Das ist der ganze Algorithmus. Das heißt, das Token ist ein gekürzter Fingerabdruck: Es heftet eine Assembly kompakt an einen öffentlichen Schlüssel, sodass eine Referenz den genauen Schlüssel benennen kann, mit dem eine Abhängigkeit gebaut worden sein muss, ohne 160 Byte RSA-Modulus mitzuschleppen. Wenn die Runtime MyLib bindet, berechnet sie das Token des öffentlichen Schlüssels des Kandidaten neu und vergleicht es mit dem in der Referenz. Dieser Vergleich ist Identitätsabgleich, nicht mehr.
Was Glass liest und was es nicht zu behaupten wagt
Wenn Sie eine Assembly laden, liest Glass die Zeile der Assembly-Tabelle, zieht den PublicKey-Blob aus #Blob und führt genau den obigen Hash aus, um Ihnen das Token in der Identitätszeile anzuzeigen — es vertraut nicht dem Token, das eine Referenz behauptet, sondern leitet es aus dem tatsächlich vorhandenen Schlüssel ab. Klappen Sie den Assembly-Knoten auf, und der vollständige öffentliche Schlüssel steht dort in der Metadatenansicht, mit RSA1 gekennzeichnet, daneben der AssemblyFlags-Wert, damit Sie das PublicKey-Bit (0x0001) sehen, das den Blob als echten Schlüssel und nicht als Token markiert.
Der Teil, über den Glass bewusst schweigt, ist die Verifikation. Es gibt ein zweites Artefakt im PE, das man mit dem Schlüssel verwechselt: die Strong-Name-Signatur, eine RSA-Signatur über einen Hash des Images, gespeichert in einem reservierten Bereich, auf den das StrongNameSignature-Datenverzeichnis des CLI-Headers zeigt. Glass zeigt Ihnen, dass der Bereich existiert und wie groß er ist. Es wird Ihnen nicht sagen, die Signatur sei „gültig“, als wäre das ein Vertrauensurteil, denn auf der Runtime, die den meisten Lesern wichtig ist, wird diese Frage nie gestellt.
Was ein Strong Name nicht beweist
Zwei unabhängige Lücken, und Glass legt die Belege für beide offen.
Er beweist nicht, wer der Herausgeber ist. Ein Strong-Name-Schlüssel ist selbst erzeugt — sn -k liefert einen in einer Sekunde —, ohne Zertifizierungsstelle, ohne Identität und ohne Widerruf. Jeder kann einen Schlüssel erzeugen und damit eine Assembly mit einem Strong Name versehen. Das Token sagt Ihnen, dass zwei Assemblys mit demselben Schlüssel signiert wurden; es sagt Ihnen nichts darüber, wem dieser Schlüssel gehört. (Authenticode, das eine Signatur an ein auf eine benannte Organisation ausgestelltes X.509-Zertifikat bindet, ist das Artefakt, das die Herausgeberidentität trägt: eine eigene Signatur, die Glass gesondert meldet.)
Im modernen .NET beweist er keine Integrität. .NET Framework prüfte die Strong-Name-Signatur beim Laden einer Assembly außerhalb des GAC, auch wenn ein Host mit voller Vertrauensstellung selbst das per Strong-Name-Bypass abschalten konnte. .NET Core und .NET 5+ entfernten die Prüfung beim Laden vollständig: Der Strong Name dient nur zur Berechnung der Identität und zum Binden von Referenzen. Ein Angreifer, der die Signatur entfernt, die IL bearbeitet und den öffentlichen Schlüssel an seiner Stelle lässt, erzeugt eine Assembly, die trotzdem lädt und weiterhin das ursprüngliche Token meldet — denn nichts berechnet die Signatur neu. Deshalb kennzeichnet Glass das Token als Identität und überlässt die Integrität Authenticode und Ihrem eigenen Datei-Hashing.
Verzögert signierte Assemblys sehen signiert aus, sind es aber nicht
Es gibt einen dritten Zustand, den man kennen sollte, und dort beginnt die meiste „Ist das signiert?“-Verwirrung. Eine verzögert signierte Assembly trägt den echten öffentlichen Schlüssel — hat also ein Token und meldet eine vollständige Identität —, aber ihr Signaturbereich ist reserviert und mit Nullen gefüllt, damit ihn später jemand mit dem privaten Schlüssel einträgt:
# Developer builds with the public key only; signature space is reserved
csc /delaysign+ /keyfile:public-only.snk MyLib.cs
# Later, the release gatekeeper completes it with the private key
sn -R MyLib.dll full-keypair.snk
Glass liest das StrongNameSignature-Verzeichnis, sieht einen nicht leeren öffentlichen Schlüssel neben einem reinen Null-Signatur-Blob und meldet die Assembly als verzögert signiert statt als signiert. Diese Unterscheidung zählt: Eine verzögert signierte Assembly würde unter .NET Framework die Prüfung nicht bestehen (oder bräuchte eine Verify-Skip-Registrierung), während sie im modernen .NET problemlos lädt — gerade weil nichts prüft. Eine eindrückliche Demonstration, dass „hat ein Token“ und „hat eine geprüfte Signatur“ nichts miteinander zu tun haben.
Vorbehalte
Die Token-Herleitung ist unabhängig von Ihrem Signaturschlüssel auf SHA-1 festgelegt; ein 2048-Bit-RSA-Schlüssel und die neueren Schlüssel im ECMA-Stil reduzieren sich beide auf ein 8-Byte-SHA-1-Token, sodass die Kollisionsresistenz des Tokens nicht die des Schlüssels ist. Glass berechnet und vergleicht Tokens, es versucht nicht, den Signatur-Blob kryptografisch zu verifizieren, denn ein Ergebnis „gültige Signatur“ würde eine Garantie beim Laden implizieren, die moderne Runtimes nicht bieten, und wäre irreführend auszugeben. Und eine Token-Übereinstimmung beim Binden wird nur erzwungen, wenn die referenzierende Assembly tatsächlich ein Token aufgezeichnet hat: Eine gegen ein unsigniertes MyLib gebaute Referenz zeichnet ein leeres PublicKeyToken auf, und Glass zeigt diese leere Identität an, statt eine zu erfinden.
Fazit
Ein Strong-Name-Public-Key-Token ist ein SHA-1-Fingerabdruck eines selbst erzeugten öffentlichen Schlüssels, vollständig in der besitzenden Assembly gespeichert und als acht Byte in allem, was sie referenziert. Es bindet Referenzen an einen Schlüssel, was eine echte und nützliche Identitätsgarantie ist. Es ist kein Herausgeberzertifikat und, unter .NET Core und .NET 5+, kein Manipulationssiegel: Die implizierte Signatur wird beim Laden nie geprüft. Glass.NET liest den Schlüssel, leitet das Token ehrlich ab, unterscheidet signiert von verzögert signiert und hört genau dort auf, wo die Garantien der Metadaten enden — damit Sie die Identität als das lesen, was sie ist, und sich für die Integrität, die sie nie tragen sollte, an Authenticode und Ihr eigenes Hashing halten.
Nebula.NET testen
Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.