Vermittlung grundlegender Sicherheitskenntnisse im Nodejs-Kryptomodul

Dieser Artikel vermittelt Ihnen hauptsächlich Nodejs für Fortgeschrittene: die grundlegenden Sicherheitskenntnisse, die Sie zum Beherrschen des Kryptomoduls benötigen. Ich hoffe, dass es jedem helfen kann. Im Zeitalter des Internets wächst die Datenmenge im Netzwerk täglich alarmierend. Gleichzeitig treten nacheinander verschiedene Netzwerksicherheitsprobleme auf. Da die Bedeutung der Informationssicherheit heute immer wichtiger wird, müssen Sie als Entwickler Ihr Sicherheitsverständnis vertiefen und die Sicherheit von Diensten durch technische Mittel verbessern. Das Modul

crypto ist eines der Kernmodule von nodejs. Es bietet sicherheitsrelevante Funktionen wie Digest-Operationen, Verschlüsselung, elektronische Signaturen usw. Viele Anfänger wissen nicht, wie sie mit der langen API-Liste beginnen sollen, daher sind umfangreiche Kenntnisse im Sicherheitsbereich erforderlich.

Dieser Artikel konzentriert sich auf das theoretische Wissen hinter der API und umfasst hauptsächlich den folgenden Inhalt:

1. Zusammenfassung (Hash), Digest-based Message Verification Code (HMAC)

2. Symmetrische Verschlüsselung, asymmetrische Verschlüsselung, elektronische Signatur

3. Blockverschlüsselungsmodus

Dieser Artikel ist ein Auszug Weitere Kapitel und Aktualisierungen finden Sie unter „Nodejs Learning Notes“. Besuchen Sie bitte die Adresse der Github-Homepage.

2. Digest (Hash)

Digest (Digest): Nehmen Sie eine Nachricht mit variabler Länge als Eingabe und generieren Sie eine Ausgabe mit fester Länge, indem Sie die Hash-Funktion ausführen verdauen. Wird normalerweise verwendet, um zu überprüfen, ob die Nachricht vollständig ist und nicht manipuliert wurde.

Digest-Vorgänge sind irreversibel. Mit anderen Worten: Wenn der Input fest ist, wird ein fester Output erzeugt. Wenn der Output jedoch bekannt ist, kann der Input nicht abgeleitet werden.

Der Pseudocode lautet wie folgt.

digest = Hash(message)

Übliche Digest-Algorithmen und entsprechende Ausgabeziffern sind wie folgt:

• MD5: 128 Bits

• SHA-1: 160 Bit

• SHA256: 256 Bit

• SHA512: 512 Bit

Beispiel in NodeJS:

var crypto = require('crypto');
var md5 = crypto.createHash('md5');

var message = 'hello';
var digest = md5.update(message, 'utf8').digest('hex');    

console.log(digest);
// 输出如下：注意这里是16进制
// 5d41402abc4b2a76b9719d911017c592

Hinweis: In verschiedenen Artikeln oder Dokumenten werden die Wörter „Abstract“, „Hash“ und „Hash“ häufig synonym verwendet, was zu vielen anfänglichen Problemen führt. Der Gelehrte sah verwirrt aus. Tatsächlich bezieht es sich meistens auf dasselbe. Denken Sie nur an die obige Definition von „abstrakt“.

3. MAC, HMAC

MAC (Message Authentication Code): Nachrichtenauthentifizierungscode, der zur Gewährleistung der Datenintegrität verwendet wird. Das Ergebnis der Operation hängt von der Nachricht selbst und dem geheimen Schlüssel ab.

MAC kann auf viele verschiedene Arten implementiert werden, beispielsweise als HMAC.

HMAC (Hash-based Message Authentication Code): Es kann grob als Hash-Funktion mit einem geheimen Schlüssel verstanden werden.

nodejs-Beispiele sind wie folgt:

const crypto = require('crypto');

// 参数一：摘要函数
// 参数二：秘钥
let hmac = crypto.createHmac('md5', '123456');
let ret = hmac.update('hello').digest('hex');

console.log(ret);
// 9c699d7af73a49247a239cb0dd2f8139

4. Symmetrische Verschlüsselung, asymmetrische Verschlüsselung

Verschlüsselung/Entschlüsselung: Gegebener Klartext, durch einen bestimmten Der Algorithmus generiert verschlüsselten Chiffretext. Dieser Vorgang wird als Verschlüsselung bezeichnet. Das Gegenteil ist die Entschlüsselung.

encryptedText = encrypt( plainText )
plainText = decrypt( EncryptedText )

Geheimer Schlüssel: Um die Sicherheit des Verschlüsselungs-/Entschlüsselungsalgorithmus weiter zu verbessern, add/ Der geheime Schlüssel wird während des Entschlüsselungsvorgangs eingeführt. Der Geheimschlüssel kann als Parameter des Verschlüsselungs-/Entschlüsselungsalgorithmus betrachtet werden. Wenn der Geheimtext bekannt ist und der zur Entschlüsselung verwendete Geheimschlüssel nicht bekannt ist, kann der Geheimtext nicht entschlüsselt werden.

encryptedText = encrypt(plainText, encryptKey)
plainText = decrypt(encryptedText, decryptKey)

Je nachdem, ob die für die Verschlüsselung und Entschlüsselung verwendeten geheimen Schlüssel gleich sind, können Verschlüsselungsalgorithmen unterschiedlich sein unterteilt in Symmetrische Verschlüsselung, Asymmetrische Verschlüsselung.

1. Symmetrische Verschlüsselung

Der für die Verschlüsselung und Entschlüsselung verwendete geheime Schlüssel ist derselbe, nämlich encryptKey === decryptKey.

Gemeinsame symmetrische Verschlüsselungsalgorithmen: DES, 3DES, AES, Blowfish, RC5, IDEA.

Pseudocode für die Verschlüsselung und Entschlüsselung:

encryptedText = encrypt(plainText, key); // Encryption
plainText = decrypt(encryptedText, key); // Decryption

2. Asymmetrische Verschlüsselung

Auch als Public-Key-Verschlüsselung bekannt. Die zur Verschlüsselung und Entschlüsselung verwendeten geheimen Schlüssel sind unterschiedlich, nämlich encryptKey !== decryptKey.

Der Verschlüsselungsschlüssel ist öffentlich und wird als öffentlicher Schlüssel bezeichnet. Der Entschlüsselungsschlüssel wird geheim gehalten und wird als geheimer Schlüssel bezeichnet.

Übliche asymmetrische Verschlüsselungsalgorithmen: RSA, DSA, ElGamal.

Pseudocode für die Verschlüsselung und Entschlüsselung:

encryptedText = encrypt(plainText, publicKey); // Encryption
plainText = decrypt(encryptedText, privateKey); // Decryption

3. Vergleich und Anwendung

Neben dem Unterschied bei den geheimen Schlüsseln gibt es auch einen Unterschied in der Rechengeschwindigkeit. Generell gilt:

1. Symmetrische Verschlüsselung ist schneller als asymmetrische Verschlüsselung.

2. Asymmetrische Verschlüsselung wird normalerweise zum Verschlüsseln von kurzen Texten verwendet, und symmetrische Verschlüsselung wird normalerweise zum Verschlüsseln von langen Texten verwendet.

Die beiden können in Kombination verwendet werden, beispielsweise das HTTPS-Protokoll, das über RSA ausgetauscht werden kann, um während der Handshake-Phase einen symmetrischen geheimen Schlüssel zu generieren. In der anschließenden Kommunikationsphase können die Daten mit einem symmetrischen Verschlüsselungsalgorithmus verschlüsselt werden und der geheime Schlüssel wird während der Handshake-Phase generiert.

Hinweis: Der symmetrische Schlüsselaustausch muss nicht unbedingt über RSA erfolgen, sondern kann auch über etwas wie DH erfolgen, was hier nicht näher erläutert wird.

5. Digitale Signatur

Anhand der Signatur können Sie den Zweck der digitalen Signatur grob erraten. Die Hauptfunktionen sind wie folgt:

1. Bestätigen Sie, dass die Informationen von einem bestimmten Thema stammen.

2. 确认信息完整、未被篡改。

为了达到上述目的，需要有两个过程：

1. 发送方：生成签名。

2. 接收方：验证签名。

1、发送方生成签名

1. 计算原始信息的摘要。

2. 通过私钥对摘要进行签名，得到电子签名。

3. 将原始信息、电子签名，发送给接收方。

附：签名伪代码

digest = hash(message); // 计算摘要
digitalSignature = sign(digest,  priviteKey); // 计算数字签名

2、接收方验证签名

1. 通过公钥解开电子签名，得到摘要D1。（如果解不开，信息来源主体校验失败）

2. 计算原始信息的摘要D2。

3. 对比D1、D2，如果D1等于D2，说明原始信息完整、未被篡改。

附：签名验证伪代码

digest1 = verify(digitalSignature, publicKey); // 获取摘要
digest2 = hash(message); // 计算原始信息的摘要
digest1 === digest2 // 验证是否相等

3、对比非对称加密

由于RSA算法的特殊性，加密/解密、签名/验证 看上去特别像，很多同学都很容易混淆。先记住下面结论，后面有时间再详细介绍。

1. 加密/解密：公钥加密，私钥解密。

2. 签名/验证：私钥签名，公钥验证。

六、分组加密模式、填充、初始化向量

常见的对称加密算法，如AES、DES都采用了分组加密模式。这其中，有三个关键的概念需要掌握：模式、填充、初始化向量。

搞清楚这三点，才会知道crypto模块对称加密API的参数代表什么含义，出了错知道如何去排查。

1、分组加密模式

所谓的分组加密，就是将（较长的）明文拆分成固定长度的块，然后对拆分的块按照特定的模式进行加密。

常见的分组加密模式有：ECB（不安全）、CBC（最常用）、CFB、OFB、CTR等。

以最简单的ECB为例，先将消息拆分成等分的模块，然后利用秘钥进行加密。

图片来源：这里，更多关于分组加密模式的介绍可以参考 wiki。

后面假设每个块的长度为128位

2、初始化向量：IV

为了增强算法的安全性，部分分组加密模式（CFB、OFB、CTR）中引入了初始化向量（IV），使得加密的结果随机化。也就是说，对于同一段明文，IV不同，加密的结果不同。

以CBC为例，每一个数据块，都与前一个加密块进行亦或运算后，再进行加密。对于第一个数据块，则是与IV进行亦或。

IV的大小跟数据块的大小有关（128位），跟秘钥的长度无关。

如图所示，图片来源 这里

3、填充：padding

分组加密模式需要对长度固定的块进行加密。分组拆分完后，最后一个数据块长度可能小于128位，此时需要进行填充以满足长度要求。

填充方式有多重。常见的填充方式有PKCS7。

假设分组长度为k字节，最后一个分组长度为k-last，可以看到：

1. 不管明文长度是多少，加密之前都会会对明文进行填充 （不然解密函数无法区分最后一个分组是否被填充了，因为存在最后一个分组长度刚好等于k的情况）

2. 如果最后一个分组长度等于k-last === k，那么填充内容为一个完整的分组 k k k ... k （k个字节）

3. 如果最后一个分组长度小于k-last < k，那么填充内容为 k-last mod k

                     01 -- if lth mod k = k-1
                  02 02 -- if lth mod k = k-2
                      .
                      .
                      .
            k k ... k k -- if lth mod k = 0

概括来说

1. 分组加密：先将明文切分成固定长度的块（128位），再进行加密。

2. 分组加密的几种模式：ECB（不安全）、CBC（最常用）、CFB、OFB、CTR。

3. 填充(padding)：部分加密模式，当最后一个块的长度小于128位时，需要通过特定的方式进行填充。（ECB、CBC需要填充，CFB、OFB、CTR不需要填充）

4. 初始化向量（IV）：部分加密模式（CFB、OFB、CTR）会将 明文块 与 前一个密文块进行亦或操作。对于第一个明文块，不存在前一个密文块，因此需要提供初始化向量IV（把IV当做第一个明文块 之前的 密文块）。此外，IV也可以让加密结果随机化。

Verwandte Empfehlungen:

Einfache Methode zur Verwendung von CryptoJS

Detaillierte Erläuterung der Krypto-Verschlüsselungsmethode von NodeJS

Detaillierte Einführung zu Crypto-JS

Das obige ist der detaillierte Inhalt vonVermittlung grundlegender Sicherheitskenntnisse im Nodejs-Kryptomodul. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!