Para garantir a segurança de suas transações Payouts, você deve realizar uma criptografia de ponta a ponta. Isso envolve a criação de um mecanismo de chave pública-privada, no qual um request é criptografado por meio de uma chave de segurança, e outra chave é usada para validá-lo.

Portanto, você deve enviar sua chave pública para o Mercado Pago para a validação de suas transações, e manter sua chave privada armazenada de forma segura para criptografar seus requests.

Para criar as chaves pública e privada no Linux ou MacOS, execute o seguinte comando em seu terminal:

terminal
Copiar
openssl genpkey -algorithm ed25519 -out mpprivate.pem && 
openssl pkey -in mpprivate.pem -pubout -out mppublic.pem

Em resposta, serão gerados dois arquivos, um com sua chave pública, que você deve enviar ao Mercado Pago, e outro com a chave privada, que deve ser armazenada de forma segura em seu sistema.

Para enviar sua chave pública, você precisará se conectar com a equipe de Integrações. Abaixo, fornecemos o seguinte exemplo de requisição, no qual o arquivo private.key é lido, o request é criptografado e a assinatura é adicionada ao header.

package main

import (
    "bytes"
    "crypto/ed25519"
    "crypto/x509"
    "encoding/base64"
    "encoding/pem"
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    // Path to the file storing the private key
    privateKeyFile := "private.key"

    // Read the private key from the file
    privateKeyBytes, err := ioutil.ReadFile(privateKeyFile)
    if err != nil {
        fmt.Println("Error reading private key:", err)
        return
    }

    // Convert the private key bytes to a PrivateKey
    privateKey := ed25519.PrivateKey(privateKeyBytes)

    // Define your request body
    requestBody := []byte(`{"key": "value"}`)

    // Sign the request body with the private key
    signature := ed25519.Sign(privateKey, requestBody)

    // Encode the signature to base64
    signatureBase64 := base64.StdEncoding.EncodeToString(signature)

    // Create a new HTTP request
    req, err := http.NewRequest("POST", "https://example.com/api/endpoint", bytes.NewBuffer(requestBody))
    if err != nil {
        fmt.Println("Error creating request:", err)
        return
    }

    // Add the X-signature header with the base64 encoded signature
    req.Header.Set("X-signature", signatureBase64)

    // Send the request
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error sending request:", err)
        return
    }
    defer resp.Body.Close()

    // Read the response body
    responseBody, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("Error reading response body:", err)
        return
    }

    // Print the response body
    fmt.Println("Response:", string(responseBody))
}

from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import ed25519
import base64
import json

def main():
    # PEM formatted private key
    private_key_pem = b'''************************************************'''

    try:
        # Load the private key from PEM format
        private_key = serialization.load_pem_private_key(
            private_key_pem,
            password=None  # No password protection in this example
        )

        # Ensure we have an Ed25519 private key
        if not isinstance(private_key, ed25519.Ed25519PrivateKey):
            print("Error: The provided key is not a valid Ed25519 private key")
            return

        # Define request body as a Python dict
        request_data = b'''{REQUEST_BODY}'''

        # Use request_data directly as it's already in bytes
        request_body = request_data
        
        print("Request body that will be signed:")
        print(request_data.decode('utf-8'))  # Print the request body
        print("\n---\n")

        # Sign the request body
        signature = private_key.sign(request_body)

        # Get the public key
        public_key = private_key.public_key()

        # Encode signature to base64
        signature_base64 = base64.b64encode(signature).decode('utf-8')

        # Print results
        print(f"Generated signature: {signature_base64}")
        print(f"Signature size: {len(signature)} bytes")
        
        # Get key sizes
        private_bytes = private_key.private_bytes(
            encoding=serialization.Encoding.Raw,
            format=serialization.PrivateFormat.Raw,
            encryption_algorithm=serialization.NoEncryption()
        )
        public_bytes = public_key.public_bytes(
            encoding=serialization.Encoding.Raw,
            format=serialization.PublicFormat.Raw
        )
        
        print(f"Private key size: {len(private_bytes)} bytes")
        print(f"Public key size: {len(public_bytes)} bytes")

        # Verify the signature
        try:
            public_key.verify(signature, request_body)
            print("✓ Signature verified successfully!")
        except Exception:
            print("✗ Signature verification failed!")

    except Exception as e:
        print(f"Error: {str(e)}")

if __name__ == "__main__":
    main()

Após realizar os devidos testes de sua integração, lembre-se substituir as credenciaisChaves de acesso únicas que usamos para identificar uma integração na sua conta, estando vinculadas à sua aplicação. Para mais informações, acesse o link abaixo.Credenciais utilizadas na etapa de desenvolvimento pelas de produção para iniciar ao ambiente produtivo da loja e começar a realizar transações reais. Para isso, é necessário ativá-las. Siga os passos abaixo para realizá-lo.

1. Acesse Suas integrações e selecione uma aplicação.
2. Em Dados de integração, vá para a seção Credenciais, localizada no lado direito da tela, e clique em Produção. Em seguida, clique em Ativar credenciais. Alternativamente, você poderá acessá-las a partir da seção Credenciais de produção no menu lateral esquerdo.
3. No campo Indústria, selecione a indústria ou ramo ao qual pertence o negócio que você está integrando no menu suspenso.
4. No campo Website (obrigatório), preencha com o URL do website do seu negócio.
5. Aceite a Declaração de Privacidade e os Termos e condições. Preencha o reCAPTCHA e clique em Ativar credenciais de produção.

Para subir em produção, você deve colocar as credenciais de produção da sua aplicação do Mercado Pago na sua integração.

Para isso, acesse Suas integrações, dirija-se à seção Credenciais, localizada à direita da tela, e clique em Produção. Alternativamente, você também poderá acessá-las a partir de Produção > Credenciais de produção.

Lá você encontrará sua Public Key e Access Token produtivos, que deverá utilizar no lugar das credenciais da conta de teste.

Para mais informações, consulte nossa documentação de Credenciais.