> ## Documentation Index > Fetch the complete documentation index at: https://x-preview-mintlify-5394b2f8.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. # Introdução à Criptografia > Conheça os conceitos de ECDH, criptografia de chave pública e assinaturas digitais por trás da criptografia de ponta a ponta do X Chat, sem detalhes de implementação. export const Button = ({href, children}) => { return
; }; Esta introdução explica as ideias criptográficas por trás do X Chat em nível conceitual. Você não precisa desse aprofundamento para desenvolver — o [Chat XDK](/pt/xchat/xchat-xdk) faz a criptografia, descriptografia, assinatura e o armazenamento de chaves por você — mas o modelo mental ajuda quando você projeta seu app ou depura o comportamento. Quando estiver pronto para implementar, consulte [Primeiros passos](/pt/xchat/getting-started) para um passo a passo completo e a [referência da API](/x-api/chat/get-chat-conversations) na barra lateral para rotas individuais. **Você não implementa esta criptografia por conta própria.** O Chat XDK cuida disso. Esta página é para entendimento, não uma lista de verificação de API. *** ## O panorama geral O X Chat usa um sistema de criptografia em camadas onde: 1. As **mensagens** são criptografadas com uma **chave da conversa** (criptografia simétrica rápida) 2. As **chaves da conversa** são criptografadas para cada participante usando sua **chave pública de identidade** (troca de chaves assimétrica) 3. As **mensagens são assinadas** com a **chave de assinatura**, para que os destinatários possam verificar quem as enviou e que nada foi alterado A criptografia simétrica é eficiente para grandes volumes de tráfego de mensagens; a criptografia assimétrica é usada principalmente para **distribuir** com segurança as chaves de conversa. ```mermaid theme={null} flowchart TB subgraph "Message Encryption" A[Your Message] --> B[Encrypt with
Conversation Key] B --> C[Encrypted Message] end subgraph "Key Distribution" D[Conversation Key] --> E[Encrypt with
Recipient's Public Key] E --> F[Encrypted Key
for Recipient] end subgraph "Authentication" C --> G[Sign with
Your Private Key] G --> H[Signature] end ``` No fluxo do produto, o X transporta **texto cifrado e envelopes de chave** — não conteúdo de mensagem legível nem a chave da conversa em bruto. Seu app usa o Chat XDK para criptografia e a [Chat API](/pt/xchat/introduction) (via XDK em Python/TypeScript ou HTTPS) para registrar chaves e enviar ou receber esses payloads criptografados. Consulte [Primeiros passos](/pt/xchat/getting-started) para entender como essas peças se encaixam. *** ## Tipos de chave explicados O X Chat usa três tipos de material de chave, cada um com um propósito específico. ### 1. Par de chaves de identidade **Propósito:** trocar com segurança chaves de conversa entre usuários | Componente | Descrição | | :------------------------------ | :------------------------------------------------------------------------------------- | | **Chave pública de identidade** | Compartilhada com outros; usada para criptografar chaves de conversa *para* você | | **Chave privada de identidade** | Mantida em segredo; usada para descriptografar chaves de conversa enviadas *para* você | Quando alguém adiciona você a uma conversa, essa pessoa criptografa a chave da conversa usando sua chave pública de identidade. Apenas sua chave privada de identidade pode descriptografá-la. As metades públicas são registradas e descobertas por meio das APIs de **chave pública** da plataforma (veja Chaves de criptografia na referência de API). As metades privadas ficam no Chat XDK (por exemplo, via [backup seguro de chave](#secure-key-backup-distributed-key-storage) ou um blob de chave cuidadosamente protegido). ### 2. Par de chaves de assinatura **Propósito:** provar que você é o autor de uma mensagem | Componente | Descrição | | :------------------------------ | :-------------------------------------------------------------- | | **Chave pública de assinatura** | Compartilhada com outros; usada para verificar suas assinaturas | | **Chave privada de assinatura** | Mantida em segredo; usada para assinar suas mensagens | Quando você envia uma mensagem, ela é assinada com sua chave privada de assinatura. Os destinatários verificam usando sua chave pública de assinatura (também publicada pelas APIs de chave pública). O Chat XDK assina como parte da criptografia de uma mensagem e pode verificar na descriptografia quando você fornece o material de chave pública do remetente. ### 3. Chave da conversa **Propósito:** criptografar e descriptografar mensagens (e [mídia](/pt/xchat/media)) dentro de uma conversa específica | Propriedade | Descrição | | :------------------------------------ | :--------------------------------------------------------------------------------- | | **Simétrica** | A mesma chave criptografa e descriptografa | | **Por conversa** | Cada conversa tem sua própria chave | | **Compartilhada entre participantes** | Todos os participantes que devem ler a conversa têm uma cópia | | **Versionada** | As chaves podem ser rotacionadas; os apps devem rastrear versões ao longo do tempo | As chaves de conversa são geradas quando uma conversa é configurada ou quando as chaves são rotacionadas. Cada participante recebe uma **cópia criptografada** da chave, produzida com sua chave pública de identidade. Depois de descriptografar sua cópia uma vez, você guarda a chave da conversa em **bruto** e a usa para criptografia rápida de mensagens (e [mídia](/pt/xchat/media)). A configuração dessas cópias para uma conversa é feita por meio do Chat XDK juntamente com os endpoints de **chave** de conversa — abordados em [Primeiros passos](/pt/xchat/getting-started#4-set-up-conversation-keys). *** ## Como a criptografia funciona (conceitualmente) ### Enviando uma mensagem Você digita: "Olá, tudo bem?" Seu app usa a chave da conversa em bruto para este chat (obtida na configuração ou em um evento anterior de distribuição de chaves), para a versão de chave correta. O Chat XDK criptografa sua mensagem com a chave da conversa. O resultado é texto cifrado que é inútil sem essa chave. O Chat XDK assina o payload criptografado com sua chave privada de assinatura, provando que você é o autor deste conteúdo exato. Seu app envia o payload criptografado e a assinatura para o X por meio do endpoint **send message** da Chat API. O X armazena e entrega bytes que ele não consegue ler em texto simples. ### Recebendo uma mensagem Seu app recebe texto cifrado do X — via [webhooks ou um activity stream](/pt/xchat/real-time-events), ou lendo os **eventos** da conversa para obter o histórico. Use sua chave em bruto em cache, ou obtenha-a descriptografando sua cópia a partir de um evento de distribuição de chave (mudança de chave), caso seja nova ou tenha sido rotacionada. O Chat XDK verifica a assinatura usando a chave pública de assinatura do remetente (e a vinculação de identidade relacionada), para que você saiba quem a enviou e que ela não foi modificada. O Chat XDK descriptografa com a chave da conversa. Agora você pode ler: "Olá, tudo bem?" A implementação de criptografia, envio, recebimento e descriptografia está em [Primeiros passos](/pt/xchat/getting-started) e na referência do [Chat XDK](/pt/xchat/xchat-xdk). *** ## Distribuição de chaves explicada Um desafio central em criptografia de ponta a ponta é a **distribuição de chaves**: como os participantes obtêm a chave da conversa **sem** que o X (ou um observador) veja essa chave em texto claro. ### Configuração inicial da chave Quando uma conversa é preparada para envio de mensagens: 1. O Chat XDK gera uma chave de conversa aleatória 2. O Chat XDK criptografa essa chave para a **chave pública de identidade de cada participante** 3. Seu app publica essas cópias criptografadas por meio das APIs de Chat do X 4. Cada participante descriptografa **sua** cópia com sua chave privada de identidade (no Chat XDK) O X só lida com as cópias **empacotadas**, nunca com a chave da conversa em bruto. ### Eventos de mudança de chave Quando a chave da conversa é rotacionada (por exemplo, quando a composição do grupo muda), os participantes recebem um evento de **mudança de chave** com novas cópias criptografadas para cada membro. Seu app deve: 1. Notar material de mudança de chave em eventos ao vivo ou no histórico da conversa 2. Descriptografar e armazenar a nova chave da conversa (e a versão) 3. Usar a versão mais recente para envios subsequentes [Primeiros passos](/pt/xchat/getting-started#6-receive-and-decrypt) e [Eventos em tempo real](/pt/xchat/real-time-events) descrevem onde esses eventos aparecem na prática. *** ## Backup seguro de chave: armazenamento distribuído de chaves Suas chaves **privadas** de identidade e assinatura devem ser armazenadas com cuidado. O X Chat inclui um sistema de **backup seguro de chave** para que as chaves possam ser recuperadas com um código de acesso entre dispositivos, sem que nenhum servidor detenha o segredo completo. ### O problema com o armazenamento tradicional de chaves | Abordagem | Problema | | :------------------------------------ | :---------------------------------------------------------------------------------- | | Armazenar apenas no dispositivo | Perder o dispositivo = perder as chaves = perder o acesso ao histórico de mensagens | | Armazenar em um backup em nuvem comum | O provedor pode acessar o material da chave | | Lembrar uma chave longa | As pessoas não conseguem memorizar de forma confiável chaves de alta entropia | ### Como o backup seguro de chave resolve isso O backup seguro de chave combina **compartilhamento de segredo** com **proteção por código de acesso**: 1. As chaves privadas são **divididas em partes (shares)** 2. As partes são mantidas por **realms independentes** (servidores separados) 3. **Nenhum realm sozinho** tem informação suficiente para reconstruir as chaves 4. A recuperação exige seu **código de acesso** e a cooperação de **realms suficientes** 5. Códigos incorretos têm **limitação de taxa** para retardar tentativas ```mermaid theme={null} flowchart LR A[Your Private Keys] --> B[Split into Shares] B --> C[Realm 1
Share A] B --> D[Realm 2
Share B] B --> E[Realm 3
Share C] subgraph Recovery F[Your Passcode + Multiple Realms] --> G[Reconstruct Keys] end ``` Você obtém capacidade de recuperação (novo dispositivo + código de acesso) sem que um único participante detenha o segredo inteiro. Você não configura os servidores de backup de chave manualmente no caminho normal. O Chat XDK inclui o cliente de backup; a configuração dos realms vem da API do X pelo campo **`juicebox_config`** do seu registro de chave pública. O armazenamento inicial do código de acesso e o desbloqueio posterior são chamadas do Chat XDK — veja [inicializar com chaves existentes](/pt/xchat/getting-started#2-initialize-the-chat-xdk-with-existing-keys) e [criar e registrar chaves](/pt/xchat/getting-started#3-create-and-register-keys-first-time-setup) em Primeiros passos. Alguns apps (especialmente servidores e bots) usam um blob de chave exportado em vez do backup seguro de chave; proteja esse material como uma senha. *** ## Assinaturas explicadas Toda mensagem do X Chat inclui uma **assinatura digital** que apoia: 1. **Autenticidade** — foi produzida com a chave privada de assinatura do remetente 2. **Integridade** — o conteúdo criptografado não foi modificado após a assinatura ### Como as assinaturas funcionam (conceitualmente) | Ação | Chave usada | Resultado | | :------------ | :--------------------------------------- | :----------------------------------------------------------- | | **Assinar** | Chave privada de assinatura do remetente | Uma assinatura vinculada a esta mensagem criptografada exata | | **Verificar** | Chave pública de assinatura do remetente | Confirma que a assinatura corresponde à mensagem e à chave | Se qualquer coisa no material assinado mudar, a verificação falha. Apenas alguém com a chave privada de assinatura pode produzir uma assinatura válida para essa chave. ### No seu app O Chat XDK assina quando você criptografa mensagens de saída e verifica quando descriptografa as de entrada, comparando com o material de chave pública do remetente (das APIs de chave pública). A verificação é **obrigatória por padrão**: o SDK rejeita eventos assinados não verificados, a menos que você desabilite explicitamente a checagem (não recomendado). Detalhes estão na referência do [Chat XDK](/pt/xchat/xchat-xdk). As assinaturas também cobrem conteúdo citado. Uma resposta incorpora a mensagem original **assinada** em bruto que ela cita; quando o Chat XDK descriptografa a resposta, ele verifica essa original incorporada e compara a citação com ela, reportando o resultado como `reply_preview_validation` (`Valid` / `Invalid`). Um resultado `Invalid` significa que a citação não corresponde ao original assinado — trate o material citado como não confiável, mesmo que a resposta em si seja verificada separadamente — para que nenhum participante possa atribuir palavras falsas a outro. ### Mudanças de estado assinadas (assinaturas de ação) Mensagens não são o único material assinado. Toda chamada que muda o estado da conversa — adicionar ou rotacionar chaves de conversa, criar um grupo, adicionar membros — deve carregar uma ou mais **assinaturas de ação**: o remetente assina um payload descrevendo exatamente o que a mudança faz (para uma mudança de chave, esse payload inclui a própria nova chave da conversa), e a API rejeita a solicitação se as assinaturas estiverem ausentes ou malformadas. Como o servidor nunca detém a chave da conversa em texto claro, ele não pode verificar criptograficamente a assinatura de uma mudança de chave; ele valida que a descrição assinada e codificada da mudança corresponde à solicitação recebida. A verificação **criptográfica** acontece nas extremidades: o Chat XDK de cada destinatário verifica a assinatura contra a chave pública de assinatura do remetente ao descriptografar o evento de mudança de chave. Os métodos `prepare` do Chat XDK produzem essas assinaturas para você — criação de grupo e adição de membros retornam **duas** (a mudança de chave mais a ação de grupo), e ambas devem ser enviadas. As assinaturas são vinculadas ao conteúdo do evento e são imutáveis: um evento cuja assinatura não verifica nunca poderá se tornar válido depois. Veja [Solução de problemas](/pt/xchat/troubleshooting) para saber como lidar com esses casos. *** ## Propriedades de segurança ### Contra o que o X Chat protege | Ameaça | Proteção | | :------------------------------------------------------------------- | :--------------------------------------------------------------------- | | **O X ler o corpo das mensagens** | O conteúdo é criptografado antes de ser enviado ao X | | **Interceptadores de rede** | Segurança de transporte mais conteúdo criptografado de ponta a ponta | | **Adulteração de mensagens** | Assinaturas detectam modificação | | **Falsificação trivial de remetente** | Assinaturas válidas exigem a chave privada de assinatura do remetente | | **Roubo de chave em um único servidor (com backup seguro de chave)** | As partes são divididas entre realms e protegidas por código de acesso | ### Contra o que o X Chat **não** protege | Ameaça | Por quê | | :---------------------------------- | :------------------------------------------------------------------------------------------ | | **Dispositivo comprometido** | Texto simples e chaves podem ser expostos em um cliente desbloqueado | | **Metadados** | O X pode saber quem enviou mensagens para quem e quando — não o texto da mensagem | | **Sigilo futuro (forward secrecy)** | Comprometer chaves de identidade pode expor chaves de conversa empacotadas com essas chaves | | **Segurança pós-comprometimento** | Rotacionar chaves não reescreve o histórico | *** ## Glossário | Termo | Definição | | :------------------------------ | :----------------------------------------------------------------------------------------------- | | **Criptografia simétrica** | A mesma chave criptografa e descriptografa (usada para mensagens e fluxos de mídia) | | **Criptografia assimétrica** | Chaves diferentes para criptografar e descriptografar (usada para trocar chaves de conversa) | | **Chave pública** | Segura para compartilhar; usada para criptografar *para* alguém ou verificar suas assinaturas | | **Chave privada** | Deve permanecer secreta; usada para descriptografar ou assinar | | **Par de chaves (keypair)** | Uma chave pública e uma chave privada vinculadas | | **ECDH / ECIES** | Algoritmos usados ao trocar chaves de conversa via chaves de identidade | | **ECDSA** | Algoritmo de assinatura usado para autoria de mensagens | | **P-256** | Curva elíptica usada no X Chat (secp256r1) | | **Chave da conversa** | Chave simétrica compartilhada pelos participantes de uma conversa (versionada ao longo do tempo) | | **Compartilhamento de segredo** | Dividir um segredo de modo que várias partes sejam necessárias para reconstruí-lo | | **Realm** | Um servidor de backup seguro de chave independente que detém uma parte do seu material de chave | *** ## Próximos passos Implemente chaves, envio e recebimento passo a passo Métodos e tipos do SDK de criptografia Visão geral do produto e arquitetura Como os eventos criptografados são entregues