@hed-hog/core 0.0.399 → 0.0.401

package/src/authorize/authorize.controller.ts

@@ -4,16 +4,23 @@ import {
   Body,
   Controller,
   Get,
+  Header,
   Headers,
   Inject,
   Ip,
   Post,
   Query,
+  Res,
+  UseFilters,
   UseGuards,
   forwardRef,
 } from '@nestjs/common';
 import { Throttle, ThrottlerGuard } from '@nestjs/throttler';
+import type { Response } from 'express';
+import { OAuthError } from './authorize.errors';
 import { AuthorizeService } from './authorize.service';
+import { OAuthMetadataService } from './oauth-metadata.service';
+import { OAuthExceptionFilter } from './oauth-exception.filter';
 import { AuthorizeInfoDTO } from './dto/authorize-info.dto';
 import { ConsentDTO } from './dto/consent.dto';
 import { TokenDTO } from './dto/token.dto';
@@ -21,18 +28,87 @@ import { TokenDTO } from './dto/token.dto';
 /**
  * Endpoints do fluxo Authorization Code + PKCE.
  *
- * Note o que NÃO existe aqui: um `GET /auth/authorize` que redireciona. O
- * redirect final é feito pelo browser, na página de consent do admin, depois do
- * POST /auth/authorize/consent. Assim toda a validação fica no servidor e o
- * `code` não passa pelo mecanismo de redirect do Nest (nem pelos seus logs).
+ * O `GET /auth/authorize` daqui NÃO emite o `code`: ele valida e redireciona para
+ * a tela de consent do admin, que é quem faz o redirect final depois do
+ * `POST /auth/authorize/consent`. A restrição original continua valendo — o
+ * `code` nunca passa pelo mecanismo de redirect do Nest, nem pelos seus logs.
+ *
+ * Ele existe porque um cliente OAuth padrão (o conector do Claude) espera um
+ * `authorization_endpoint` na mesma origem do `issuer`, e porque a validação de
+ * `response_type`, `scope` e `resource` tem que acontecer no servidor, antes de
+ * qualquer render — um erro precisa voltar como `error=` na query, e não como uma
+ * tela morta.
  */
 @Controller('auth')
 export class AuthorizeController {
   constructor(
     @Inject(forwardRef(() => AuthorizeService))
     private readonly service: AuthorizeService,
+    @Inject(forwardRef(() => OAuthMetadataService))
+    private readonly metadata: OAuthMetadataService,
   ) {}
 
+  /**
+   * O authorization endpoint anunciado nos metadados.
+   *
+   * A ordem de validação é normativa (RFC 6749 §4.1.2.1): `client_id` e
+   * `redirect_uri` primeiro, e falha neles NÃO redireciona — sem um redirect_uri
+   * validado, redirecionar seria mandar o usuário para onde o atacante pediu.
+   * Tudo o mais volta para o cliente como `error` na query.
+   */
+  @Public()
+  @UseGuards(ThrottlerGuard)
+  @Throttle({ default: { limit: 30, ttl: 60000 } })
+  @UseFilters(OAuthExceptionFilter)
+  @Get('authorize')
+  async authorize(@Query() query: AuthorizeInfoDTO, @Res() res: Response) {
+    try {
+      await this.service.getAuthorizationInfo({
+        clientId: query.client_id,
+        redirectUri: query.redirect_uri,
+        scope: query.scope,
+        codeChallenge: query.code_challenge,
+        codeChallengeMethod: query.code_challenge_method,
+        responseType: query.response_type,
+        resource: query.resource,
+      });
+    } catch (error) {
+      if (error instanceof OAuthError && error.redirectable) {
+        return res.redirect(
+          302,
+          await this.buildErrorRedirect(query, error),
+        );
+      }
+      throw error;
+    }
+
+    // Só parâmetros validados seguem para a tela. O `code` é emitido lá, pelo
+    // consent, e volta por um redirect do browser — não por este.
+    const consentBase = await this.metadata.getConsentUiBase();
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== undefined && value !== null && value !== '') {
+        params.set(key, String(value));
+      }
+    }
+
+    return res.redirect(302, `${consentBase}/auth/authorize?${params.toString()}`);
+  }
+
+  private async buildErrorRedirect(
+    query: AuthorizeInfoDTO,
+    error: OAuthError,
+  ): Promise<string> {
+    const target = new URL(query.redirect_uri);
+    target.searchParams.set('error', error.code);
+    target.searchParams.set('error_description', error.description);
+    if (query.state) target.searchParams.set('state', query.state);
+    // RFC 9207: vai também no erro, e o cliente valida antes de exibir qualquer
+    // coisa. Anunciamos `authorization_response_iss_parameter_supported`.
+    target.searchParams.set('iss', await this.metadata.getIssuer());
+    return target.toString();
+  }
+
   /**
    * Metadados para a tela de consent. Público: a página precisa validar os
    * parâmetros e mostrar de quem é o app ANTES de exigir login.
@@ -42,13 +118,32 @@ export class AuthorizeController {
   @Throttle({ default: { limit: 30, ttl: 60000 } })
   @Get('authorize/info')
   async authorizeInfo(@Query() query: AuthorizeInfoDTO) {
-    return this.service.getAuthorizationInfo({
-      clientId: query.client_id,
-      redirectUri: query.redirect_uri,
-      scope: query.scope,
-      codeChallenge: query.code_challenge,
-      codeChallengeMethod: query.code_challenge_method,
-    });
+    try {
+      return await this.service.getAuthorizationInfo({
+        clientId: query.client_id,
+        redirectUri: query.redirect_uri,
+        scope: query.scope,
+        codeChallenge: query.code_challenge,
+        codeChallengeMethod: query.code_challenge_method,
+        responseType: query.response_type,
+        resource: query.resource,
+      });
+    } catch (error) {
+      // Erro redirecionável volta para o cliente pelas mãos da tela, e o RFC 9207
+      // exige `iss` também nele. Mas a tela só aprende o issuer no caminho de
+      // SUCESSO desta chamada — num erro ela redirecionaria sem o parâmetro, e um
+      // cliente que o valide (nós anunciamos suportá-lo) rejeita a resposta
+      // inteira. Então o issuer viaja junto do erro.
+      if (error instanceof OAuthError && error.redirectable) {
+        throw new OAuthError(
+          error.code,
+          error.description,
+          true,
+          await this.metadata.getIssuer(),
+        );
+      }
+      throw error;
+    }
   }
 
   /** O usuário logado aprova. O code sai vinculado a ele. */
@@ -64,6 +159,8 @@ export class AuthorizeController {
       scope: body.scope,
       codeChallenge: body.code_challenge,
       codeChallengeMethod: body.code_challenge_method,
+      responseType: body.response_type,
+      resource: body.resource,
     });
 
     return { code };
@@ -79,6 +176,11 @@ export class AuthorizeController {
   @Public()
   @UseGuards(ThrottlerGuard)
   @Throttle({ default: { limit: 20, ttl: 60000 } })
+  @UseFilters(OAuthExceptionFilter)
+  // RFC 6749 5.1: a resposta carrega credenciais e nao pode ser cacheada. O
+  // filtro ja poe isto nos erros; aqui vale para o sucesso.
+  @Header('Cache-Control', 'no-store')
+  @Header('Pragma', 'no-cache')
   @Post('token')
   async token(
     @Body() body: TokenDTO,
@@ -87,11 +189,24 @@ export class AuthorizeController {
     @Headers('user-agent') userAgent: string,
     @Headers('x-browser-id') browserId: string,
   ) {
+    if (body.grant_type === 'refresh_token') {
+      return this.service.exchangeRefreshToken({
+        refreshToken: body.refresh_token,
+        clientId: body.client_id,
+        resource: body.resource,
+        locale,
+        ipAddress,
+        userAgent,
+        browserId: browserId || null,
+      });
+    }
+
     return this.service.exchangeCode({
       code: body.code,
       codeVerifier: body.code_verifier,
       clientId: body.client_id,
       redirectUri: body.redirect_uri,
+      resource: body.resource,
       locale,
       ipAddress,
       userAgent,

package/src/authorize/authorize.errors.ts

@@ -0,0 +1,55 @@
+import { BadRequestException } from '@nestjs/common';
+
+/**
+ * Códigos de erro do RFC 6749 §4.1.2.1 e §5.2, mais o `invalid_target` do
+ * RFC 8707.
+ */
+export type OAuthErrorCode =
+  | 'invalid_request'
+  | 'invalid_client'
+  | 'invalid_grant'
+  | 'unauthorized_client'
+  | 'unsupported_grant_type'
+  | 'unsupported_response_type'
+  | 'invalid_scope'
+  | 'invalid_target'
+  | 'access_denied'
+  | 'login_required'
+  | 'server_error';
+
+/**
+ * Erro do fluxo OAuth.
+ *
+ * `redirectable` decide o que acontece com ele, e a distinção é normativa
+ * (RFC 6749 §4.1.2.1): erro de `client_id` ou de `redirect_uri` **não** pode
+ * voltar para o `redirect_uri` — se ele não foi validado, redirecionar seria
+ * mandar o usuário para onde o atacante pediu. Todo o resto volta para o cliente
+ * como `error` na query, que é como ele descobre o que fez de errado.
+ */
+export class OAuthError extends BadRequestException {
+  // Herda de BadRequestException, e nao de HttpException direto: todo erro OAuth
+  // de requisicao e um 400, e manter a hierarquia preserva qualquer `catch` que
+  // ja exista para BadRequestException — inclusive os testes que descrevem o
+  // comportamento anterior.
+  constructor(
+    readonly code: OAuthErrorCode,
+    readonly description: string,
+    readonly redirectable = false,
+    /**
+     * Só acompanha erro redirecionável: é o `iss` que a tela precisa devolver ao
+     * cliente junto do erro (RFC 9207). No caminho de sucesso ela já o recebe em
+     * `getAuthorizationInfo`.
+     */
+    readonly issuer?: string,
+  ) {
+    super({
+      error: code,
+      error_description: description,
+      redirectable,
+      ...(issuer ? { issuer } : {}),
+      // `message` fica junto porque os clientes ja registrados leem esse campo
+      // nas respostas de erro de hoje. Tirar seria uma quebra silenciosa.
+      message: description,
+    });
+  }
+}

package/src/authorize/authorize.module.ts

@@ -2,8 +2,11 @@ import { PrismaModule } from '@hed-hog/api-prisma';
 import { Module, forwardRef } from '@nestjs/common';
 import { AuthModule } from '../auth/auth.module';
 import { SecurityModule } from '../security/security.module';
+import { SessionModule } from '../session/session.module';
+import { TokenModule } from '../token/token.module';
 import { AuthorizeController } from './authorize.controller';
 import { AuthorizeService } from './authorize.service';
+import { WellKnownController } from './well-known.controller';
 
 /**
  * Separado de OAuthModule de propósito: lá o HedHog é *client* de IdPs externos
@@ -15,8 +18,10 @@ import { AuthorizeService } from './authorize.service';
     forwardRef(() => PrismaModule),
     forwardRef(() => SecurityModule),
     forwardRef(() => AuthModule),
+    forwardRef(() => SessionModule),
+    forwardRef(() => TokenModule),
   ],
-  controllers: [AuthorizeController],
+  controllers: [AuthorizeController, WellKnownController],
   providers: [AuthorizeService],
   exports: [AuthorizeService],
 })