| Data de elaboração | 12/06/2026 |
| Responsável pelo estudo | João Pedro Rocha Brito |
| Equipe do estudo | Liderança Técnica |
| Alvo | Autenticação do Sauron |
| Origem | Atualização de versionamento de bibliotecas do Sauron |
| Objetivo | O presente estudo visa documentar como migrar de um fluxo Implicit (onde você recebe o id_token direto) para um fluxo Authorization Code com PKCE |
| Documentação correlata | |
| Observações | |
O PKCE exige a geração de um code_verifier (uma string aleatória) e um code_challenge (o hash SHA256 dessa string).
private function generate_pkce_codes()
{
// 1. Criar um verifier aleatório (entre 43 e 128 caracteres)
$verifier = bin2hex(random_bytes(32));
// 2. Criar o challenge (SHA256 do verifier, em Base64Url sem padding)
$hash = hash('sha256', $verifier, true);
$challenge = str_replace(['+', '/', '='], ['-', '_', ''], base64_encode($hash));
return [
'verifier' => $verifier,
'challenge' => $challenge
];
}
get_login_urlVocê deve alterar o response_type para code e incluir o challenge. Importante: você precisa salvar o verifier na sessão para usá-lo depois.
public function get_login_url()
{
$app_url = preg_replace('/\/+$/', '', $this->ci->config->config['base_url']);
// Gerar PKCE
$pkce = $this->generate_pkce_codes();
// Salvar o verifier na sessão (CodeIgniter style)
$this->ci->session->set_userdata('oidc_verifier', $pkce['verifier']);
$params = [
'client_id' => $this->sauron_client_id,
'redirect_uri' => "{$app_url}/signin-oidc",
'response_type' => 'code', // Alterado de id_token para code
'scope' => 'openid profile email', // Adicione escopos necessários
'code_challenge' => $pkce['challenge'],
'code_challenge_method' => 'S256',
'nonce' => bin2hex(random_bytes(16)),
'state' => bin2hex(random_bytes(16)), // Recomendado para segurança
];
return $this->sauron_web_url . '/connect/authorize?' . http_build_query($params);
}
No fluxo de code, o Sauron redirecionará o usuário de volta para sua redirect_uri com um parâmetro ?code=.... Você precisará de um método para capturar esse código e enviar o code_verifier para obter os tokens reais.
public function exchange_code_for_token($code)
{
$app_url = preg_replace('/\/+$/', '', $this->ci->config->config['base_url']);
// Recuperar o verifier salvo no passo anterior
$verifier = $this->ci->session->userdata('oidc_verifier');
$response = $this->http_client_sauron->post('/connect/token', [
'grant_type' => 'authorization_code',
'client_id' => $this->sauron_client_id,
'code' => $code,
'redirect_uri' => "{$app_url}/signin-oidc",
'code_verifier' => $verifier, // O segredo que valida o PKCE
]);
if ($response->error) {
throw new Exception('Falha ao trocar o code pelo token');
}
// Aqui você terá access_token, id_token e possivelmente refresh_token
return $response->data;
}
Segurança: o id_token não viaja mais pela URL ou via form_post diretamente do navegador para a aplicação. O que trafega é um code temporário e inútil sem o code_verifier.
State: recomenda-se fortemente adicionar o parâmetro state para evitar ataques CSRF.
Back-channel: a troca do código pelo token acontece «por debaixo dos panos» (server-to-server), o que é significativamente mais seguro.
Quando o Sauron redirecionar o usuário para:
https://seuapp.com/signin-oidc?code=XYZ
o controller poderá realizar a troca do código pelos tokens da seguinte forma:
public function signin_oidc()
{
$code = $this->input->get('code');
if ($code) {
$tokens = $this->sauron_service->exchange_code_for_token($code);
// Salve os tokens na sessão e logue o usuário
}
}
Você já possui uma biblioteca de HTTPClient configurada. Portanto, basta garantir que o endpoint /connect/token (ou o equivalente no Sauron) esteja acessível via requisições POST.
A adoção do fluxo Authorization Code com PKCE representa uma evolução importante na segurança do processo de autenticação da aplicação. Com essa abordagem, os tokens deixam de ser expostos diretamente ao navegador, passando a ser obtidos por meio de uma comunicação segura entre a aplicação e o provedor de identidade.
Além disso, a utilização do code_verifier e do code_challenge reduz significativamente os riscos de interceptação e reutilização indevida do código de autorização, enquanto o uso do parâmetro state contribui para a proteção contra ataques do tipo CSRF.
Dessa forma, para concluir a implementação, é necessário realizar três adequações principais: gerar e armazenar os dados do PKCE durante a solicitação de autenticação, alterar o fluxo de login para utilizar response_type=code e implementar a troca do código de autorização pelos tokens no retorno da redirect_uri. Com essas alterações, a integração com o Sauron estará alinhada às práticas modernas recomendadas pelo protocolo OpenID Connect, proporcionando maior segurança e confiabilidade ao processo de autenticação dos usuários.