Como proteger seu app com cabeçalhos assinados

Nesta página, você aprenderá como proteger seu app com cabeçalhos assinados pelo IAP. Quando configurado, o Identity-Aware Proxy (IAP) usa JSON Web Tokens (JWT) para garantir que qualquer solicitação direcionada ao app seja autorizada. Isso protege o aplicativo dos seguintes tipos de riscos:

  • IAP acidentalmente desativado
  • Firewalls mal configurados
  • Acesso a partir do projeto

Para proteger adequadamente seu app, seja ele de qualquer tipo, você precisa usar cabeçalhos assinados.

Como alternativa, se você tiver um aplicativo do ambiente padrão do App Engine, a API Users poderá ser usada.

As verificações de integridade do Compute Engine e do GKE não incluem os cabeçalhos JWT. Além disso, o IAP não processa verificações de integridade. Se a verificação de integridade retornar erros de acesso, certifique-se de que você a configurou corretamente no Console do Cloud e que o caminho dela está incluído na lista de permissões da validação do cabeçalho JWT. Para mais informações, consulte Como criar uma exceção de verificação de integridade.

Antes de começar

Para proteger o aplicativo com cabeçalhos assinados, você precisará do seguinte:

Como proteger seu app com cabeçalhos do IAP

Para proteger seu app com o JWT do IAP, verifique o cabeçalho, o payload e a assinatura do JWT. O JWT está no cabeçalho de solicitação HTTP x-goog-iap-jwt-assertion. Se um invasor evadir o IAP, ele poderá forjar os cabeçalhos de identidade x-goog-authenticated-user-{email,id} não assinados pelo IAP. O JWT do IAP é uma alternativa mais segura.

Os cabeçalhos assinados proporcionam uma camada secundária de segurança caso alguém desvie do IAP. Quando ativado, o IAP remove os cabeçalhos x-goog-* fornecidos pelo cliente sempre que as solicitações passam pela infraestrutura de exibição desse recurso.

Como verificar o cabeçalho do JWT

Verifique se o cabeçalho do JWT está em conformidade com as seguintes restrições:

Declarações do cabeçalho JWT
alg Algoritmo ES256
kid ID da chave Precisa corresponder a uma das chaves públicas listadas no arquivo de chave do IAP, disponível em dois formatos diferentes: https://www.gstatic.com/iap/verify/public_key e https://www.gstatic.com/iap/verify/public_key-jwk.

Certifique-se de que o JWT foi assinado pela chave privada que corresponda à declaração kid do token. Para fazer isso, primeiro consiga a chave pública de um destes dois locais:

  • https://www.gstatic.com/iap/verify/public_key: este URL contém um dicionário JSON que mapeia as declarações kid para os valores de chave pública.
  • https://www.gstatic.com/iap/verify/public_key-jwk: este URL contém as chaves públicas do IAP no formato JWK (em inglês).

Depois de conseguir a chave pública, use uma biblioteca de JWT para verificar a assinatura.

Como verificar o payload do JWT

Verifique se o payload do JWT está em conformidade com as seguintes restrições:

Declarações de payload do JWT
exp Tempo de expiração Precisa estar no futuro. O tempo é medido em segundos desde a era UNIX. Defina 30 segundos para a defasagem. A vida útil máxima de um token é de 10 minutos + 2 * distorção.
iat Hora de emissão Precisa estar no passado. O tempo é medido em segundos desde a era UNIX. Defina 30 segundos para a defasagem.
aud Público-alvo Precisa ser uma string com os seguintes valores:
  • App Engine: /projects/PROJECT_NUMBER/apps/PROJECT_ID
  • Compute Engine e GKE: /projects/PROJECT_NUMBER/global/backendServices/SERVICE_ID
iss Emissor Precisa ser https://cloud.google.com/iap.
hd Domínio da conta Se uma conta pertencer a um domínio hospedado, a declaração hd será fornecida para diferenciar o domínio a que a conta está associada.
google Declaração do Google Se um ou mais níveis de acesso se aplicarem à solicitação, os nomes deles serão armazenados no objeto JSON da declaração google, na chave access_levels, como uma matriz de strings.

Para conseguir os valores da string aud mencionada acima, acesse o Console do Cloud ou use a ferramenta de linha de comando gcloud.

Para conseguir os valores da string aud no Console do Cloud, acesse as configurações do Identity-Aware Proxy do seu projeto, clique em Maisao lado do recurso Balanceador de carga e selecione Público-alvo do JWT com cabeçalho assinado. A caixa de diálogo JWT com cabeçalho assinado exibida mostra a declaração auddo recurso selecionado.

Menu flutuante com a opção

Se você quiser usar a ferramenta de linha de comando gcloud no SDK do Cloud para conseguir os valores da string aud, precisará saber o ID do projeto. No Console do Cloud, encontre esse ID no card Informações do projeto e execute os comandos especificados abaixo para cada valor.

Número do projeto

Para conseguir o número do projeto usando a ferramenta de linha de comando gcloud, execute o seguinte comando:

gcloud projects describe PROJECT_ID

O comando retorna uma saída semelhante a esta:

createTime: '2016-10-13T16:44:28.170Z'
lifecycleState: ACTIVE
name: project_name
parent:
  id: '433637338589'
  type: organization
projectId: PROJECT_ID
projectNumber: 'PROJECT_NUMBER'

ID do serviço

Para conseguir o código do serviço usando a ferramenta de linha de comando gcloud, execute o seguinte comando:

gcloud compute backend-services describe SERVICE_NAME --project=PROJECT_ID --global

O comando retorna uma saída semelhante a esta:

affinityCookieTtlSec: 0
backends:
- balancingMode: UTILIZATION
  capacityScaler: 1.0
  group: https://www.googleapis.com/compute/v1/projects/project_name/regions/us-central1/instanceGroups/my-group
connectionDraining:
  drainingTimeoutSec: 0
creationTimestamp: '2017-04-03T14:01:35.687-07:00'
description: ''
enableCDN: false
fingerprint: zaOnO4k56Cw=
healthChecks:
- https://www.googleapis.com/compute/v1/projects/project_name/global/httpsHealthChecks/my-hc
id: 'SERVICE_ID'
kind: compute#backendService
loadBalancingScheme: EXTERNAL
name: my-service
port: 8443
portName: https
protocol: HTTPS
selfLink: https://www.googleapis.com/compute/v1/projects/project_name/global/backendServices/my-service
sessionAffinity: NONE
timeoutSec: 3610

Como recuperar a identidade do usuário

Se todas as verificações acima forem bem-sucedidas, recupere a identidade do usuário. O payload do token de código contém as seguintes informações de usuário:

Identidade do usuário de payload do token de código
sub Assunto O identificador exclusivo e estável do usuário. Use esse valor em vez do cabeçalho x-goog-authenticated-user-id.
email E-mail do usuário O endereço de e-mail do usuário.
  • Use esse valor em vez do cabeçalho x-goog-authenticated-user-email.
  • Ao contrário do cabeçalho e da declaração sub, esse valor não tem um prefixo de namespace.

Veja alguns códigos de amostra para proteger um app com cabeçalhos assinados pelo IAP:

C#


using Google.Apis.Auth;
using System;
using System.Threading;
using System.Threading.Tasks;

public class IAPTokenVerification
{
    /// <summary>
    /// Verifies a signed jwt token and returns its payload.
    /// </summary>
    /// <param name="signedJwt">The token to verify.</param>
    /// <param name="expectedAudience">The audience that the token should be meant for.
    /// Validation will fail if that's not the case.</param>
    /// <param name="cancellationToken">The cancellation token to propagate cancellation requests.</param>
    /// <returns>A task that when completed will have as its result the payload of the verified token.</returns>
    /// <exception cref="InvalidJwtException">If verification failed. The message of the exception will contain
    /// information as to why the token failed.</exception>
    public async Task<JsonWebSignature.Payload> VerifyTokenAsync(
        string signedJwt, string expectedAudience, CancellationToken cancellationToken = default)
    {
        SignedTokenVerificationOptions options = new SignedTokenVerificationOptions
        {
            // Use clock tolerance to account for possible clock differences
            // between the issuer and the verifier.
            IssuedAtClockTolerance = TimeSpan.FromMinutes(1),
            ExpiryClockTolerance = TimeSpan.FromMinutes(1),
            TrustedAudiences = { expectedAudience }
        };

        return await JsonWebSignature.VerifySignedTokenAsync(signedJwt, options, cancellationToken: cancellationToken);
    }
}

Go

import (
	"context"
	"fmt"
	"io"

	"google.golang.org/api/idtoken"
)

// validateJWTFromAppEngine validates a JWT found in the
// "x-goog-iap-jwt-assertion" header.
func validateJWTFromAppEngine(w io.Writer, iapJWT, projectNumber, projectID string) error {
	// iapJWT := "YmFzZQ==.ZW5jb2RlZA==.and0" // req.Header.Get("X-Goog-IAP-JWT-Assertion")
	// projectNumber := "123456789"
	// projectID := "your-project-id"
	ctx := context.Background()
	aud := fmt.Sprintf("/projects/%s/apps/%s", projectNumber, projectID)

	payload, err := idtoken.Validate(ctx, iapJWT, aud)
	if err != nil {
		return fmt.Errorf("idtoken.Validate: %v", err)
	}

	// payload contains the JWT claims for further inspection or validation
	fmt.Fprintf(w, "payload: %v", payload)

	return nil
}

// validateJWTFromComputeEngine validates a JWT found in the
// "x-goog-iap-jwt-assertion" header.
func validateJWTFromComputeEngine(w io.Writer, iapJWT, projectNumber, backendServiceID string) error {
	// iapJWT := "YmFzZQ==.ZW5jb2RlZA==.and0" // req.Header.Get("X-Goog-IAP-JWT-Assertion")
	// projectNumber := "123456789"
	// backendServiceID := "backend-service-id"
	ctx := context.Background()
	aud := fmt.Sprintf("/projects/%s/global/backendServices/%s", projectNumber, backendServiceID)

	payload, err := idtoken.Validate(ctx, iapJWT, aud)
	if err != nil {
		return fmt.Errorf("idtoken.Validate: %v", err)
	}

	// payload contains the JWT claims for further inspection or validation
	fmt.Fprintf(w, "payload: %v", payload)

	return nil
}

Java

Ver no GitHub (em inglês) Feedback

import com.google.api.client.http.HttpRequest;
import com.google.api.client.json.webtoken.JsonWebToken;
import com.google.auth.oauth2.TokenVerifier;

/** Verify IAP authorization JWT token in incoming request. */
public class VerifyIapRequestHeader {

  private static final String IAP_ISSUER_URL = "https://cloud.google.com/iap";

  // Verify jwt tokens addressed to IAP protected resources on App Engine.
  // The project *number* for your Google Cloud project via 'gcloud projects describe $PROJECT_ID'
  // The project *number* can also be retrieved from the Project Info card in Cloud Console.
  // projectId is The project *ID* for your Google Cloud Project.
  boolean verifyJwtForAppEngine(HttpRequest request, long projectNumber, String projectId)
      throws Exception {
    // Check for iap jwt header in incoming request
    String jwt = request.getHeaders().getFirstHeaderStringValue("x-goog-iap-jwt-assertion");
    if (jwt == null) {
      return false;
    }
    return verifyJwt(
        jwt,
        String.format("/projects/%s/apps/%s", Long.toUnsignedString(projectNumber), projectId));
  }

  boolean verifyJwtForComputeEngine(
      HttpRequest request, long projectNumber, long backendServiceId) throws Exception {
    // Check for iap jwt header in incoming request
    String jwtToken = request.getHeaders()
        .getFirstHeaderStringValue("x-goog-iap-jwt-assertion");
    if (jwtToken == null) {
      return false;
    }
    return verifyJwt(
        jwtToken,
        String.format(
            "/projects/%s/global/backendServices/%s",
            Long.toUnsignedString(projectNumber), Long.toUnsignedString(backendServiceId)));
  }

  private boolean verifyJwt(String jwtToken, String expectedAudience) {
    TokenVerifier tokenVerifier = TokenVerifier.newBuilder()
        .setAudience(expectedAudience)
        .setIssuer(IAP_ISSUER_URL)
        .build();
    try {
      JsonWebToken jsonWebToken = tokenVerifier.verify(jwtToken);

      // Verify that the token contain subject and email claims
      JsonWebToken.Payload payload = jsonWebToken.getPayload();
      return payload.getSubject() != null && payload.get("email") != null;
    } catch (TokenVerifier.VerificationException e) {
      System.out.println(e.getMessage());
      return false;
    }
  }
}

Node.js

Ver no GitHub (em inglês) Feedback
/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const iapJwt = 'SOME_ID_TOKEN'; // JWT from the "x-goog-iap-jwt-assertion" header

let expectedAudience = null;
if (projectNumber && projectId) {
  // Expected Audience for App Engine.
  expectedAudience = `/projects/${projectNumber}/apps/${projectId}`;
} else if (projectNumber && backendServiceId) {
  // Expected Audience for Compute Engine
  expectedAudience = `/projects/${projectNumber}/global/backendServices/${backendServiceId}`;
}

const oAuth2Client = new OAuth2Client();

async function verify() {
  // Verify the id_token, and access the claims.
  const response = await oAuth2Client.getIapPublicKeys();
  const ticket = await oAuth2Client.verifySignedJwtWithCertsAsync(
    iapJwt,
    response.pubkeys,
    expectedAudience,
    ['https://cloud.google.com/iap']
  );
  // Print out the info contained in the IAP ID token
  console.log(ticket);
}

verify().catch(console.error);

PHP

namespace Google\Cloud\Samples\Iap;

# Imports Google auth libraries for IAP validation
use Google\Auth\AccessToken;

/**
 * Validate a JWT passed to your App Engine app by Identity-Aware Proxy.
 *
 * @param string $iap_jwt The contents of the X-Goog-IAP-JWT-Assertion header.
 * @param string $cloud_project_number The project *number* for your Google
 *     Cloud project. This is returned by 'gcloud projects describe $PROJECT_ID',
 *     or in the Project Info card in Cloud Console.
 * @param string $cloud_project Your Google Cloud Project ID.
 *
 * @return (user_id, user_email).
 */
function validate_jwt_from_app_engine($iap_jwt, $cloud_project_number, $cloud_project_id)
{
    $expected_audience = sprintf(
        '/projects/%s/apps/%s',
        $cloud_project_number,
        $cloud_project_id
    );
    return validate_jwt($iap_jwt, $expected_audience);
}

/**
 * Validate a JWT passed to your Compute / Container Engine app by Identity-Aware Proxy.
 *
 * @param string $iap_jwt The contents of the X-Goog-IAP-JWT-Assertion header.
 * @param string $cloud_project_number The project *number* for your Google
 *     Cloud project. This is returned by 'gcloud projects describe $PROJECT_ID',
 *     or in the Project Info card in Cloud Console.
 * @param string $backend_service_id The ID of the backend service used to access the
 *     application. See https://cloud.google.com/iap/docs/signed-headers-howto
 *     for details on how to get this value.
 *
 * @return (user_id, user_email).
 */
function validate_jwt_from_compute_engine($iap_jwt, $cloud_project_number, $backend_service_id)
{
    $expected_audience = sprintf(
        '/projects/%s/global/backendServices/%s',
        $cloud_project_number,
        $backend_service_id
    );
    return validate_jwt($iap_jwt, $expected_audience);
}

function validate_jwt($iap_jwt, $expected_audience)
{
    // Validate the signature using the IAP cert URL.
    $token = new AccessToken();
    $jwt = $token->verify($iap_jwt, [
        'certsLocation' => AccessToken::IAP_CERT_URL
    ]);

    if (!$jwt) {
        return print('Failed to validate JWT: Invalid JWT');
    }

    // Validate token by checking issuer and audience fields.
    assert($jwt['iss'] == 'https://cloud.google.com/iap');
    assert($jwt['aud'] == $expected_audience);

    // Return the user identity (subject and user email) if JWT verification is successful.
    return array('sub' => $jwt['sub'], 'email' => $jwt['email']);
}

Python

Ver no GitHub (em inglês) Feedback
from google.auth.transport import requests
from google.oauth2 import id_token

def validate_iap_jwt(iap_jwt, expected_audience):
    """Validate an IAP JWT.

    Args:
      iap_jwt: The contents of the X-Goog-IAP-JWT-Assertion header.
      expected_audience: The Signed Header JWT audience. See
          https://cloud.google.com/iap/docs/signed-headers-howto
          for details on how to get this value.

    Returns:
      (user_id, user_email, error_str).
    """

    try:
        decoded_jwt = id_token.verify_token(
            iap_jwt, requests.Request(), audience=expected_audience,
            certs_url='https://www.gstatic.com/iap/verify/public_key')
        return (decoded_jwt['sub'], decoded_jwt['email'], '')
    except Exception as e:
        return (None, None, '**ERROR: JWT validation error {}**'.format(e))

Ruby

# iap_jwt = "The contents of the X-Goog-Iap-Jwt-Assertion header"
# project_number = "The project *number* for your Google Cloud project"
# project_id = "Your Google Cloud project ID"
# backend_service_id = "Your Compute Engine backend service ID"
require "googleauth"

audience = nil
if project_number && project_id
  # Expected audience for App Engine
  audience = "/projects/#{project_number}/apps/#{project_id}"
elsif project_number && backend_service_id
  # Expected audience for Compute Engine
  audience = "/projects/#{project_number}/global/backendServices/#{backend_service_id}"
end

# The client ID as the target audience for IAP
payload = Google::Auth::IDTokens.verify_iap iap_jwt, aud: audience

puts payload

if audience.nil?
  puts "Audience not verified! Supply a project_number and project_id to verify"
end

Como testar seu código de validação

Se você visitar seu app usando os parâmetros de consulta secure_token_test, o IAP incluirá um JWT inválido. Use-o para garantir que a lógica de validação do JWT processe todos os diversos casos de falha e para ver como seu app se comporta ao receber um JWT inválido.

Como criar uma exceção de verificação de integridade

Como mencionado anteriormente, as verificações de integridade do Compute Engine e do GKE não usam cabeçalhos JWT. Além disso, o IAP não processa verificações de integridade. Você precisará configurar a verificação de integridade, bem como o app para permitir o acesso nessa situação.

Como configurar a verificação de integridade

Se você ainda não definiu um caminho para a verificação de integridade, use o Console do Cloud para configurar um caminho não confidencial para essa finalidade. Esse caminho não pode ser compartilhado com nenhum outro recurso.

  1. Acesse a página Verificações de integridade no Console do Cloud.
    Acessar a página "Verificações de integridade"
  2. Clique na verificação de integridade que você está usando no app e depois clique em Editar.
  3. Em Caminho da solicitação, insira um nome de caminho não confidencial. Isso especifica o caminho do URL que o Google Cloud usará para enviar solicitações de verificação de integridade. Se omitido, a solicitação de verificação de integridade será enviada para /.
  4. Clique em Salvar.

Como configurar a validação do JWT

No código que chama a rotina de validação do JWT, inclua uma condição para exibir um status HTTP 200 ao caminho de solicitação da verificação de integridade. Por exemplo:

if HttpRequest.path_info = '/HEALTH_CHECK_REQUEST_PATH'
  return HttpResponse(status=200)
else
  VALIDATION_FUNCTION

JWTs para identidades externas

Se você estiver usando o IAP com identidades externas, ele ainda emitirá um JWT assinado em todas as solicitações autenticadas, assim como faz com as identidades do Google. No entanto, existem algumas diferenças.

Informações do provedor

Ao usar identidades externas, o payload do JWT incluirá uma declaração chamada gcip. Essa declaração contém informações sobre o usuário, como o e-mail e o URL da foto, além de outros atributos específicos do provedor.

Veja abaixo um exemplo de um JWT de um usuário que fez login com o Facebook:

"gcip": '{
  "auth_time": 1553219869,
  "email": "facebook_user@gmail.com",
  "email_verified": false,
  "firebase": {
    "identities": {
      "email": [
        "facebook_user@gmail.com"
      ],
      "facebook.com": [
        "1234567890"
      ]
    },
    "sign_in_provider": "facebook.com",
  },
  "name": "Facebook User",
  "picture: "https://graph.facebook.com/1234567890/picture",
  "sub": "gZG0yELPypZElTmAT9I55prjHg63"
}',

Campos email e sub

Se um usuário foi autenticado pelo Identity Platform, os campos email e sub do JWT terão como prefixo o emissor do token do Identity Platform e o ID do locatário usado (se houver). Por exemplo:

"email": "securetoken.google.com/PROJECT-ID/TENANT-ID:demo_user@gmail.com",
"sub": "securetoken.google.com/PROJECT-ID/TENANT-ID:gZG0yELPypZElTmAT9I55prjHg63"

Como controlar o acesso com sign_in_attributes

O IAM não é compatível com identidades externas. No entanto, é possível usar as declarações incorporadas no campo sign_in_attributes para controlar o acesso. Por exemplo, imagine que um usuário fez login usando um provedor SAML:

{
  "aud": "/projects/project_number/apps/my_project_id",
  "gcip": '{
    "auth_time": 1553219869,
    "email": "demo_user@gmail.com",
    "email_verified": true,
    "firebase": {
      "identities": {
        "email": [
          "demo_user@gmail.com"
        ],
        "saml.myProvider": [
          "demo_user@gmail.com"
        ]
      },
      "sign_in_attributes": {
        "firstname": "John",
        "group": "test group",
        "role": "admin",
        "lastname": "Doe"
      },
      "sign_in_provider": "saml.myProvider",
      "tenant": "my_tenant_id"
    },
    "sub": "gZG0yELPypZElTmAT9I55prjHg63"
  }',
  "email": "securetoken.google.com/my_project_id/my_tenant_id:demo_user@gmail.com",
  "exp": 1553220470,
  "iat": 1553219870,
  "iss": "https://cloud.google.com/iap",
  "sub": "securetoken.google.com/my_project_id/my_tenant_id:gZG0yELPypZElTmAT9I55prjHg63"
}

É possível adicionar lógica ao aplicativo de maneira semelhante ao código abaixo para restringir o acesso a usuários com um papel válido:

const gcipClaims = JSON.parse(decodedIapJwtClaims.gcip);
if (gcipClaims &&
    gcipClaims.firebase &&
    gcipClaims.firebase.sign_in_attributes &&
    gcipClaims.firebase.sign_in_attribute.role === 'admin') {
  // Allow access to admin restricted resource.
} else {
  // Block access.
}

Para acessar os demais atributos de usuário dos provedores SAML e OIDC do Identity Platform, use a declaração aninhada gcipClaims.gcip.firebase.sign_in_attributes.