Autenticação com assinatura RSA

Além do token de autenticação, é obrigatório assinar o payload dos métodos POST e PUT com uma chave RSA para garantir a segurança dos dados.

Caso ainda não tenha uma chave, siga os passos:

No cmd ou terminal Linux/MAC, insira estes comandos:

1. Gerar uma chave privada:

   1. Bash

      openssl genrsa -out private-dom.pem 2048
      

2. Gerar chave pública a partir da chave privada:

   1. Bash

      openssl rsa -in private-dom.pem -outform PEM -pubout -out public-dom.pem
      
      

3. Envie sua chave pública, public-dom.pem, por e-mail ao seu gerente de contas na Dom para que ela seja configurada.

ASSINAR O SEU PAYLOAD COM CHAVE PRIVADA

Implemente em sua aplicação um método para assinar o payload. O resultado da assinatura deve ser codificado em base64 e enviado no cabeçalho da requisição, no parâmetro Signature.

Para testar se a assinatura enviada na requisição está correta, utilize o endpoint descrito em Verificar Assinatura

Exemplo em PHP:

PHP

<?php

/**
 * Função para assinar um payload com uma chave privada
 *
 * @param string $payload O payload a ser assinado (em JSON)
 * @param string $privateKeyPath Caminho para o arquivo da chave privada
 * @return string Assinatura em base64
 * @throws Exception Caso haja erro ao carregar a chave privada ou assinar o conteúdo
 */
function signPayload(string $payload, string $privateKeyPath): string
{
    // Carrega a chave privada
    $privateKey = file_get_contents($privateKeyPath);
    if ($privateKey === false) {
        throw new Exception("Erro ao carregar a chave privada.");
    }

    $privateKeyResource = openssl_pkey_get_private($privateKey);
    if ($privateKeyResource === false) {
        throw new Exception("Chave privada inválida.");
    }

    // Assina o payload
    $success = openssl_sign($payload, $signature, $privateKeyResource, OPENSSL_ALGO_SHA256);
    openssl_free_key($privateKeyResource);

    if (!$success) {
        throw new Exception("Erro ao assinar o payload.");
    }

    // Retorna a assinatura codificada em base64
    return base64_encode($signature);
}

// Caminho para a chave privada
$privateKeyPath = 'private-dom.pem';

// Payload em formato JSON
$payload = json_encode([
    'test' => "Testando"
]);

if ($payload === false) {
    die("Erro ao gerar o JSON do payload.\n");
}

try {
    // Assina o payload com a chave privada
    $signature = signPayload($payload, $privateKeyPath);

    // Configuração do cabeçalho
    $headers = [
        "Content-Type: application/json",
        "Signature: $signature",
      	"Authorization: Bearer {{seu_token}}"
    ];

    // URL do endpoint para enviar a requisição POST
    $url = 'https://apiv3.dompagamentos.com.br/checkout/production/verify-signature-rsa';

    // Inicializa o cURL
    $ch = curl_init($url);

    // Configura a requisição POST
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

    // Executa a requisição e captura a resposta
    $response = curl_exec($ch);
    if ($response === false) {
        throw new Exception('Erro na requisição: ' . curl_error($ch));
    }

    // Captura o código de resposta HTTP
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);

    // Fecha a conexão cURL
    curl_close($ch);

    // Exibe a resposta
    echo "HTTP Code: $httpCode\n";
    echo "Response: $response\n";

} catch (Exception $e) {
    echo "Erro: " . $e->getMessage() . "\n";
}

Exemplo em Node.js utilizando a biblioteca crypto:

Node

const fs = require('fs');
const crypto = require('crypto');
const axios = require('axios');

/**
 * Função para assinar um payload com uma chave privada
 *
 * @param {string} payload O payload a ser assinado (em JSON)
 * @param {string} privateKeyPath Caminho para o arquivo da chave privada
 * @returns {string} Assinatura em base64
 * @throws {Error} Caso haja erro ao carregar a chave privada ou assinar o conteúdo
 */
function signPayload(payload, privateKeyPath) {
  try {
    // Carrega a chave privada
    const privateKey = fs.readFileSync(privateKeyPath, 'utf8');

    // Assina o payload usando a chave privada e o algoritmo SHA256
    const sign = crypto.createSign('SHA256');
    sign.update(payload);
    sign.end();

    // Gera a assinatura e retorna codificada em base64
    const signature = sign.sign(privateKey, 'base64');
    return signature;
  } catch (error) {
    throw new Error(`Erro ao assinar o payload: ${error.message}`);
  }
}

// Caminho para a chave privada
const privateKeyPath = 'private-dom.pem';

// Payload em formato JSON
const payload = JSON.stringify({
  test: "Testando"
});

// URL do endpoint para enviar a requisição POST
const url = 'https://apiv3.dompagamentos.com.br/checkout/production/verify-signature-rsa';

// Token de autenticação
const token = '{{seu_token}}';

(async () => {
  try {
    // Assina o payload com a chave privada
    const signature = signPayload(payload, privateKeyPath);

    // Configuração do cabeçalho
    const headers = {
      'Content-Type': 'application/json',
      'Signature': signature,
      'Authorization': `Bearer ${token}`
    };

    // Envia a requisição POST usando axios
    const response = await axios.post(url, payload, { headers });

    // Exibe o status e a resposta
    console.log('HTTP Code:', response.status);
    console.log('Response:', response.data);
  } catch (error) {
    console.error('Erro:', error.message);
  }
})();