Visão geral da App Security

A segurança é um recurso essencial do Google Cloud Platform, mas há outras etapas necessárias para proteger seu aplicativo do App Engine e identificar vulnerabilidades.

Use os recursos a seguir para garantir a segurança do seu aplicativo do App Engine. Para saber mais sobre o modelo de segurança do Google e as medidas disponíveis para proteger os projetos do GCP, consulte Segurança do Google Cloud Platform.

Solicitações HTTPS

Use solicitações HTTPS para acessar o aplicativo do App Engine com segurança. Dependendo de como o aplicativo está configurado, você tem as seguintes opções:

Domínios de appspot.com
  • Basta usar o prefixo de URL https para enviar uma solicitação HTTPS ao serviço default do projeto do GCP, por exemplo:
    https://[MY_PROJECT_ID].appspot.com
  • Para visar recursos específicos no aplicativo do App Engine, use a sintaxe -dot- para separar cada recurso que você quer visar. Por exemplo:

    https://[VERSION_ID]-dot-[SERVICE_ID]-dot-[MY_PROJECT_ID].appspot.com

  • Dica: para converter um URL HTTP em HTTPS, basta substituir os pontos entre cada recurso por -dot-. Por exemplo:

    http://[SERVICE_ID].[MY_PROJECT_ID].appspot.com
    https://[SERVICE_ID]-dot-[MY_PROJECT_ID].appspot.com

Para saber mais informações sobre URLs HTTPS e como selecionar recursos, consulte Como as solicitações são encaminhadas.

Domínios personalizados

Para enviar solicitações HTTPS com um domínio personalizado, use os certificados SSL gerenciados provisionados pelo App Engine. Para saber mais, consulte Como proteger domínios personalizados com SSL.

Controle de acesso

Em cada projeto do GCP, configure o controle de acesso para determinar quem pode acessar os serviços no projeto, incluindo o App Engine. É possível atribuir papéis diferentes a contas diferentes, para garantir a atribuição apenas das permissões necessárias a cada conta e o respectivo suporte ao seu aplicativo. Para saber detalhes, consulte Como configurar o controle de acesso .

Firewall do App Engine

Com o firewall do App Engine, é possível controlar o acesso ao aplicativo do App Engine por meio de um grupo de regras que podem permitir ou negar solicitações feitas por endereços IP dentro de intervalos especificados. Você não será cobrado pelo tráfego ou pela largura de banda bloqueada pelo firewall. Crie um firewall para:

Permitir somente o tráfego de dentro de uma rede específica
Garanta que apenas endereços IP de um determinado intervalo de redes específicas possam acessar o aplicativo. Por exemplo, crie regras para autorizar o acesso apenas dos endereços IP dentro do intervalo pertencente à rede particular da sua empresa durante a fase de testes do aplicativo. Em seguida, é possível criar e modificar as regras do firewall para controlar o escopo do acesso ao longo do processo de lançamento, permitindo que apenas determinadas organizações, internas ou externas à empresa, acessem o aplicativo até que ele esteja disponível para o público em geral.
Permitir somente o tráfego de um serviço específico
Garanta que todo o tráfego encaminhado ao aplicativo do App Engine seja primeiramente intermediado por proxy por meio de um serviço específico. Por exemplo, se você usar um firewall de aplicativos da Web (WAF, na sigla em inglês) de terceiros para intermediar por proxy as solicitações direcionadas ao aplicativo, será possível criar regras de firewall para negar todas as solicitações, exceto aquelas encaminhadas a partir do WAF.
Bloquear endereços IP abusivos
O Google Cloud Platform tem muitos mecanismos para evitar ataques. No entanto, é possível usar o firewall do App Engine para bloquear o tráfego que chega ao aplicativo vindo de endereços IP maliciosos. Ele também serve para proteger o aplicativo contra ataques de negação de serviço e outras formas de abuso semelhantes. Coloque endereços IP ou sub-redes na lista de proibições para que as solicitações encaminhadas desses pontos sejam negadas antes de chegarem ao aplicativo do App Engine.

Para saber mais sobre como criar regras e configurar o firewall, consulte Como controlar o acesso com firewalls.

Security Scanner

O Google Cloud Security Scanner é um verificador de segurança que detecta vulnerabilidades por meio do rastreamento do seu aplicativo do App Engine, seguindo todos os links dentro do escopo dos URLs iniciais e tentando acionar o máximo possível de entradas de usuários e gerenciadores de eventos.

Para usar o Security Scanner, é preciso ser proprietário do projeto do GCP. Para mais informações sobre a atribuição de papéis, consulte Como conceder acesso a projetos.

É possível executar verificações de segurança no Console do Google Cloud Platform para identificar as vulnerabilidades de segurança no aplicativo do App Engine. Para detalhes sobre como executar o Security Scanner, consulte o Guia de início rápido do produto.

Provedor de proteção de dados do ASP.Net Core

A pilha de proteção de dados do ASP.NET Core protege dados de aplicativos da Web, como cookies e tokens anti-CSRF, por meio de criptografia.

O padrão IDataProtectionProvider armazena as chaves de criptografia localmente na máquina que executa o servidor da Web, que não é compatível com o Google App Engine e faz com que mensagens de erro sejam exibidas.

Para solucionar esse problema, use o Google.Cloud.AspNetCore.DataProtection.Storage e o Google.Cloud.AspNetCore.DataProtection.Kms. Faça o seguinte para usar essas bibliotecas:

  1. Crie um intervalo do Cloud Storage.

  2. Crie um keyring e uma chave do Cloud Key Management Service:

    gcloud kms keyrings create dataprotectionprovider --location global
    gcloud kms keys create key --location global --keyring `
        dataprotectionprovider --purpose=encryption
    
  3. Defina a permissão da sua conta de serviço para usar o keyring:

    gcloud kms keyrings add-iam-policy-binding dataprotectionprovider `
        --location 'global' `
        --member serviceAccount:my-project-id@appspot.gserviceaccount.com  `
        --role roles/cloudkms.cryptoKeyEncrypterDecrypter
    
  4. Adicione as bibliotecas ao .csproj do seu aplicativo:

    dotnet add package Google.Cloud.AspNetCore.DataProtection.Kms
    dotnet add package Google.Cloud.AspNetCore.DataProtection.Storage
    
  5. Adicione os nomes do intervalo e do objeto (nome do arquivo) em que as chaves serão armazenadas e o nome da chave KMS para o arquivo appsettings.json do aplicativo:

    {
      "Logging": {
        "LogLevel": {
          "Default": "Warning"
        }
      },
      "AllowedHosts": "*",
      "DataProtection": {
        "Bucket": "YOUR-BUCKET",
        "Object": "DataProtectionProviderKeys.xml",
        "KmsKeyName": "projects/YOUR-PROJECT-ID/locations/global/keyRings/dataprotectionprovider/cryptoKeys/key"
      }
    }
    
  6. É possível configurar a pilha de proteção de dados do ASP.NET Core para usar as bibliotecas do Google. Basta adicionar o seguinte ao seu arquivo Startup.cs:

    
    using Google.Cloud.AspNetCore.DataProtection.Kms;
    using Google.Cloud.AspNetCore.DataProtection.Storage;
        public class Startup
        {
            public void ConfigureServices(IServiceCollection services)
            {
                // Antiforgery tokens require data protection.
                services.AddDataProtection()
                    // Store keys in Cloud Storage so that multiple instances
                    // of the web application see the same keys.
                    .PersistKeysToGoogleCloudStorage(
                        Configuration["DataProtection:Bucket"],
                        Configuration["DataProtection:Object"])
                    // Protect the keys with Google KMS for encryption and fine-
                    // grained access control.
                    .ProtectKeysWithGoogleKms(
                        Configuration["DataProtection:KmsKeyName"]);
    

É possível fazer o download de um exemplo pronto para execução com um script de configuração no repositório do Google Cloud Platform no GitHub (em inglês).