Para asegurar la seguridad de tus transacciones Payouts, deberás realizar un cifrado de extremo a extremo. Esto implica la creación de un mecanismo de clave pública-privada, en el que un request se cifra por medio de una clave de seguridad, y otra clave se usa para validarlo.

Por lo tanto, deberás enviar tu clave pública a Mercado Pago para la validación de tus transacciones, y mantener tu clave privada almacenada de forma segura para cifrar tus requests.

Para crear las llaves pública y privada en Linux o MacOS, ejecuta el siguiente comando en tu terminal:

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

En respuesta, se generarán dos archivos, uno con tu clave pública, que debes enviar a Mercado Pago, y otro con la clave privada, que debes almacenar de forma segura en tu sistema.

Para enviar tu clave pública, deberás conectarte con el equipo de Integraciones. A continuación, te proporcionamos el siguiente ejemplo de solicitud, en el que se lee el archivo private.key, se cifra el request y se agrega la firma al 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()

Después de realizar las debidas pruebas de tu integración, recuerda reemplazar las credencialesClaves de acceso únicas que usamos para identificar una integración en tu cuenta, estando vinculadas a tu aplicación. Para más información, accede al link a continuación.Credenciales utilizadas en la etapa de desarrollo por las de producción para iniciar al ambiente productivo de la tienda y comenzar a realizar transacciones reales. Para ello, es necesario activarlas. Sigue los pasos a continuación para realizarlo.

1. Accede a Tus integraciones y selecciona una aplicación.
2. En Datos de integración, ve a la sección Credenciales, ubicada en el lado derecho de la pantalla, y haz clic en Producción. Luego, haz clic en Activar credenciales. Alternativamente, podrás acceder a ellas desde la sección Credenciales de producción en el menú lateral izquierdo.
3. En el campo Industria, selecciona la industria o ramo al que pertenece el negocio que estás integrando en el menú desplegable.
4. En el campo Sitio web (obligatorio), completa con la URL del sitio web de tu negocio.
5. Acepta la Declaración de Privacidad y los Términos y condiciones. Completa el reCAPTCHA y haz clic en Activar credenciales de producción.

Para salir a producción, debes colocar las credenciales de producción de tu aplicación de Mercado Pago en tu integración.

Para ello, accede a Tus integraciones, dirígete a la sección Credenciales, ubicada a la derecha de la pantalla, y haz clic en Producción. Alternativamente, también podrás acceder a ellas desde Producción > Credenciales de producción.

Allí encontrarás tu Public Key y Access Token productivos, que deberás utilizar en lugar de las credenciales de la cuenta de prueba.

Para más información, consulta nuestra documentación de Credenciales.