Partage des connaissances de base en sécurité dans le module crypto Nodejs

Cet article partage principalement avec vous Nodejs avancé : les connaissances de base en sécurité que vous devez maîtriser dans le module crypto. J'espère que cela pourra aider tout le monde. À l’ère d’Internet, la quantité de données sur le réseau augmente chaque jour à un rythme alarmant. Dans le même temps, divers problèmes de sécurité des réseaux émergent les uns après les autres. Aujourd'hui, alors que l'importance de la sécurité des informations devient de plus en plus importante, en tant que développeur, vous devez renforcer votre compréhension de la sécurité et améliorer la sécurité des services par des moyens techniques. Le module

crypto est l'un des modules de base de nodejs. Il fournit des fonctions liées à la sécurité, telles que les opérations de résumé, le cryptage, les signatures électroniques, etc. De nombreux débutants ne savent pas par où commencer avec la longue liste d'API, cela implique donc beaucoup de connaissances dans le domaine de la sécurité.

Cet article se concentre sur les connaissances théoriques derrière l'API, comprenant principalement le contenu suivant :

1. Résumé (hash), code de vérification de message basé sur le résumé (HMAC)

2. Chiffrement symétrique, chiffrement asymétrique, signature électronique

3. Mode de chiffrement par bloc

Cet article est extrait à partir de "Nodejs Learning Notes", pour plus de chapitres et de mises à jour, veuillez visiter l'adresse de la page d'accueil de github.

2. Digest (hash)

Digest (digest) : prenez un message de longueur variable en entrée et exécutez la fonction de hachage pour générer une sortie de longueur fixe. digérer. Généralement utilisé pour vérifier que le message est complet et n'a pas été falsifié.

Les opérations Digest sont irréversibles. En d’autres termes, lorsque l’entrée est fixe, une sortie fixe est produite. Mais si le résultat est connu, l’entrée ne peut pas être déduite.

Le pseudo code est le suivant.

digest = Hash(message)

Les algorithmes de résumé courants et les chiffres de sortie correspondants sont les suivants :

• MD5 : 128 bits

• SHA-1 : 160 bits

• SHA256 : 256 bits

• SHA512 : 512 bits

Exemple dans 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

Remarque : dans divers articles ou documents, les mots résumé, hachage et hachage sont souvent utilisés de manière interchangeable, ce qui donne lieu à de nombreuses initiales. L'érudit avait l'air confus. En fait, la plupart du temps, cela fait référence à la même chose. Rappelez-vous simplement la définition du terme abstrait ci-dessus.

3. MAC, HMAC

MAC (Message Authentication Code) : Code d'authentification du message, utilisé pour garantir l'intégrité des données. Le résultat de l'opération dépend du message lui-même et de la clé secrète.

MAC peut être implémenté de différentes manières, comme HMAC.

HMAC (Hash-based Message Authentication Code) : il peut être grossièrement compris comme une fonction de hachage avec une clé secrète.

Les exemples de nodejs sont les suivants :

const crypto = require('crypto');

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

console.log(ret);
// 9c699d7af73a49247a239cb0dd2f8139

4. Chiffrement symétrique, chiffrement asymétrique

Cryptage/déchiffrement : Étant donné le texte en clair, via un certain L'algorithme génère un texte chiffré. Ce processus est appelé cryptage. L’inverse est le décryptage.

encryptedText = encrypt( plainText )
plainText = decrypt( approvedText )

Clé secrète : Afin d'améliorer encore la sécurité de l'algorithme de cryptage/déchiffrement, add/ La clé secrète est introduite lors du processus de décryptage. La clé secrète peut être considérée comme un paramètre de l'algorithme de chiffrement/déchiffrement. Lorsque le texte chiffré est connu, si la clé secrète utilisée pour le déchiffrement n'est pas connue, le texte chiffré ne peut pas être déchiffré.

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

Selon que les clés secrètes utilisées pour le chiffrement et le déchiffrement sont les mêmes, les algorithmes de chiffrement peuvent être divisé en Cryptage symétrique, Cryptage asymétrique.

1. Cryptage symétrique

La clé secrète utilisée pour le cryptage et le déchiffrement est la même, c'est-à-dire encryptKey === decryptKey.

Algorithmes de chiffrement symétriques courants : DES, 3DES, AES, Blowfish, RC5, IDEA.

Pseudo code pour le cryptage et le décryptage :

encryptedText = encrypt(plainText, key); // Encryption
plainText = decrypt(encryptedText, key); 🎜 >2. Le chiffrement asymétrique

est également appelé chiffrement à clé publique. Les clés secrètes utilisées pour le cryptage et le déchiffrement sont différentes, à savoir

.

encryptKey !== decryptKeyLa clé de chiffrement est publique et est appelée clé publique. La clé de déchiffrement est gardée secrète et est appelée clé secrète.

Algorithmes de chiffrement asymétriques courants : RSA, DSA, ElGamal.

Pseudo code pour le cryptage et le décryptage :

encryptedText = encrypt(plainText, publicKey); // Encryption

plainText = decrypt(encryptedText, privateKey); 🎜 >3. Comparaison et application

En plus de la différence de clés secrètes, il existe également une différence de vitesse de calcul. De manière générale :

Le chiffrement symétrique est plus rapide que le chiffrement asymétrique.

1. Le cryptage asymétrique est généralement utilisé pour crypter du texte court, et le cryptage symétrique est généralement utilisé pour crypter du texte long.

2. Les deux peuvent être utilisés en combinaison, comme le protocole HTTPS, qui peut générer des clés symétriques via l'échange RSA pendant la phase de prise de contact. Dans la phase de communication suivante, les données peuvent être cryptées à l'aide d'un algorithme de cryptage symétrique et la clé secrète est générée lors de la phase de prise de contact.

Remarque : l'échange de clés symétriques ne doit pas nécessairement être effectué via RSA, mais peut également être effectué via quelque chose comme DH, qui ne sera pas développé ici.

5. Signature numérique

À partir de la

signature

, vous pouvez deviner approximativement le but de la

signature numérique

. Les principales fonctions sont les suivantes : Confirmer que l'information provient d'un sujet précis.

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

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

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也可以让加密结果随机化。

Recommandations associées :

Méthode simple d'utilisation de CryptoJS

Explication détaillée de la méthode de cryptage crypto de nodeJS

Introduction détaillée sur crypto-js

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!