Skip to main content
Este guia descreve o processo de autenticação para interagir com a Noodle External API, que utiliza chaves assimétricas e JSON Web Tokens (JWT) com o algoritmo ES256 para segurança.

​
Visão Geral da Autenticação

O processo de autenticação envolve os seguintes passos principais:
  1. Geração de Chaves Assimétricas: Você precisará de um par de chaves pública e privada. A chave privada é usada para assinar suas requisições e deve ser mantida em segredo. A chave pública é usada pelo servidor para verificar a assinatura.
  2. Geração do Hash do Corpo da Requisição: Um hash MD5 do corpo da sua requisição (se houver) é gerado.
  3. Criação do JWT: Um JWT é criado contendo informações da requisição (método, URL, hash do corpo), timestamp, seu ID de usuário e chave de API. Este JWT é assinado com sua chave privada usando o algoritmo ES256.
  4. Envio da Requisição: O JWT assinado é enviado no cabeçalho Authorization da sua requisição HTTP.

​
1) Geração de Chaves Assimétricas (ES256 - secp256r1)

Use os seguintes comandos Unix (OpenSSL) para gerar suas chaves. Guarde sua chave privada (private_key.pem) em um ambiente seguro e nunca a compartilhe.

​
Gerar Chave Privada:

openssl ecparam -name secp256r1 -genkey -noout -out private_key.pem

​
Gerar Chave Pública a partir da Chave Privada:

openssl ec -in private_key.pem -pubout -out public_key.pem

​
2. Geração do Token de Autenticação (JWT)

O token de autenticação é um JWT assinado com sua chave privada. Os seguintes campos são necessários no payload do JWT:
CampoDescriçãoExemplo (do Documento)
payload_md5Hash MD5 do corpo da requisição JSON.md5(json.dumps(request_body).encode()).hexdigest()
timestampTimestamp atual no formato UTC: %Y-%m-%dT%H:%M:%S.%fZ (ex: 2023-10-26T10:00:00.000Z).datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%S.%fZ")
methodMétodo HTTP da requisição (ex: “POST”, “GET”)."POST"
urlA URL do endpoint da API que está sendo chamada (sem o domínio base, apenas o caminho). Ex: /external."https://prodcution.api.noodle.cx/external/split"
user_idSeu ID de usuário fornecido."adc936da-1c92-11ef-8696-e2e1e3dec240"
api_keySua chave de API fornecida."b860df30-8d03-34ed-0436-02081e3dec48"
O cabeçalho do JWT (JOSE header) deve ser: 
{
    "typ": "JWT",
    "alg": "ES256"
}

​
3. Exemplos de Código para Gerar o Cabeçalho de Autenticação

Abaixo estão exemplos de como gerar o JWT e o cabeçalho de autorização em diferentes linguagens de programação. Você precisará adaptar o carregamento da chave privada e a estrutura exata da sua requisição.
  • Python
  • JavaScript
  • Java
  • C#
  • Go
  • PHP
  • Ruby
  • Dart

​
Python

Este exemplo é baseado diretamente no documento fornecido.
import json
from datetime import datetime, timezone
from hashlib import md5
from jose import jwt, exceptions as jose_exceptions
from typing import Dict


BASE_URL = "[https://homolog.api.noodle.cx](https://homolog.api.noodle.cx)"
USER_ID = "82f04bce-e088-11ee-acd2-299d225f5178"
API_KEY = "fdef711f-8c6b-476d-b1cf-c9c340422763"
PRIVATE_KEY_PEM = """-----BEGIN EC PRIVATE KEY-----
MHcCAQEEIO8Bh+h4TkpoA1yVa0V1lX85UeAnXd2bmgFs9k67X4UKoAoGCCqGSM49
AwEHoUQDQgAE2hsBhwR3Od4CgBnT/DVZH+SBsyn74IMABdmcjYZOJIbVySYYSQGq
C5jvT8zoE5GDlQEHX0j7vKGrZO4YXnwlxQ==
-----END EC PRIVATE KEY-----"""

def generate_auth_header(method: str, url: str, body_dict: Dict) -> Dict:
    """
    a url aqui é a URL completa do endpoint, incluindo o domínio base.
    """
    try:
        json_body_str = json.dumps(body_dict, separators=(',', ':'))
        body_md5_hash = md5(json_body_str.encode('utf-8')).hexdigest()
        timestamp_now = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"

        jwt_payload = {
            "payload_md5": body_md5_hash,
            "timestamp": timestamp_now,
            "method": method,
            "url": url,
            "user_id": USER_ID,
            "api_key": API_KEY
        }

        encoded_token = jwt.encode(
            claims=jwt_payload,
            key=PRIVATE_KEY_PEM,
            algorithm="ES256",
            headers={"typ": "JWT", "alg": "ES256"}
        )
        print("✅ Token JWT gerado com sucesso!")
        return {"Authorization": encoded_token}

    except jose_exceptions.JOSEError as e:
        print(f"❌ Erro ao gerar o token JWT: {e}")
        raise

​
4. Utilizando o Header de Autenticação

Após gerar o encoded_header_token (o JWT assinado) conforme demonstrado nos exemplos de código da seção anterior, você deve incluí-lo em suas requisições HTTP para a Noodle External API. O token JWT é enviado no cabeçalho (header) Authorization. Para requisições que enviam dados no corpo, como POST ou PUT com um payload JSON, você também deve incluir o cabeçalho Content-Type: application/json.

​
Formato do Cabeçalho

Authorization: SEU_TOKEN_JWT_GERADO_AQUI
Content-Type: application/json
Substitua SEU_TOKEN_JWT_GERADO_AQUI pelo valor real do token que seu código gerou.

​
Exemplo de Requisição (cURL)

O exemplo a seguir demonstra como fazer uma requisição POST para o endpoint /external, similar ao usado nos exemplos de geração de token. Você precisará substituir <SEU_TOKEN_JWT_GERADO> pelo token real. 
# Substitua <SEU_TOKEN_JWT_GERADO> pelo token JWT que você gerou.
# O corpo da requisição (-d) deve ser o mesmo usado para gerar o 'payload_md5' do seu JWT.

curl -X POST "https://production.api.noodle.cx/external" \
-H "Authorization: <SEU_TOKEN_JWT_GERADO>" \
-H "Content-Type: application/json" \
-d '{"Noodle": "Test"}'
Ao executar este comando cURL (com o token correto), a API da Noodle tentará autenticar sua requisição usando o JWT fornecido e processará o corpo da requisição. Lembre-se que o payload_md5 dentro do seu JWT deve corresponder exatamente ao hash MD5 do corpo da requisição JSON que você está enviando ('{"Noodle": "Test"}' neste exemplo).

​
Suporte

Para troca de informações sobre a API, solicitação ou renovação de certificados, ou para esclarecer quaisquer dúvidas sobre o processo de autenticação e uso da Noodle External API, entre em contato conosco através do seguinte e-mail: [email protected]