OAuth PKCE na Deriv: como funciona a conexão segura
Quando um aplicativo de trading pede para "conectar a sua conta Deriv", a pergunta certa não é só "é seguro?", mas "seguro contra o quê?". O fluxo OAuth com PKCE responde a uma parte bem específica dessa pergunta: ele impede que alguém que intercepte o retorno da autorização consiga transformar esse retorno em acesso à sua conta.
Este artigo explica, de forma técnica mas direta, como o OAuth PKCE na Deriv funciona, quais parâmetros aparecem na URL, onde ficam os segredos temporários e o que o PKCE não resolve. Se você quer a visão geral do OAuth antes, leia OAuth da Deriv: como funciona.
O problema que o PKCE resolve
No OAuth 2.0 com "authorization code", o fluxo básico é:
- O app redireciona você para a página de login da corretora.
- Você entra e autoriza o app.
- A corretora redireciona de volta para o app com um código de autorização na URL.
- O app troca esse código por credenciais de acesso.
O ponto fraco está no passo 3. O código viaja pela URL e pode vazar: por extensões do navegador, histórico, logs de proxy, apps maliciosos registrados no mesmo esquema de URL em celulares, entre outros. Sem proteção extra, quem pegasse esse código poderia tentar fazer a troca do passo 4 no lugar do app legítimo.
O PKCE (Proof Key for Code Exchange, definido na RFC 7636) acrescenta uma prova: só quem iniciou o fluxo consegue concluir a troca.
Como o PKCE funciona, peça por peça
code_verifier
Antes de redirecionar você para a Deriv, o app gera um valor aleatório longo, o code_verifier. Ele fica guardado localmente e não é enviado na primeira requisição.
code_challenge e o método S256
A partir do verifier, o app calcula o code_challenge: aplica SHA-256 ao verifier e codifica o resultado em Base64 URL-safe (sem os sinais de "=" no final). Esse challenge, junto com code_challenge_method=S256, vai na URL de autorização.
Como SHA-256 é uma função de mão única, quem vê o challenge não consegue descobrir o verifier.
state
Além do PKCE, o fluxo usa o parâmetro state, outro valor aleatório. Quando a Deriv redireciona de volta, ela devolve o mesmo state, e o app confere se ele bate com o que foi gerado. Isso protege contra ataques do tipo CSRF, em que alguém tenta encaixar uma autorização que você não iniciou.
A troca do código
No retorno, o app recebe o code e o state. Ele envia o código junto com o code_verifier original para a troca. O servidor de autorização recalcula o SHA-256 do verifier e compara com o challenge recebido no início. Se não bater, a troca é recusada. Um código interceptado, sozinho, não serve para nada.
Como isso aparece na prática
A URL de autorização de um app que usa PKCE com a Deriv tem, em geral, este formato (valores de exemplo):
https://auth.deriv.com/oauth2/auth
?response_type=code
&client_id=SEU_APP_ID
&redirect_uri=https://seuapp.com/callback
&scope=trade
&state=AbC123...
&code_challenge=Xyz789...
&code_challenge_method=S256Alguns detalhes de implementação que valem atenção:
- redirect_uri registrado: a Deriv só devolve o código para o endereço cadastrado para aquele app. Por isso o fluxo precisa começar no domínio oficial do aplicativo.
- Caracteres do state: na prática, usar só letras e números no state e no verifier evita rejeições do servidor de autorização com valores considerados fracos ou malformados.
- Armazenamento temporário: guardar verifier e state em
sessionStoragefaz com que eles durem só aquela aba e aquela sessão de navegação. - Troca no backend: fazer a troca do código no servidor, e não no navegador, mantém as credenciais resultantes longe do JavaScript da página.
Como o Codexium usa esse fluxo
No Codexium, o botão de conectar a Deriv segue exatamente esse desenho: o app gera um code_verifier aleatório e um state, calcula o code_challenge com SHA-256 (método S256), guarda os dois valores temporários na sessão do navegador e redireciona para a página oficial de autorização da Deriv. No retorno, o código e o verifier vão para o backend do Codexium, que faz a troca. Você nunca digita a sua senha da Deriv no Codexium.
Os escopos pedidos aparecem na tela de autorização da própria Deriv antes de você confirmar. Leia sempre essa lista. Para entender o que cada permissão significa, veja permissões do token de API da Deriv.
O que o PKCE não protege
PKCE é uma camada importante, mas é só uma camada. Ele não protege contra:
- Phishing: se você autorizar um app falso numa página falsa, o fluxo funciona perfeitamente para o atacante. Confira sempre o domínio da página de login.
- Conta Deriv comprometida: se alguém já tem a sua senha, o PKCE do app não muda nada. Ative a autenticação em dois fatores, como explicado em segurança da conta Deriv com 2FA.
- App mal-intencionado legítimo: PKCE prova que quem conclui o fluxo é quem o iniciou. Ele não diz nada sobre a intenção do app. Escolha ferramentas que você conhece.
- Risco das operações: autorização segura não tem relação com resultado. Um robô conectado corretamente pode perder dinheiro do mesmo jeito.
Revogar o acesso quando quiser
Uma vantagem do OAuth sobre colar tokens manualmente é que a autorização fica visível e revogável no painel da Deriv. Se você deixar de usar um app, revogue o acesso. O passo a passo está em como revogar token na Deriv. Se você ainda usa token de API colado manualmente, compare com o guia de conectar a conta Deriv com token de API com segurança.
Checklist técnico para quem desenvolve
- Gere code_verifier com fonte criptográfica (
crypto.getRandomValues), com comprimento entre 43 e 128 caracteres. - Use sempre
code_challenge_method=S256, nuncaplain. - Gere e valide o state em todo retorno.
- Comece o fluxo no domínio do redirect_uri registrado.
- Faça a troca do código no backend e não exponha credenciais ao navegador.
- Limpe verifier e state depois da troca.
- Peça só os escopos de que o app realmente precisa.
Conectar a Deriv ao Codexium
Se você quer automatizar operações com uma conexão feita pela autorização oficial da Deriv, o Codexium usa o fluxo descrito acima. Comece pela conta demonstrativa, configure limites de sessão e só depois avalie se faz sentido continuar.
Conecte a Deriv com segurança
Crie sua conta no Codexium e conecte a Deriv pela autorização oficial com PKCE. Teste primeiro na conta demo.
Perguntas frequentes
O que significa PKCE?
Proof Key for Code Exchange. É uma extensão do OAuth 2.0, definida na RFC 7636, que liga a troca do código de autorização a um segredo temporário criado por quem iniciou o fluxo.
A Deriv usa OAuth com PKCE?
Sim. O servidor de autorização da Deriv aceita o fluxo com code_challenge e o método S256, e é assim que o Codexium conecta a conta.
Qual a diferença entre S256 e plain?
No S256, o challenge é o SHA-256 do verifier, então quem o vê não descobre o segredo. No plain, o challenge é o próprio verifier, o que oferece muito menos proteção.
Preciso informar minha senha da Deriv ao app?
Não. No OAuth você digita a senha apenas na página oficial da Deriv. O app recebe um código que só ele consegue trocar.
PKCE deixa meu robô mais lucrativo?
Não. PKCE protege a forma de conexão, não o resultado das operações. Robôs de trading podem perder todo o capital utilizado.
