node:crypto

O módulo node:crypto no Azion Runtime: hashes, assinaturas HMAC, valores aleatórios seguros e acesso à Web Crypto API, com exemplos e as APIs com suporte.

Última atualização

Ver como Markdown Configurar agente

O módulo node:crypto fornece as funções criptográficas do Node.js: hashing, assinaturas HMAC, criptografia, descriptografia e valores aleatórios seguros. No Node.js, o módulo encapsula as funções de hash, HMAC, cifra, decifra, assinatura e verificação do OpenSSL. No Azion Runtime, o módulo está disponível por meio da compatibilidade com Node.js, e você pode usá-lo dentro de uma function para assinar requisições, verificar a integridade de mensagens ou gerar identificadores únicos. Sua exportação subtle, na importação nomeada e na exportação padrão, é o mesmo objeto que globalThis.crypto.subtle, e o módulo também exporta webcrypto.

nota — Com azion dev, timingSafeEqual() e generateKeyPairSync() lançam TypeError: (void 0) is not a function, e o build emite o aviso Import "timingSafeEqual" will always be undefined because there is no matching export in "internal-env-dev:crypto". As duas funções funcionam em uma function após o deploy. Localmente, Buffer.isBuffer() também retorna false para o buffer que randomBytes() retorna; após o deploy, retorna true.

Exemplos

Cada exemplo é uma function completa que importa de node:crypto. A resposta abaixo de cada exemplo é a que uma function com deploy feito retorna. Valores aleatórios, como UUIDs e tokens, mudam a cada requisição.

HMAC e geração de UUID

Esta function assina uma string com uma chave HMAC, imprime a assinatura e responde com um UUID aleatório:

JavaScript
01/**
02 * An example of using the Node.js Crypto API in an Azion Function.
03 * Support:
04 * - Extended by library `crypto-browserify`
05 * - Implemented additional methods:
06 * - randomUUID (named export and default export)
07 * @module runtime-apis/nodejs/crypto/main
08 * @example
09 * // Build and run with the Azion CLI:
10 * azion build
11 * azion dev
12 */
13import { createHmac, randomUUID } from "node:crypto";
14
15/**
16 * Example of using the Node.js Crypto API
17 * @param {*} event
18 * @returns
19 */
20const main = async (event) => {
21 const hmac = createHmac("sha256", "a secret");
22 hmac.update("Azion Functions");
23 const hmacResult = hmac.digest("hex");
24 console.log(hmacResult);
25 // 86fec9e22ad82998c7007d637f61a5206e2b64ee2a8ac2ed12f1f359e3d14bc6
26
27 const uuid = randomUUID();
28 console.log(uuid);
29 // 9b942e1e-6ceb-49cd-9d75-e50c7852e950
30
31 return new Response(uuid, { status: 200 });
32};
33
34export default main;

A function responde com o UUID:

9b942e1e-6ceb-49cd-9d75-e50c7852e950

Geração de hash com SHA-256

Esta function gera o hash de uma string fixa para verificar a integridade dos dados e gera o hash da URL da requisição para criar uma chave de cache determinística:

JavaScript
01import { createHash } from "node:crypto";
02
03const main = async (event) => {
04 // Create a SHA-256 hash
05 const hash = createHash("sha256");
06 hash.update("Hello, Azion Runtime!");
07
08 const digest = hash.digest("hex");
09 console.log("SHA-256 hash:", digest);
10 // SHA-256 hash: 6183c5245446e11f9d5dc70b167bb7fb6d8f878576765db2106c18c24eba2970
11
12 // Hash request data for caching keys
13 // Note: event.request is available in Functions for Applications
14 const requestUrl = event.request?.url || "https://default.example.com";
15 const cacheKey = createHash("sha256")
16 .update(requestUrl)
17 .digest("hex");
18
19 console.log("Cache key:", cacheKey);
20
21 return new Response(JSON.stringify({ digest, cacheKey }), {
22 headers: { "Content-Type": "application/json" }
23 });
24};
25
26export default main;

A function responde com os dois hashes. O valor digest é o mesmo a cada requisição; o valor cacheKey depende da URL da requisição, então o seu é diferente:

{"digest":"6183c5245446e11f9d5dc70b167bb7fb6d8f878576765db2106c18c24eba2970","cacheKey":"22d8de40ffcb2a09a030d3798d6821add8941a103b43c8e722d87b7ee59aa821"}

Geração de bytes aleatórios

Esta function gera valores aleatórios seguros para um token, um ID de sessão e um nonce, e define o nonce em um header Content-Security-Policy:

JavaScript
01import { randomBytes } from "node:crypto";
02import { Buffer } from "node:buffer";
03
04const main = async (event) => {
05 // Generate 32 random bytes
06 // Note: randomBytes returns a Buffer in Azion Runtime
07 const bytes = randomBytes(32);
08
09 // Ensure compatibility: convert to Buffer if needed
10 const buffer = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes);
11
12 const token = buffer.toString("hex");
13 console.log("Secure token:", token);
14
15 // Generate a shorter session ID
16 const sessionId = randomBytes(16).toString("base64url");
17 console.log("Session ID:", sessionId);
18
19 // Generate a nonce for CSP headers
20 const nonce = randomBytes(16).toString("base64");
21
22 // Show raw buffer output (common in Node.js)
23 console.log("Raw buffer:", bytes);
24
25 return new Response(JSON.stringify({ token, sessionId, nonce }), {
26 headers: {
27 "Content-Type": "application/json",
28 "Content-Security-Policy": `script-src 'nonce-${nonce}'`
29 }
30 });
31};
32
33export default main;

A function responde com os três valores e define Content-Security-Policy como script-src 'nonce-<nonce>', em que <nonce> é o valor de nonce da mesma resposta. Os valores mudam a cada requisição:

{"token":"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef","sessionId":"AAECAwQFBgcICQoLDA0ODw","nonce":"AAECAwQFBgcICQoLDA0ODw=="}

Integração com a Web Crypto API

O módulo crypto também dá acesso à Web Crypto API por meio de crypto.subtle, que é o mesmo objeto que globalThis.crypto.subtle. Esta function gera uma chave AES, exporta essa chave e criptografa uma string com ela:

JavaScript
01import crypto from "node:crypto";
02
03const main = async (event) => {
04 // Access Web Crypto API
05 // Note: crypto.subtle === globalThis.crypto.subtle in Azion Runtime
06 const subtle = crypto.subtle;
07
08 // Generate an AES key for encryption
09 const key = await subtle.generateKey(
10 { name: "AES-GCM", length: 256 },
11 true,
12 ["encrypt", "decrypt"]
13 );
14
15 // Export the key for storage
16 const exportedKey = await subtle.exportKey("raw", key);
17 const keyBuffer = new Uint8Array(exportedKey);
18
19 console.log("Generated key length:", keyBuffer.length);
20 // Generated key length: 32
21
22 // Encrypt data
23 const iv = crypto.getRandomValues(new Uint8Array(12));
24 const encoder = new TextEncoder();
25 const data = encoder.encode("Sensitive data to encrypt");
26
27 const encrypted = await subtle.encrypt(
28 { name: "AES-GCM", iv },
29 key,
30 data
31 );
32
33 console.log("Encrypted data length:", encrypted.byteLength);
34 // Encrypted data length: 41
35
36 return new Response("Encryption complete", { status: 200 });
37};
38
39export default main;

A function responde com uma confirmação, depois de registrar no log um tamanho de chave de 32 bytes e um tamanho criptografado de 41 bytes:

Encryption complete

APIs com suporte

A tabela lista o status de cada API de node:crypto no Azion Runtime:

APIStatus
constants🟢 Com suporte
createHash()🟢 Com suporte
createHmac()🟢 Com suporte
getRandomValues()🟢 Com suporte
randomBytes()🟢 Com suporte
randomUUID()🟢 Com suporte
subtle🟢 Com suporte
webcrypto🟢 Com suporte
createCipher()🟡 Parcialmente suportado
createDecipher()🟡 Parcialmente suportado
createSign()🟡 Parcialmente suportado
createVerify()🟡 Parcialmente suportado

As APIs marcadas como 🟡 Parcialmente suportado têm funcionalidade limitada em comparação com a implementação completa do Node.js. Para criptografia e assinatura, a Web Crypto API (crypto.subtle) é uma alternativa mais completa. O módulo também exporta funções que a tabela não lista: createCipheriv() e createDecipheriv() criptografam e descriptografam com aes-256-cbc, pbkdf2Sync() deriva uma chave a partir de uma senha e getHashes() está disponível. timingSafeEqual() e generateKeyPairSync(), também exportadas, funcionam em uma function após o deploy.

Recursos relacionados

APIs do Node.js

Como cada módulo do Node.js se comporta no Azion Runtime, com seu status de suporte.

SubtleCrypto

Os métodos da Web Crypto que crypto.subtle expõe para criptografia, assinatura e gerenciamento de chaves.

Documentação do crypto no Node.js

Os parâmetros e os valores de retorno de cada API de node:crypto, conforme a documentação do Node.js.

Web Crypto API na MDN

O padrão por trás de crypto.subtle e crypto.getRandomValues().