Integração de Sistemas

Valide se sua conta, suas APIs, e suas KEYS estão funcionando corretamente e integre o futuro com segurança aos seus novos projetos!

Bancos de Dados

Criptografia transparente para seus dados

PostgreSQL
MySQL
MongoDB
Oracle

Cloud Providers

Integração nativa com grandes provedores

AWS KMS
Azure Key Vault
Google Cloud KMS
IBM Cloud

Linguagens

SDKs oficiais disponíveis

Python
Java
JavaScript/Node.js
Go

Validação de Conexão

import requests

# ===== CONFIGURAÇÃO NECESSÁRIA =====
API_URL = "http://localhost:8000"          # URL da sua API VexCrypt
API_KEY = "pqc_sua_api_key_aqui"          # API Key gerada no painel VexCrypt
KEY_ID  = "key_xxxxxxxxxxxxxxxxxxxxxxxx"  # ID da chave (aba Chaves do painel)
# ===================================

headers = {
    "X-API-Key": API_KEY,
    "Content-Type": "application/json"
}

# CRIPTOGRAFAR DADOS
plaintext = "Dados sensíveis da minha empresa"
print(f"[LOG] 🔐 Iniciando criptografia...")
print(f"[LOG] 📝 Dados originais: {plaintext}")

encrypt_response = requests.post(
    f"{API_URL}/crypto/encrypt",
    headers=headers,
    json={"data": plaintext, "key_id": KEY_ID}
)

encrypt_data = encrypt_response.json()
encrypted  = encrypt_data["encrypted_data"]
algorithm  = encrypt_data["algorithm"]
operation  = encrypt_data["operation_id"]

print(f"[LOG] ✅ Criptografia concluída!")
print(f"[LOG] 🔑 Algoritmo: {algorithm}")
print(f"[LOG] 🆔 Operação: {operation}")
print(f"[LOG] 📦 Dados criptografados: {encrypted[:60]}...")

# DESCRIPTOGRAFAR DADOS
print(f"\n[LOG] 🔓 Iniciando descriptografia...")

decrypt_response = requests.post(
    f"{API_URL}/crypto/decrypt",
    headers=headers,
    json={"encrypted_data": encrypted, "key_id": KEY_ID}
)

decrypt_data = decrypt_response.json()
decrypted   = decrypt_data["decrypted_data"]

print(f"[LOG] ✅ Descriptografia concluída!")
print(f"[LOG] 📝 Dados recuperados: {decrypted}")
print(f"[LOG] 🔄 Operação registrada: {decrypt_data['operation_id']}")

import okhttp3.*;
import org.json.*;
import java.io.IOException;

public class VexCryptIntegration {
    // ===== CONFIGURAÇÃO NECESSÁRIA =====
    private static final String API_URL = "http://localhost:8000";
    private static final String API_KEY = "pqc_sua_api_key_aqui";          // API Key gerada no painel
    private static final String KEY_ID  = "key_xxxxxxxxxxxxxxxxxxxxxxxx"; // ID da chave (aba Chaves)
    // ===================================
    
    private static final OkHttpClient client = new OkHttpClient();
    private static final MediaType MEDIA_JSON = MediaType.get("application/json; charset=utf-8");
    
    public static void main(String[] args) throws IOException {
        // CRIPTOGRAFAR DADOS
        String plaintext = "Dados sensíveis da minha empresa";
        System.out.println("[LOG] 🔐 Iniciando criptografia...");
        System.out.println("[LOG] 📝 Dados originais: " + plaintext);
        
        JSONObject encryptPayload = new JSONObject()
            .put("data", plaintext)
            .put("key_id", KEY_ID);
        
        Request encryptRequest = new Request.Builder()
            .url(API_URL + "/crypto/encrypt")
            .addHeader("X-API-Key", API_KEY)
            .post(RequestBody.create(encryptPayload.toString(), MEDIA_JSON))
            .build();
        
        Response encryptResponse = client.newCall(encryptRequest).execute();
        JSONObject encryptData = new JSONObject(encryptResponse.body().string());
        
        String encrypted  = encryptData.getString("encrypted_data");
        String algorithm  = encryptData.getString("algorithm");
        String operationE = encryptData.getString("operation_id");
        
        System.out.println("[LOG] ✅ Criptografia concluída!");
        System.out.println("[LOG] 🔑 Algoritmo: " + algorithm);
        System.out.println("[LOG] 🆔 Operação: " + operationE);
        System.out.println("[LOG] 📦 Dados criptografados: " + encrypted.substring(0, Math.min(60, encrypted.length())) + "...");
        
        // DESCRIPTOGRAFAR DADOS
        System.out.println("\n[LOG] 🔓 Iniciando descriptografia...");
        
        JSONObject decryptPayload = new JSONObject()
            .put("encrypted_data", encrypted)
            .put("key_id", KEY_ID);
        
        Request decryptRequest = new Request.Builder()
            .url(API_URL + "/crypto/decrypt")
            .addHeader("X-API-Key", API_KEY)
            .post(RequestBody.create(decryptPayload.toString(), MEDIA_JSON))
            .build();
        
        Response decryptResponse = client.newCall(decryptRequest).execute();
        JSONObject decryptData = new JSONObject(decryptResponse.body().string());
        
        String decrypted  = decryptData.getString("decrypted_data");
        String operationD = decryptData.getString("operation_id");
        
        System.out.println("[LOG] ✅ Descriptografia concluída!");
        System.out.println("[LOG] 📝 Dados recuperados: " + decrypted);
        System.out.println("[LOG] 🔄 Operação registrada: " + operationD);
    }
}

// ===== CONFIGURAÇÃO NECESSÁRIA =====
const API_URL = 'http://localhost:8000';           // URL da sua API VexCrypt
const API_KEY = 'pqc_sua_api_key_aqui';           // API Key gerada no painel VexCrypt
const KEY_ID  = 'key_xxxxxxxxxxxxxxxxxxxxxxxx';   // ID da chave (aba Chaves do painel)
// ===================================

const headers = {
    'X-API-Key': API_KEY,
    'Content-Type': 'application/json'
};

async function vexcryptIntegration() {
    try {
        // CRIPTOGRAFAR DADOS
        const plaintext = 'Dados sensíveis da minha empresa';
        console.log('[LOG] 🔐 Iniciando criptografia...');
        console.log(`[LOG] 📝 Dados originais: ${plaintext}`);
        
        const encryptResponse = await fetch(`${API_URL}/crypto/encrypt`, {
            method: 'POST',
            headers: headers,
            body: JSON.stringify({ data: plaintext, key_id: KEY_ID })
        });
        
        const encryptData = await encryptResponse.json();
        const encrypted  = encryptData.encrypted_data;
        const algorithm  = encryptData.algorithm;
        const operationE = encryptData.operation_id;
        
        console.log('[LOG] ✅ Criptografia concluída!');
        console.log(`[LOG] 🔑 Algoritmo: ${algorithm}`);
        console.log(`[LOG] 🆔 Operação: ${operationE}`);
        console.log(`[LOG] 📦 Dados criptografados: ${encrypted.substring(0, 60)}...`);
        
        // DESCRIPTOGRAFAR DADOS
        console.log('\n[LOG] 🔓 Iniciando descriptografia...');
        
        const decryptResponse = await fetch(`${API_URL}/crypto/decrypt`, {
            method: 'POST',
            headers: headers,
            body: JSON.stringify({ encrypted_data: encrypted, key_id: KEY_ID })
        });
        
        const decryptData = await decryptResponse.json();
        const decrypted   = decryptData.decrypted_data;
        const operationD  = decryptData.operation_id;
        
        console.log('[LOG] ✅ Descriptografia concluída!');
        console.log(`[LOG] 📝 Dados recuperados: ${decrypted}`);
        console.log(`[LOG] 🔄 Operação registrada: ${operationD}`);
        
    } catch (error) {
        console.error('[ERRO] ❌ Falha na operação:', error.message);
    }
}

vexcryptIntegration();

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

// ===== CONFIGURAÇÃO NECESSÁRIA =====
const (
    API_URL = "http://localhost:8000"
    API_KEY = "pqc_sua_api_key_aqui"          // API Key gerada no painel VexCrypt
    KEY_ID  = "key_xxxxxxxxxxxxxxxxxxxxxxxx" // ID da chave (aba Chaves do painel)
)
// ===================================

type EncryptRequest struct {
    Data  string `json:"data"`
    KeyID string `json:"key_id"`
}

type EncryptResponse struct {
    EncryptedData string `json:"encrypted_data"`
    Algorithm     string `json:"algorithm"`
    OperationID   string `json:"operation_id"`
}

type DecryptRequest struct {
    EncryptedData string `json:"encrypted_data"`
    KeyID         string `json:"key_id"`
}

type DecryptResponse struct {
    DecryptedData string `json:"decrypted_data"`
    OperationID   string `json:"operation_id"`
}

func main() {
    // CRIPTOGRAFAR DADOS
    plaintext := "Dados sensíveis da minha empresa"
    fmt.Println("[LOG] 🔐 Iniciando criptografia...")
    fmt.Printf("[LOG] 📝 Dados originais: %s\n", plaintext)
    
    encryptPayload, _ := json.Marshal(EncryptRequest{
        Data:  plaintext,
        KeyID: KEY_ID,
    })
    
    encryptReq, _ := http.NewRequest("POST", API_URL+"/crypto/encrypt",
        bytes.NewBuffer(encryptPayload))
    encryptReq.Header.Set("X-API-Key", API_KEY)
    encryptReq.Header.Set("Content-Type", "application/json")
    
    client := &http.Client{}
    encryptResp, _ := client.Do(encryptReq)
    defer encryptResp.Body.Close()
    
    encryptBody, _ := io.ReadAll(encryptResp.Body)
    var encryptData EncryptResponse
    json.Unmarshal(encryptBody, &encryptData)
    
    fmt.Println("[LOG] ✅ Criptografia concluída!")
    fmt.Printf("[LOG] 🔑 Algoritmo: %s\n", encryptData.Algorithm)
    fmt.Printf("[LOG] 🆔 Operação: %s\n", encryptData.OperationID)
    fmt.Printf("[LOG] 📦 Dados criptografados: %.60s...\n", encryptData.EncryptedData)
    
    // DESCRIPTOGRAFAR DADOS
    fmt.Println("\n[LOG] 🔓 Iniciando descriptografia...")
    
    decryptPayload, _ := json.Marshal(DecryptRequest{
        EncryptedData: encryptData.EncryptedData,
        KeyID:         KEY_ID,
    })
    
    decryptReq, _ := http.NewRequest("POST", API_URL+"/crypto/decrypt",
        bytes.NewBuffer(decryptPayload))
    decryptReq.Header.Set("X-API-Key", API_KEY)
    decryptReq.Header.Set("Content-Type", "application/json")
    
    decryptResp, _ := client.Do(decryptReq)
    defer decryptResp.Body.Close()
    
    decryptBody, _ := io.ReadAll(decryptResp.Body)
    var decryptData DecryptResponse
    json.Unmarshal(decryptBody, &decryptData)
    
    fmt.Println("[LOG] ✅ Descriptografia concluída!")
    fmt.Printf("[LOG] 📝 Dados recuperados: %s\n", decryptData.DecryptedData)
    fmt.Printf("[LOG] 🔄 Operação registrada: %s\n", decryptData.OperationID)
}

Assinatura Digital Pós-Quântica

import requests

# ===== CONFIGURAÇÃO NECESSÁRIA =====
API_URL = "http://localhost:8000"
API_KEY = "pqc_sua_api_key_aqui"          # API Key gerada no painel VexCrypt
SIG_KEY_ID  = "key_xxxxxxxxxxxxxxxxxxxxxxxx"  # ID da chave de assinatura (ML-DSA ou Falcon)
ALGORITHM   = "ML-DSA-65"                 # Algoritmo: ML-DSA-44/65/87, Falcon-512/1024
# ===================================

headers = {
    "X-API-Key": API_KEY,
    "Content-Type": "application/json"
}

# ASSINAR DOCUMENTO
document = "Contrato de NDA — Empresa XYZ — 2026"
print("[LOG] ✍️  Assinando documento...")

sign_resp = requests.post(
    f"{API_URL}/api/v1/external/sign",
    headers=headers,
    json={
        "document_data": document,
        "key_id": SIG_KEY_ID,
        "algorithm": ALGORITHM
    }
)

sign_data  = sign_resp.json()
signature  = sign_data["signature"]
public_key = sign_data["verification_data"]["public_key"]

print(f"[LOG] ✅ Documento assinado!")
print(f"[LOG] 🔑 Algoritmo: {sign_data['algorithm']}")
print(f"[LOG] 🆔 Operação: {sign_data['operation_id']}")
print(f"[LOG] 📝 Assinatura: {signature[:60]}...")

# VERIFICAR ASSINATURA
print("\n[LOG] 🔍 Verificando assinatura...")

verify_resp = requests.post(
    f"{API_URL}/api/v1/external/verify",
    headers=headers,
    json={
        "document_data": document,
        "signature": signature,
        "public_key": public_key,
        "algorithm": ALGORITHM
    }
)

verify_data = verify_resp.json()
print(f"[LOG] ✅ Verificação concluída!")
print(f"[LOG] 🛡️  Assinatura válida: {verify_data['valid']}")
print(f"[LOG] 🆔 Operação: {verify_data['operation_id']}")

import okhttp3.*;
import org.json.*;
import java.io.IOException;

public class VexCryptSignature {
    // ===== CONFIGURAÇÃO NECESSÁRIA =====
    private static final String API_URL    = "http://localhost:8000";
    private static final String API_KEY    = "pqc_sua_api_key_aqui";
    private static final String SIG_KEY_ID = "key_xxxxxxxxxxxxxxxxxxxxxxxx";
    private static final String ALGORITHM  = "ML-DSA-65";
    // ===================================

    private static final OkHttpClient client    = new OkHttpClient();
    private static final MediaType    MEDIA_JSON = MediaType.get("application/json; charset=utf-8");

    public static void main(String[] args) throws IOException {
        String document = "Contrato de NDA — Empresa XYZ — 2026";
        System.out.println("[LOG] ✍️  Assinando documento...");

        // ASSINAR DOCUMENTO
        JSONObject signPayload = new JSONObject()
            .put("document_data", document)
            .put("key_id", SIG_KEY_ID)
            .put("algorithm", ALGORITHM);

        Request signRequest = new Request.Builder()
            .url(API_URL + "/api/v1/external/sign")
            .addHeader("X-API-Key", API_KEY)
            .post(RequestBody.create(signPayload.toString(), MEDIA_JSON))
            .build();

        Response signResponse = client.newCall(signRequest).execute();
        JSONObject signData   = new JSONObject(signResponse.body().string());

        String signature  = signData.getString("signature");
        String publicKey  = signData.getJSONObject("verification_data").getString("public_key");
        String operationS = signData.getString("operation_id");

        System.out.println("[LOG] ✅ Documento assinado!");
        System.out.println("[LOG] 🔑 Algoritmo: " + signData.getString("algorithm"));
        System.out.println("[LOG] 🆔 Operação: " + operationS);
        System.out.println("[LOG] 📝 Assinatura: " + signature.substring(0, Math.min(60, signature.length())) + "...");

        // VERIFICAR ASSINATURA
        System.out.println("\n[LOG] 🔍 Verificando assinatura...");

        JSONObject verifyPayload = new JSONObject()
            .put("document_data", document)
            .put("signature", signature)
            .put("public_key", publicKey)
            .put("algorithm", ALGORITHM);

        Request verifyRequest = new Request.Builder()
            .url(API_URL + "/api/v1/external/verify")
            .addHeader("X-API-Key", API_KEY)
            .post(RequestBody.create(verifyPayload.toString(), MEDIA_JSON))
            .build();

        Response verifyResponse = client.newCall(verifyRequest).execute();
        JSONObject verifyData   = new JSONObject(verifyResponse.body().string());

        System.out.println("[LOG] ✅ Verificação concluída!");
        System.out.println("[LOG] 🛡️  Assinatura válida: " + verifyData.getBoolean("valid"));
        System.out.println("[LOG] 🆔 Operação: " + verifyData.getString("operation_id"));
    }
}

// ===== CONFIGURAÇÃO NECESSÁRIA =====
const API_URL    = 'http://localhost:8000';
const API_KEY    = 'pqc_sua_api_key_aqui';
const SIG_KEY_ID = 'key_xxxxxxxxxxxxxxxxxxxxxxxx';
const ALGORITHM  = 'ML-DSA-65';
// ===================================

const headers = {
    'X-API-Key': API_KEY,
    'Content-Type': 'application/json'
};

async function vexcryptSignature() {
    try {
        const document = 'Contrato de NDA — Empresa XYZ — 2026';
        console.log('[LOG] ✍️  Assinando documento...');

        // ASSINAR DOCUMENTO
        const signResponse = await fetch(`${API_URL}/api/v1/external/sign`, {
            method: 'POST',
            headers,
            body: JSON.stringify({
                document_data: document,
                key_id: SIG_KEY_ID,
                algorithm: ALGORITHM
            })
        });

        const signData  = await signResponse.json();
        const signature = signData.signature;
        const publicKey = signData.verification_data.public_key;

        console.log('[LOG] ✅ Documento assinado!');
        console.log(`[LOG] 🔑 Algoritmo: ${signData.algorithm}`);
        console.log(`[LOG] 🆔 Operação: ${signData.operation_id}`);
        console.log(`[LOG] 📝 Assinatura: ${signature.substring(0, 60)}...`);

        // VERIFICAR ASSINATURA
        console.log('\n[LOG] 🔍 Verificando assinatura...');

        const verifyResponse = await fetch(`${API_URL}/api/v1/external/verify`, {
            method: 'POST',
            headers,
            body: JSON.stringify({
                document_data: document,
                signature,
                public_key: publicKey,
                algorithm: ALGORITHM
            })
        });

        const verifyData = await verifyResponse.json();
        console.log('[LOG] ✅ Verificação concluída!');
        console.log(`[LOG] 🛡️  Assinatura válida: ${verifyData.valid}`);
        console.log(`[LOG] 🆔 Operação: ${verifyData.operation_id}`);

    } catch (error) {
        console.error('[ERRO] ❌ Falha na operação:', error.message);
    }
}

vexcryptSignature();

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

// ===== CONFIGURAÇÃO NECESSÁRIA =====
const (
    API_URL    = "http://localhost:8000"
    API_KEY    = "pqc_sua_api_key_aqui"
    SIG_KEY_ID = "key_xxxxxxxxxxxxxxxxxxxxxxxx"
    ALGORITHM  = "ML-DSA-65"
)

// ===================================

type SignRequest struct {
    DocumentData string `json:"document_data"`
    KeyID        string `json:"key_id"`
    Algorithm    string `json:"algorithm"`
}

type VerificationData struct {
    PublicKey string `json:"public_key"`
    Algorithm string `json:"algorithm"`
}

type SignResponse struct {
    Signature        string          `json:"signature"`
    Algorithm        string          `json:"algorithm"`
    KeyID            string          `json:"key_id"`
    Timestamp        string          `json:"timestamp"`
    OperationID      interface{}     `json:"operation_id"`
    Message          string          `json:"message"`
    VerificationData VerificationData `json:"verification_data"`
}

type VerifyRequest struct {
    DocumentData string `json:"document_data"`
    Signature    string `json:"signature"`
    PublicKey    string `json:"public_key"`
    Algorithm    string `json:"algorithm"`
}

type VerifyResponse struct {
    Valid        bool        `json:"valid"`
    Algorithm    string      `json:"algorithm"`
    Timestamp    string      `json:"timestamp"`
    OperationID  interface{} `json:"operation_id"`
    Message      string      `json:"message"`
}

func post(url string, payload interface{}) []byte {
    body, _ := json.Marshal(payload)
    req, _  := http.NewRequest("POST", url, bytes.NewBuffer(body))
    req.Header.Set("X-API-Key", API_KEY)
    req.Header.Set("Content-Type", "application/json")
    resp, _ := (&http.Client{}).Do(req)
    defer resp.Body.Close()
    data, _ := io.ReadAll(resp.Body)
    return data
}

func main() {
    document := "Contrato de NDA — Empresa XYZ — 2026"
    fmt.Println("[LOG] ✍️  Assinando documento...")

    // ASSINAR DOCUMENTO
    signBody := post(API_URL+"/api/v1/external/sign", SignRequest{
        DocumentData: document,
        KeyID:        SIG_KEY_ID,
        Algorithm:    ALGORITHM,
    })

    var signData SignResponse
    json.Unmarshal(signBody, &signData)

    fmt.Println("[LOG] ✅ Documento assinado!")
    fmt.Printf("[LOG] 🔑 Algoritmo: %s\n", signData.Algorithm)
    fmt.Printf("[LOG] 🆔 Operação: %v\n", signData.OperationID)
    fmt.Printf("[LOG] 📝 Assinatura: %.60s...\n", signData.Signature)

    // VERIFICAR ASSINATURA
    fmt.Println("\n[LOG] 🔍 Verificando assinatura...")

    verifyBody := post(API_URL+"/api/v1/external/verify", VerifyRequest{
        DocumentData: document,
        Signature:    signData.Signature,
        PublicKey:    signData.VerificationData.PublicKey,
        Algorithm:    ALGORITHM,
    })

    var verifyData VerifyResponse
    json.Unmarshal(verifyBody, &verifyData)

    fmt.Println("[LOG] ✅ Verificação concluída!")
    fmt.Printf("[LOG] 🛡️  Assinatura válida: %v\n", verifyData.Valid)
    fmt.Printf("[LOG] 🆔 Operação: %v\n", verifyData.OperationID)
}