Node.js v16.16.0 文档


目录

crypto 加密#

中英对照

crypto 模块提供了加密功能,其中包括了用于 OpenSSL 散列、HMAC、加密、解密、签名、以及验证的函数的一整套封装。


确定加密支持是否不可用#

中英对照

可以在不支持 crypto 模块的情况下构建 Node.js。 在这种情况下,尝试 import crypto 或调用 require('crypto') 将导致抛出错误。



Certificate#

中英对照

SPKAC 是最初由 Netscape 实现的证书签名请求机制,并被正式指定为 HTML5 的 keygen 元素的一部分。

Certificate.exportChallenge(spkac[, encoding])#

中英对照

    
    

    Certificate.exportPublicKey(spkac[, encoding])#

    中英对照

      
      

      Certificate.verifySpkac(spkac[, encoding])#

      中英对照

        
        

        旧版的 API#

        中英对照

        作为旧版接口,可以创建 crypto.Certificate 类的新实例,如下面的示例所示。

        new crypto.Certificate()#

        中英对照

        可以使用 new 关键字或通过调用 crypto.Certificate() 作为函数来创建 Certificate 类的实例:

        
        
        certificate.exportChallenge(spkac[, encoding])#

        中英对照

          
          
          certificate.exportPublicKey(spkac[, encoding])#

          中英对照

            
            
            certificate.verifySpkac(spkac[, encoding])#

            中英对照

              
              

              Cipher#

              中英对照

                Cipher 类的实例用于加密数据。 可以通过以下两种方式之一使用该类:

                  
                  

                  
                  

                  
                  

                  cipher.final([outputEncoding])#

                  中英对照

                    一旦调用了 cipher.final() 方法,则 Cipher 对象就不能再用于加密数据。 多次尝试调用 cipher.final() 将导致抛出错误。

                    cipher.getAuthTag()#

                    中英对照

                      只有在使用 cipher.final() 方法完成加密后才应调用 cipher.getAuthTag() 方法。

                      cipher.setAAD(buffer[, options])#

                      中英对照

                        当使用认证的加密模式时(目前支持 GCMCCMOCB),则 cipher.setAAD() 方法设置用于额外的认证数据 (AAD) 输入参数的值。

                        cipher.setAutoPadding([autoPadding])#

                        中英对照

                          当使用块加密算法时,Cipher 类会自动向输入数据添加填充到适当的块大小。 要禁用默认填充调用 cipher.setAutoPadding(false)

                          cipher.update(data[, inputEncoding][, outputEncoding])#

                          中英对照

                            使用 data 更新密码。 如果给定了 inputEncoding 参数,则 data 参数是使用指定编码的字符串。 如果未给定 inputEncoding 参数,则 data 必须是 BufferTypedArrayDataView。 如果 dataBufferTypedArrayDataView,则忽略 inputEncoding

                            Decipher#

                            中英对照

                              Decipher 类的实例用于解密数据。 可以通过以下两种方式之一使用该类:

                                
                                

                                
                                

                                
                                

                                decipher.final([outputEncoding])#

                                中英对照

                                  一旦调用了 decipher.final() 方法,就不能再使用 Decipher 对象来解密数据。 多次尝试调用 decipher.final() 将导致抛出错误。

                                  decipher.setAAD(buffer[, options])#

                                  中英对照

                                    当使用认证的加密模式时(目前支持 GCMCCMOCB),则 decipher.setAAD() 方法设置用于额外的认证数据 (AAD) 输入参数的值。

                                    decipher.setAuthTag(buffer[, encoding])#

                                    中英对照

                                      当使用认证的加密模式时(目前支持 GCMCCMOCB),则使用 decipher.setAuthTag() 方法传入接收到的认证标签。 如果没有提供标签,或者密文被篡改,则抛出 decipher.final(),表示由于认证失败,密文应该被丢弃。 如果标签长度根据 NIST SP 800-38D 无效或与 authTagLength 选项的值不匹配,则 decipher.setAuthTag() 将抛出错误。

                                      decipher.setAutoPadding([autoPadding])#

                                      中英对照

                                        当数据在没有标准块填充的情况下加密时,调用 decipher.setAutoPadding(false) 将禁用自动填充以防止 decipher.final() 检查和删除填充。

                                        decipher.update(data[, inputEncoding][, outputEncoding])#

                                        中英对照

                                          data 更新解密。 如果给定了 inputEncoding 参数,则 data 参数是使用指定编码的字符串。 如果未给定 inputEncoding 参数,则 data 必须是 Buffer。 如果 dataBuffer,则忽略 inputEncoding

                                          DiffieHellman#

                                          中英对照

                                          DiffieHellman 类是用于创建 Diffie-Hellman 密钥交换的实用工具。

                                          
                                          

                                          diffieHellman.computeSecret(otherPublicKey[, inputEncoding][, outputEncoding])#

                                          中英对照

                                            使用 otherPublicKey 作为对方的公钥计算共享密钥,并返回计算出的共享密钥。 使用指定的 inputEncoding 解释提供的密钥,使用指定的 outputEncoding 对密钥进行编码。 如果未提供 inputEncoding,则 otherPublicKey 应为 BufferTypedArrayDataView

                                            diffieHellman.generateKeys([encoding])#

                                            中英对照

                                              生成私钥和公钥 Diffie-Hellman 密钥值,并返回指定 encoding 中的公钥。 此密钥应转让给另一方。 如果提供了 encoding,则返回字符串;否则返回 Buffer

                                              diffieHellman.getGenerator([encoding])#

                                              中英对照

                                                返回指定 encoding 中的 Diffie-Hellman 生成器。 如果提供了 encoding,则返回字符串;否则返回 Buffer

                                                diffieHellman.getPrime([encoding])#

                                                中英对照

                                                  返回指定 encoding 中的 Diffie-Hellman 素数。 如果提供了 encoding,则返回字符串;否则返回 Buffer

                                                  diffieHellman.getPrivateKey([encoding])#

                                                  中英对照

                                                    返回指定 encoding 中的 Diffie-Hellman 私钥。 如果提供了 encoding,则返回字符串;否则返回 Buffer

                                                    diffieHellman.getPublicKey([encoding])#

                                                    中英对照

                                                      返回指定 encoding 中的 Diffie-Hellman 公钥。 如果提供了 encoding,则返回字符串;否则返回 Buffer

                                                      diffieHellman.setPrivateKey(privateKey[, encoding])#

                                                      中英对照

                                                        设置 Diffie-Hellman 私钥。 如果提供了 encoding 参数,则 privateKey 应该是字符串。 如果未提供 encoding,则 privateKey 应为 BufferTypedArrayDataView

                                                        diffieHellman.setPublicKey(publicKey[, encoding])#

                                                        中英对照

                                                          设置 Diffie-Hellman 公钥。 如果提供了 encoding 参数,则 publicKey 应该是字符串。 如果未提供 encoding,则 publicKey 应为 BufferTypedArrayDataView

                                                          diffieHellman.verifyError#

                                                          中英对照

                                                          包含在 DiffieHellman 对象初始化期间执行的检查所产生的任何警告和/或错误的位字段。

                                                            DiffieHellmanGroup#

                                                            中英对照

                                                            DiffieHellmanGroup 类以著名的 modp 组为参数。 它的工作原理与 DiffieHellman 相同,不同之处在于它不允许在创建后更改其密钥。 换句话说,它没有实现 setPublicKey()setPrivateKey() 方法。

                                                            
                                                            

                                                            
                                                            

                                                            ECDH#

                                                            中英对照

                                                            ECDH 类是用于创建椭圆曲线 Diffie-Hellman (ECDH) 密钥交换的实用工具。

                                                            
                                                            

                                                            ECDH.convertKey(key, curve[, inputEncoding[, outputEncoding[, format]]])#

                                                            中英对照

                                                              keycurve 指定的 EC Diffie-Hellman 公钥转换为 format 指定的格式。 format 参数指定点编码,可以是 'compressed''uncompressed''hybrid'。 提供的密钥使用指定的 inputEncoding 进行解释,返回的密钥使用指定的 outputEncoding 进行编码。

                                                              
                                                              

                                                              ecdh.computeSecret(otherPublicKey[, inputEncoding][, outputEncoding])#

                                                              中英对照

                                                                使用 otherPublicKey 作为对方的公钥计算共享密钥,并返回计算出的共享密钥。 提供的密钥使用指定的 inputEncoding 进行解释,返回的密钥使用指定的 outputEncoding 进行编码。 如果未提供 inputEncoding,则 otherPublicKey 应为 BufferTypedArrayDataView

                                                                ecdh.generateKeys([encoding[, format]])#

                                                                中英对照

                                                                  生成私有和公共 EC Diffie-Hellman 密钥值,并返回指定 formatencoding 中的公钥。 此密钥应转让给另一方。

                                                                  ecdh.getPrivateKey([encoding])#

                                                                  中英对照

                                                                    如果指定了 encoding,则返回字符串;否则返回 Buffer

                                                                    ecdh.getPublicKey([encoding][, format])#

                                                                    中英对照

                                                                      format 参数指定点编码,可以是 'compressed''uncompressed'。 如果未指定 format,该点将以 'uncompressed' 格式返回。

                                                                      ecdh.setPrivateKey(privateKey[, encoding])#

                                                                      中英对照

                                                                        设置 EC Diffie-Hellman 私钥。 如果提供了 encoding,则 privateKey 应该是字符串;否则 privateKey 应该是 BufferTypedArrayDataView

                                                                        ecdh.setPublicKey(publicKey[, encoding])#

                                                                        中英对照

                                                                          设置 EC Diffie-Hellman 公钥。 如果提供了 encoding,则 publicKey 应该是字符串;否则应为 BufferTypedArrayDataView

                                                                          
                                                                          

                                                                          Hash#

                                                                          中英对照

                                                                            Hash 类是用于创建数据的哈希摘要的实用工具。 它可以通过以下两种方式之一使用:

                                                                              
                                                                              

                                                                              
                                                                              

                                                                              
                                                                              

                                                                              hash.copy([options])#

                                                                              中英对照

                                                                                创建新的 Hash 对象,其中包含当前 Hash 对象的内部状态的深层副本。

                                                                                
                                                                                

                                                                                hash.digest([encoding])#

                                                                                中英对照

                                                                                  计算传给被哈希的所有数据的摘要(使用 hash.update() 方法)。 如果提供了 encoding,则将返回字符串;否则返回 Buffer

                                                                                  hash.update(data[, inputEncoding])#

                                                                                  中英对照

                                                                                    使用给定的 data 更新哈希内容,其编码在 inputEncoding 中给出。 如果未提供 encoding,且 data 是字符串,则强制为 'utf8' 编码。 如果 dataBufferTypedArrayDataView,则忽略 inputEncoding

                                                                                    Hmac#

                                                                                    中英对照

                                                                                      Hmac 类是用于创建加密 HMAC 摘要的实用工具。 它可以通过以下两种方式之一使用:

                                                                                        
                                                                                        

                                                                                        
                                                                                        

                                                                                        
                                                                                        

                                                                                        hmac.digest([encoding])#

                                                                                        中英对照

                                                                                          计算使用 hmac.update() 传入的所有数据的 HMAC 摘要。 如果提供了 encoding,则返回字符串;否则返回 Buffer

                                                                                          hmac.update(data[, inputEncoding])#

                                                                                          中英对照

                                                                                            使用给定的 data 更新 Hmac 内容,其编码在 inputEncoding 中给出。 如果未提供 encoding,且 data 是字符串,则强制为 'utf8' 编码。 如果 dataBufferTypedArrayDataView,则忽略 inputEncoding

                                                                                            KeyObject#

                                                                                            中英对照

                                                                                            Node.js 使用 KeyObject 类来表示对称或非对称密钥,每种密钥暴露不同的功能。 crypto.createSecretKey()crypto.createPublicKey()crypto.createPrivateKey() 方法用于创建 KeyObject 实例。 KeyObject 对象不能直接使用 new 关键字创建。

                                                                                            KeyObject.from(key)#

                                                                                            中英对照

                                                                                              示例:将 CryptoKey 实例转换为 KeyObject

                                                                                              
                                                                                              

                                                                                              keyObject.asymmetricKeyDetails#

                                                                                              中英对照

                                                                                                此属性仅存在于非对称密钥上。 根据密钥的类型,此对象包含有关密钥的信息。 通过此属性获得的任何信息都不能用于唯一标识密钥或危及密钥的安全性。

                                                                                                keyObject.asymmetricKeyType#

                                                                                                中英对照

                                                                                                  对于非对称密钥,此属性表示密钥的类型。 支持的密钥类型有:

                                                                                                    keyObject.export([options])#

                                                                                                    中英对照

                                                                                                      对于对称密钥,可以使用以下编码选项:

                                                                                                            keyObject.equals(otherKeyObject)#

                                                                                                            中英对照

                                                                                                              根据键的类型、值和参数是否完全相同,返回 truefalse。 此方法不是恒定时间

                                                                                                              keyObject.symmetricKeySize#

                                                                                                              中英对照

                                                                                                                对于秘密密钥,此属性表示密钥的大小(以字节为单位)。 对于非对称密钥,此属性为 undefined

                                                                                                                keyObject.type#

                                                                                                                中英对照

                                                                                                                  根据此 KeyObject 的类型,此属性是 'secret' 表示秘密(对称)密钥,'public' 表示公共(非对称)密钥或 'private' 表示私有(非对称)密钥。

                                                                                                                  Sign#

                                                                                                                  中英对照

                                                                                                                    Sign 类是用于生成签名的实用工具。 它可以通过以下两种方式之一使用:

                                                                                                                      
                                                                                                                      

                                                                                                                      
                                                                                                                      

                                                                                                                      sign.sign(privateKey[, outputEncoding])#

                                                                                                                      中英对照

                                                                                                                        使用 sign.update()sign.write() 计算通过的所有数据的签名。

                                                                                                                          sign.update(data[, inputEncoding])#

                                                                                                                          中英对照

                                                                                                                            使用给定的 data 更新 Sign 内容,其编码在 inputEncoding 中给出。 如果未提供 encoding,且 data 是字符串,则强制为 'utf8' 编码。 如果 dataBufferTypedArrayDataView,则忽略 inputEncoding

                                                                                                                            Verify#

                                                                                                                            中英对照

                                                                                                                              Verify 类是用于验证签名的实用工具。 它可以通过以下两种方式之一使用:

                                                                                                                                verify.update(data[, inputEncoding])#

                                                                                                                                中英对照

                                                                                                                                  使用给定的 data 更新 Verify 内容,其编码在 inputEncoding 中给出。 如果未提供 inputEncoding,且 data 是字符串,则强制为 'utf8' 编码。 如果 dataBufferTypedArrayDataView,则忽略 inputEncoding

                                                                                                                                  verify.verify(object, signature[, signatureEncoding])#

                                                                                                                                  中英对照

                                                                                                                                    使用给定的 objectsignature 验证提供的数据。

                                                                                                                                      X509Certificate#

                                                                                                                                      中英对照

                                                                                                                                      封装 X509 证书并提供对其信息的只读访问。

                                                                                                                                      
                                                                                                                                      

                                                                                                                                      new X509Certificate(buffer)#

                                                                                                                                      中英对照

                                                                                                                                        x509.ca#

                                                                                                                                        中英对照

                                                                                                                                          x509.checkEmail(email[, options])#

                                                                                                                                          中英对照

                                                                                                                                            检查证书是否与给定的电子邮件地址匹配。

                                                                                                                                            x509.checkHost(name[, options])#

                                                                                                                                            中英对照

                                                                                                                                              检查证书是否与给定的主机名匹配。

                                                                                                                                              x509.checkIP(ip)#

                                                                                                                                              中英对照

                                                                                                                                                检查证书是否与给定的 IP 地址(IPv4 或 IPv6)匹配。

                                                                                                                                                x509.checkIssued(otherCert)#

                                                                                                                                                中英对照

                                                                                                                                                  检查此证书是否由给定的 otherCert 颁发。

                                                                                                                                                  x509.checkPrivateKey(privateKey)#

                                                                                                                                                  中英对照

                                                                                                                                                    检查此证书的公钥是否与给定的私钥一致。

                                                                                                                                                    x509.fingerprint#

                                                                                                                                                    中英对照

                                                                                                                                                      此证书的 SHA-1 指纹。

                                                                                                                                                      x509.fingerprint256#

                                                                                                                                                      中英对照

                                                                                                                                                        此证书的 SHA-256 指纹。

                                                                                                                                                        x509.fingerprint512#

                                                                                                                                                        中英对照

                                                                                                                                                          此证书的 SHA-512 指纹。

                                                                                                                                                          x509.infoAccess#

                                                                                                                                                          中英对照

                                                                                                                                                            证书权限信息访问扩展的文本表示。

                                                                                                                                                            x509.issuer#

                                                                                                                                                            中英对照

                                                                                                                                                              此证书中包含的发行人标识。

                                                                                                                                                              x509.issuerCertificate#

                                                                                                                                                              中英对照

                                                                                                                                                                颁发者证书或 undefined(如果颁发者证书不可用)。

                                                                                                                                                                x509.keyUsage#

                                                                                                                                                                中英对照

                                                                                                                                                                  详细说明此证书的密钥用法的数组。

                                                                                                                                                                  x509.publicKey#

                                                                                                                                                                  中英对照

                                                                                                                                                                    此证书的公钥 <KeyObject>

                                                                                                                                                                    x509.raw#

                                                                                                                                                                    中英对照

                                                                                                                                                                      包含此证书的 DER 编码的 Buffer

                                                                                                                                                                      x509.serialNumber#

                                                                                                                                                                      中英对照

                                                                                                                                                                        此证书的序列号。

                                                                                                                                                                        x509.subject#

                                                                                                                                                                        中英对照

                                                                                                                                                                          本证书的完整主题。

                                                                                                                                                                          x509.subjectAltName#

                                                                                                                                                                          中英对照

                                                                                                                                                                            为此证书指定的使用者备用名称。

                                                                                                                                                                            x509.toJSON()#

                                                                                                                                                                            中英对照

                                                                                                                                                                              X509 证书没有标准的 JSON 编码。 toJSON() 方法返回包含 PEM 编码证书的字符串。

                                                                                                                                                                              x509.toLegacyObject()#

                                                                                                                                                                              中英对照

                                                                                                                                                                                使用旧版的证书对象编码返回有关此证书的信息。

                                                                                                                                                                                x509.toString()#

                                                                                                                                                                                中英对照

                                                                                                                                                                                  返回 PEM 编码的证书。

                                                                                                                                                                                  x509.validFrom#

                                                                                                                                                                                  中英对照

                                                                                                                                                                                    此证书被视为有效的起始日期/时间。

                                                                                                                                                                                    x509.validTo#

                                                                                                                                                                                    中英对照

                                                                                                                                                                                      此证书被视为有效的结束日期/时间。

                                                                                                                                                                                      x509.verify(publicKey)#

                                                                                                                                                                                      中英对照

                                                                                                                                                                                        验证此证书是否由给定的公钥签名。 不对证书执行任何其他验证检查。

                                                                                                                                                                                        加密模块的方法和属性#

                                                                                                                                                                                        crypto.constants#

                                                                                                                                                                                        中英对照

                                                                                                                                                                                          crypto.DEFAULT_ENCODING#

                                                                                                                                                                                          中英对照

                                                                                                                                                                                          用于可以采用字符串或缓冲区的函数的默认编码。 默认值为 'buffer',这使得方法默认为 Buffer 对象。

                                                                                                                                                                                          crypto.fips#

                                                                                                                                                                                          中英对照

                                                                                                                                                                                          用于检查和控制当前是否正在使用符合 FIPS 的加密提供程序的属性。 设置为 true 需要 Node.js 的 FIPS 构建。

                                                                                                                                                                                          crypto.checkPrime(candidate[, options, [callback]])#

                                                                                                                                                                                          中英对照

                                                                                                                                                                                            检查 candidate 的素性。

                                                                                                                                                                                            crypto.checkPrimeSync(candidate[, options])#

                                                                                                                                                                                            中英对照

                                                                                                                                                                                              检查 candidate 的素性。

                                                                                                                                                                                              crypto.createCipher(algorithm, password[, options])#

                                                                                                                                                                                              中英对照

                                                                                                                                                                                                创建并返回使用给定 algorithmpasswordCipher 对象。

                                                                                                                                                                                                crypto.createCipheriv(algorithm, key, iv[, options])#

                                                                                                                                                                                                中英对照

                                                                                                                                                                                                  使用给定的 algorithmkey 和初始化向量(iv)创建并返回 Cipher 对象。

                                                                                                                                                                                                  crypto.createDecipher(algorithm, password[, options])#

                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                    创建并返回使用给定的 algorithmpassword(键)的 Decipher 对象。

                                                                                                                                                                                                    crypto.createDecipheriv(algorithm, key, iv[, options])#

                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                      创建并返回使用给定的 algorithmkey 和初始化向量(iv)的 Decipher 对象。

                                                                                                                                                                                                      crypto.createDiffieHellman(prime[, primeEncoding][, generator][, generatorEncoding])#

                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                        使用提供的 prime 和可选的特定 generator 创建 DiffieHellman 密钥交换对象。

                                                                                                                                                                                                        crypto.createDiffieHellman(primeLength[, generator])#

                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                          创建 DiffieHellman 密钥交换对象并使用可选的特定数字 generator 生成 primeLength 位的质数。 如果未指定 generator,则使用值 2

                                                                                                                                                                                                          crypto.createDiffieHellmanGroup(name)#

                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                            crypto.getDiffieHellman() 的别名

                                                                                                                                                                                                            crypto.createECDH(curveName)#

                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                              使用 curveName 字符串指定的预定义曲线创建椭圆曲线 Diffie-Hellman (ECDH) 密钥交换对象。 使用 crypto.getCurves() 获取可用曲线名称的列表。 在最近的 OpenSSL 版本中,openssl ecparam -list_curves 还将显示每个可用椭圆曲线的名称和描述。

                                                                                                                                                                                                              crypto.createHash(algorithm[, options])#

                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                创建并返回 Hash 对象,该对象可用于使用给定的 algorithm 生成哈希摘要。 可选的 options 参数控制流的行为。 对于 XOF 哈希函数(例如 'shake256'),可以使用 outputLength 选项指定所需的输出长度(以字节为单位)。

                                                                                                                                                                                                                
                                                                                                                                                                                                                

                                                                                                                                                                                                                crypto.createHmac(algorithm, key[, options])#

                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                  创建并返回使用给定的 algorithmkeyHmac 对象。 可选的 options 参数控制流的行为。

                                                                                                                                                                                                                  
                                                                                                                                                                                                                  

                                                                                                                                                                                                                  crypto.createPrivateKey(key)#

                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                    创建并返回包含私钥的新密钥对象。 如果 key 是字符串或 Buffer,则假定 format'pem';否则,key 必须是具有上述属性的对象。

                                                                                                                                                                                                                    crypto.createPublicKey(key)#

                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                      创建并返回包含公钥的新密钥对象。 如果 key 是字符串或 Buffer,则假定 format'pem'; 如果 key 是类型为 'private'KeyObject,则公钥来自给定的私钥; 否则,key 必须是具有上述属性的对象。

                                                                                                                                                                                                                      crypto.createSecretKey(key[, encoding])#

                                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                                        创建并返回新的密钥对象,其中包含用于对称加密或 Hmac 的密钥。

                                                                                                                                                                                                                        crypto.createSign(algorithm[, options])#

                                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                                          创建并返回使用给定的 algorithmSign 对象。 使用 crypto.getHashes() 获取可用摘要算法的名称。 可选的 options 参数控制 stream.Writable 行为。

                                                                                                                                                                                                                          crypto.createVerify(algorithm[, options])#

                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                            创建并返回使用给定算法的 Verify 对象。 使用 crypto.getHashes() 获取可用签名算法的名称数组。 可选的 options 参数控制 stream.Writable 行为。

                                                                                                                                                                                                                            crypto.diffieHellman(options)#

                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                              基于 privateKeypublicKey 计算 Diffie-Hellman 秘密。 两个密钥必须具有相同的 asymmetricKeyType,它必须是 'dh'(对于 Diffie-Hellman)、'ec'(对于 ECDH)、'x448''x25519'(对于 ECDH-ES)之一。

                                                                                                                                                                                                                              crypto.generateKey(type, options, callback)#

                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                异步生成给定 length 的新随机密钥。 type 将确定将在 length 上执行哪些验证。

                                                                                                                                                                                                                                
                                                                                                                                                                                                                                

                                                                                                                                                                                                                                crypto.generateKeyPair(type, options, callback)#

                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                  生成给定 type 的新非对称密钥对。 目前支持 RSA、RSA-PSS、DSA、EC、Ed25519、Ed448、X25519、X448、以及 DH。

                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                  crypto.generateKeyPairSync(type, options)#

                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                    生成给定 type 的新非对称密钥对。 目前支持 RSA、RSA-PSS、DSA、EC、Ed25519、Ed448、X25519、X448、以及 DH。

                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                    crypto.generateKeySync(type, options)#

                                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                                      同步生成给定 length 的新随机密钥。 type 将确定将在 length 上执行哪些验证。

                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                      crypto.generatePrime(size[, options[, callback]])#

                                                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                                                        生成 size 位的伪随机素数。

                                                                                                                                                                                                                                          crypto.generatePrimeSync(size[, options])#

                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                            生成 size 位的伪随机素数。

                                                                                                                                                                                                                                              crypto.getCipherInfo(nameOrNid[, options])#

                                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                                返回有关给定密码的信息。

                                                                                                                                                                                                                                                crypto.getCiphers()#

                                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                  crypto.getCurves()#

                                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                    crypto.getDiffieHellman(groupName)#

                                                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                                                      创建预定义的 DiffieHellmanGroup 密钥交换对象。 支持的组是:'modp1''modp2''modp5'(在 RFC 2412 中定义,但请参阅注意事项)和 'modp14''modp15''modp16''modp17''modp18'(在 RFC 3526 中定义)。 返回的对象模仿 crypto.createDiffieHellman() 创建的对象的接口,但不允许更改键(例如,使用 diffieHellman.setPublicKey())。 使用这种方法的优点是双方不必事先生成或交换组模数,既节省了处理器时间又节省了通信时间。

                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                      crypto.getFips()#

                                                                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                                                                        crypto.getHashes()#

                                                                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                          crypto.hkdf(digest, ikm, salt, info, keylen, callback)#

                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                            HKDF 是 RFC 5869 中定义的简单密钥派生函数。 给定的 ikmsaltinfodigest 一起使用以导出 keylen 字节的密钥。

                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                            crypto.hkdfSync(digest, ikm, salt, info, keylen)#

                                                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                                                              提供 RFC 5869 中定义的同步 HKDF 密钥派生函数。 给定的 ikmsaltinfodigest 一起使用以导出 keylen 字节的密钥。

                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                              crypto.pbkdf2(password, salt, iterations, keylen, digest, callback)#

                                                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                                                提供异步基于密码的密钥派生函数 2 (PBKDF2) 实现。 应用由 digest 指定的选定 HMAC 摘要算法以从 passwordsaltiterations 导出请求字节长度 (keylen) 的密钥。

                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                crypto.pbkdf2Sync(password, salt, iterations, keylen, digest)#

                                                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                                                  提供同步的基于密码的密钥派生函数 2 (PBKDF2) 实现。 应用由 digest 指定的选定 HMAC 摘要算法以从 passwordsaltiterations 导出请求字节长度 (keylen) 的密钥。

                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                  crypto.privateDecrypt(privateKey, buffer)#

                                                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                                                    privateKey 解密 bufferbuffer 之前使用相应的公钥加密,例如使用 crypto.publicEncrypt()

                                                                                                                                                                                                                                                                    crypto.privateEncrypt(privateKey, buffer)#

                                                                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                                                                      privateKey 加密 buffer。 返回的数据可以使用相应的公钥解密,例如使用 crypto.publicDecrypt()

                                                                                                                                                                                                                                                                      crypto.publicDecrypt(key, buffer)#

                                                                                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                                                                                        使用 key.buffer 解密 buffer 之前使用相应的私钥加密,例如使用 crypto.privateEncrypt()

                                                                                                                                                                                                                                                                        crypto.publicEncrypt(key, buffer)#

                                                                                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                                                                                          key 加密 buffer 的内容,并返回带有加密内容的新 Buffer。 返回的数据可以使用相应的私钥解密,例如使用 crypto.privateDecrypt()

                                                                                                                                                                                                                                                                          crypto.randomBytes(size[, callback])#

                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                            生成加密强伪随机数据。 size 参数是数字,指示要生成的字节数。

                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                            crypto.randomFillSync(buffer[, offset][, size])#

                                                                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                                                                              crypto.randomFill() 的同步版本。

                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                                              crypto.randomFill(buffer[, offset][, size], callback)#

                                                                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                                                                此函数类似于 crypto.randomBytes(),但要求第一个参数是将被填充的 Buffer。 它还要求传入回调。

                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                crypto.randomInt([min, ]max[, callback])#

                                                                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                                                                  返回随机整数 n,使得 min <= n < max。 这种实现避免了模偏差

                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                  crypto.randomUUID([options])#

                                                                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                                                                    生成随机的 RFC 4122 版本 4 UUID。 UUID 是使用加密伪随机数生成器生成的。

                                                                                                                                                                                                                                                                                    crypto.scrypt(password, salt, keylen[, options], callback)#

                                                                                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                                                                                      提供异步 scrypt 实现。 Scrypt 是一个基于密码的密钥派生函数,其设计在计算和内存方面都非常昂贵,以使蛮力攻击毫无回报。

                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                      crypto.scryptSync(password, salt, keylen[, options])#

                                                                                                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                                                                                                        提供同步的 scrypt 实现。 Scrypt 是一个基于密码的密钥派生函数,其设计在计算和内存方面都非常昂贵,以使蛮力攻击毫无回报。

                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                        crypto.secureHeapUsed()#

                                                                                                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                                                                                                          crypto.setEngine(engine[, flags])#

                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                            为部分或所有 OpenSSL 功能(由标志选择)加载并设置 engine

                                                                                                                                                                                                                                                                                                crypto.setFips(bool)#

                                                                                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                                                                                  在启用 FIPS 的 Node.js 构建中启用符合 FIPS 的加密提供程序。 如果 FIPS 模式不可用,则会抛出错误。

                                                                                                                                                                                                                                                                                                  crypto.sign(algorithm, data, key[, callback])#

                                                                                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                                                                                    使用给定的私钥和算法计算并返回 data 的签名。 如果 algorithmnullundefined,则算法取决于密钥类型(尤其是 Ed25519 和 Ed448)。

                                                                                                                                                                                                                                                                                                      crypto.timingSafeEqual(a, b)#

                                                                                                                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                                                                                                                        该函数基于恒定时间算法。 如果 a 等于 b,则返回 true,而不会泄露允许攻击者猜测其中一个值的时间信息。 这适用于比较 HMAC 摘要或秘密值,如身份验证 cookie 或功能网址

                                                                                                                                                                                                                                                                                                        crypto.verify(algorithm, data, key, signature[, callback])#

                                                                                                                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                                                                                                                          使用给定的密钥和算法验证 data 的给定签名。 如果 algorithmnullundefined,则算法取决于密钥类型(尤其是 Ed25519 和 Ed448)。

                                                                                                                                                                                                                                                                                                            crypto.webcrypto#

                                                                                                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                                                                                                            Type: <Crypto> Web 加密 API 标准的实现。

                                                                                                                                                                                                                                                                                                            注意事项#

                                                                                                                                                                                                                                                                                                            使用字符串作为加密 API 的输入#

                                                                                                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                                                                                                            由于历史原因,Node.js 提供的许多加密 API 都接受字符串作为输入,其中底层加密算法处理字节序列。 这些实例包括明文、密文、对称密钥、初始化向量、密码、盐、认证标签和额外的认证数据。

                                                                                                                                                                                                                                                                                                              旧版的流 API(Node.js v0.10 之前)#

                                                                                                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                                                                                              加密模块是在 Node.js 出现统一的流 API 概念之前添加的,在 Buffer 对象用于处理二进制数据之前。 因此,许多 crypto 定义的类具有在其他实现 API 的 Node.js 类(例如 update()final()digest())上通常找不到的方法。 此外,许多方法默认接受并返回 'latin1' 编码字符串,而不是 Buffer。 此默认值在 Node.js v0.8 之后更改为默认使用 Buffer 对象。

                                                                                                                                                                                                                                                                                                              弱算法或受损算法的支持#

                                                                                                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                                                                                              crypto 模块仍然支持一些已经被破坏并且目前不推荐使用的算法。 API 还允许使用对于安全使用来说太弱的小密钥大小的密码和散列。

                                                                                                                                                                                                                                                                                                                CCM 模式#

                                                                                                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                                                                                                CCM 是支持的 AEAD 算法之一。 使用此模式的应用程序在使用密码 API 时必须遵守某些限制:

                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                                                  加密常量#

                                                                                                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                                                                                                  crypto.constants 导出的以下常量适用于 cryptotlshttps 模块的各种用途,并且通常特定于 OpenSSL。

                                                                                                                                                                                                                                                                                                                  OpenSSL 选项#

                                                                                                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                                                                                                  有关详细信息,请参阅 SSL OP 标志列表

                                                                                                                                                                                                                                                                                                                  OpenSSL 引擎的常量#

                                                                                                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                                                                                                  其他 OpenSSL 常量#

                                                                                                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                                                                                                  Node.js 加密常量#

                                                                                                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                                                                                                  返回顶部