Vollständiger SM2-Verschlüsselungsleitfaden: Schlüsselerzeugung, Ver- und Entschlüsselung sowie digitale Signaturen in der Praxis

Was ist SM2?

SM2 ist ein asymmetrischer Verschlüsselungsalgorithmus, der von der Nationalen Kryptographie-Verwaltung Chinas veröffentlicht wurde, basierend auf Elliptic Curve Cryptography (ECC), der RSA als nationalen Standard ersetzt.

Vergleich	SM2	RSA 2048
Schlüssellänge	256 Bit	2048 Bit
Sicherheitsstärke	128 Bit	112 Bit
Signaturgeschwindigkeit	~0,5ms	~3ms
Verifikationsgeschwindigkeit	~1ms	~0,1ms
Schlüssellängenverhältnis	1	8
Nationaler Standard	GM/T 0003	PKCS#1

SM2 erreicht die Sicherheitsstärke von RSA 2048 Bit mit einem 256-Bit-Schlüssel, kürzerer Schlüssel, höhere Geschwindigkeit.

Drei Verwendungszwecke von SM2

Verwendung	Beschreibung	Entsprechendes Tool
Ver-/Entschlüsselung	Mit öffentlichem Schlüssel verschlüsseln, mit privatem Schlüssel entschlüsseln	SM2-Verschlüsselung
Digitale Signatur	Mit privatem Schlüssel signieren, mit öffentlichem Schlüssel verifizieren	SM2-Signatur
Schlüsselaustausch	Beide Parteien verhandeln einen gemeinsamen Schlüssel	ECDH-Protokoll

Schritt 1: SM2-Schlüsselpaar generieren

ToolsKu-Tool verwenden

SM2-Verschlüsselungstool öffnen
Auf „Schlüsselpaar generieren" klicken
Öffentlichen und privaten Schlüssel erhalten

Kommandozeile verwenden

# gmssl installieren
brew install gmssl  # macOS
# Oder von https://github.com/guanzhi/GmSSL/releases herunterladen

# SM2-Schlüsselpaar generieren
gmssl sm2 -genkey -out sm2.key

# Schlüssel anzeigen
gmssl sm2 -in sm2.key -text

JavaScript verwenden

import { sm2 } from 'sm-crypto';

// Schlüsselpaar generieren
const keyPair = sm2.generateKeyPairHex();
// keyPair.privateKey → Privater Schlüssel (64 Hexadezimalzeichen)
// keyPair.publicKey  → Öffentlicher Schlüssel (128 Hexadezimalzeichen, 04 + X + Y)

console.log('Privater Schlüssel:', keyPair.privateKey);
console.log('Öffentlicher Schlüssel:', keyPair.publicKey);

Schlüsselformat

SM2-Öffentlicher-Schlüssel-Format:
04 || X (32 Bytes) || Y (32 Bytes)
↓
04 + 64 Hexadezimalzeichen X + 64 Hexadezimalzeichen Y
Gesamtlänge: 130 Hexadezimalzeichen (65 Bytes)

SM2-Privater-Schlüssel-Format:
32-Byte-Zufallszahl
Gesamtlänge: 64 Hexadezimalzeichen (32 Bytes)

Schritt 2: SM2-Ver- und Entschlüsselung

Verschlüsselungsablauf

Klartext → SM2-Verschlüsselung (öffentlicher Schlüssel) → Chiffretext (C1 || C3 || C2)

C1: Elliptic-Curve-Punkt (65 Bytes)
C3: SM3-Hashwert (32 Bytes)
C2: Verschlüsselte Daten

ToolsKu-Tool verwenden

SM2-Verschlüsselungstool öffnen
Öffentlichen Schlüssel einfügen
Zu verschlüsselnden Klartext eingeben
Chiffretext-Format wählen (C1C3C2 oder C1C2C3)
Auf „Verschlüsseln" klicken, um den Chiffretext zu erhalten

JavaScript verwenden

import { sm2 } from 'sm-crypto';

const publicKey = '04...'; // 128 Hexadezimalzeichen
const privateKey = '...';  // 64 Hexadezimalzeichen

// Verschlüsseln (Standard: C1C3C2-Format)
const cipherText = sm2.doEncrypt('Hallo SM2', publicKey, 1);
// Parameter 1 = C1C3C2-Format (nationaler Standard empfohlen)
// Parameter 0 = C1C2C3-Format (Abwärtskompatibilität)

console.log('Chiffretext:', cipherText);

// Entschlüsseln
const plainText = sm2.doDecrypt(cipherText, privateKey, 1);
console.log('Klartext:', plainText); // "Hallo SM2"

Chiffretext-Kodierungsformate

Format	Beschreibung	Verwendungszweck
C1C3C2	Vom nationalen Standard empfohlenes Format	Neue Projekte (Standard)
C1C2C3	Altes Format	Kompatibilität mit alten Systemen
ASN.1	DER-Kodierung	Java/C#-Interoperabilität

Schritt 3: SM2-Digitale Signatur

Signaturablauf

Nachricht → SM3-Hash → SM2-Signatur (privater Schlüssel) → Signaturwert (r, s)

ToolsKu-Tool verwenden

SM2-Verschlüsselungstool öffnen
Zum Tab „Signatur" wechseln
Privaten Schlüssel und zu signierende Nachricht eingeben
Auf „Signieren" klicken, um den Signaturwert zu erhalten

JavaScript verwenden

import { sm2 } from 'sm-crypto';

const privateKey = '...';
const publicKey = '04...';

// Signieren (automatischer SM3-Hash der Nachricht)
const signature = sm2.doSignature('Zu signierende Nachricht', privateKey);
console.log('Signatur:', signature);

// Signatur verifizieren
const verified = sm2.doVerifySignature(
  'Zu signierende Nachricht',
  signature,
  publicKey
);
console.log('Verifikationsergebnis:', verified); // true

Signatur mit Benutzer-ID

Die SM2-Signatur verwendet standardmäßig die Benutzer-ID 1234567812345678 (Standardwert des nationalen Standards), die angepasst werden kann:

// Benutzer-ID beim Signieren angeben
const sig = sm2.doSignature('Nachricht', privateKey, {
  userId: 'customUserId'
});

// Gleiche Benutzer-ID bei der Verifikation verwenden
const valid = sm2.doVerifySignature('Nachricht', sig, publicKey, {
  userId: 'customUserId'
});

SM2 vs RSA: Wann was wählen?

Szenario	Empfehlung	Grund
Nationale Regierungssysteme	SM2	Kryptographie-Compliance-Anforderung
Nationale Finanzsysteme	SM2	UnionPay/PBoC-Anforderung
Internationale Standardsysteme	RSA	Internationale Kompatibilität
Mobile Verschlüsselung	SM2	Kurzer Schlüssel, schnelle Berechnung
Grenzüberschreitender Datenaustausch	RSA	Internationaler Standard

Nationale Kryptographie-Trio: SM2 + SM3 + SM4

Algorithmus	Typ	Verwendung	Tool
SM2	Asymmetrisch	Verschlüsselung/Signatur/Schlüsselaustausch	SM2-Tool
SM3	Hash	Nachrichtenübersicht (ähnlich SHA-256)	SM3-Tool
SM4	Symmetrisch	Datenverschlüsselung (ähnlich AES-128)	SM4-Tool

Typische Kombination: SM2 + SM4 Hybridverschlüsselung

1. Zufälligen SM4-Schlüssel generieren
2. Große Daten mit SM4 verschlüsseln (schnell)
3. SM4-Schlüssel mit SM2-öffentlichem Schlüssel verschlüsseln (sichere Übertragung)
4. Senden: SM2(SM4-Schlüssel) + SM4(Daten)

import { sm2, sm4 } from 'sm-crypto';

// 1. Zufälligen SM4-Schlüssel generieren
const sm4Key = crypto.getRandomValues(new Uint8Array(16));
const sm4KeyHex = Array.from(sm4Key).map(b => b.toString(16).padStart(2, '0')).join('');

// 2. Daten mit SM4 verschlüsseln
const encryptedData = sm4.encrypt(plainText, sm4KeyHex);

// 3. SM4-Schlüssel mit SM2 verschlüsseln
const encryptedKey = sm2.doEncrypt(sm4KeyHex, sm2PublicKey, 1);

// Senden: encryptedKey + encryptedData

Häufige Fragen

Warum ist der SM2-Chiffretext viel länger als der Klartext?

SM2-Chiffretext = C1 (65 Bytes) + C3 (32 Bytes) + C2 (Klartextlänge), also ist der Chiffretext 97 Bytes länger als der Klartext. Dies ist eine Eigenschaft der asymmetrischen Verschlüsselung. Für große Daten wird SM2+SM4-Hybridverschlüsselung empfohlen.

Was ist der Unterschied zwischen SM2 und ECDSA?

SM2 verwendet die vom nationalen Standard spezifizierte elliptische Kurve (sm2p256v1), ECDSA verwendet NIST-Kurven (P-256). Die Algorithmuslogik ist ähnlich, aber die Kurvenparameter sind unterschiedlich, nicht kompatibel.

Wie verwendet man SM2 in Java?

// Bouncy Castle + nationale Kryptographie-Erweiterung verwenden
Security.addProvider(new BouncyCastleProvider());

// Schlüsselpaar generieren
KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC", "BC");
kpg.initialize(new ECParameterSpec(...)); // SM2-Kurvenparameter
KeyPair kp = kpg.generateKeyPair();

Zusammenfassung

SM2 ist der zentrale asymmetrische Verschlüsselungsalgorithmus des nationalen Kryptographie-Systems, der mit einem 256-Bit-Schlüssel die Sicherheitsstärke von RSA 2048 Bit erreicht. Beherrschen Sie die drei Hauptoperationen: Schlüsselerzeugung, Ver-/Entschlüsselung und digitale Signatur, kombiniert mit SM3-Hash und SM4-symmetrischer Verschlüsselung, um die nationalen Compliance-Anforderungen zu erfüllen. ToolsKu bietet drei Online-Tools: SM2, SM3, SM4, lokale Verarbeitung im Browser, keine Daten-Uploads.