Autenticazione per le sottoscrizioni push

Se una sottoscrizione push utilizza l'autenticazione, il servizio Pub/Sub firma un JWT e invia il JWT nell'intestazione di autorizzazione della richiesta push. Il JWT include rivendicazioni e una firma.

Gli abbonati possono convalidare il JWT e verificare quanto segue:

Le dichiarazioni sono accurate.
Il servizio Pub/Sub ha firmato le attestazioni.

Se gli abbonati utilizzano un firewall, non possono ricevere richieste push. Per ricevere le richieste push, devi disattivare il firewall e verificare il JWT.

Prima di iniziare

Scopri di più sugli abbonamenti.
Scopri come funzionano gli abbonamenti push.
Crea un abbonamento push.

Formato JWT

Il JWT è un JWT OpenIDConnect costituito da un'intestazione, un set di attestazioni e una firma. Il servizio Pub/Sub codifica il JWT come stringa base64 con delimitatori di punto.

Ad esempio, la seguente intestazione di autorizzazione include un JWT codificato:

"Authorization" : "Bearer
eyJhbGciOiJSUzI1NiIsImtpZCI6IjdkNjgwZDhjNzBkNDRlOTQ3MTMzY2JkNDk5ZWJjMWE2MWMzZDVh
YmMiLCJ0eXAiOiJKV1QifQ.eyJhdWQiOiJodHRwczovL2V4YW1wbGUuY29tIiwiYXpwIjoiMTEzNzc0M
jY0NDYzMDM4MzIxOTY0IiwiZW1haWwiOiJnYWUtZ2NwQGFwcHNwb3QuZ3NlcnZpY2VhY2NvdW50LmNvb
SIsImVtYWlsX3ZlcmlmaWVkIjp0cnVlLCJleHAiOjE1NTAxODU5MzUsImlhdCI6MTU1MDE4MjMzNSwia
XNzIjoiaHR0cHM6Ly9hY2NvdW50cy5nb29nbGUuY29tIiwic3ViIjoiMTEzNzc0MjY0NDYzMDM4MzIxO
TY0In0.QVjyqpmadTyDZmlX2u3jWd1kJ68YkdwsRZDo-QxSPbxjug4ucLBwAs2QePrcgZ6hhkvdc4UHY
4YF3fz9g7XHULNVIzX5xh02qXEH8dK6PgGndIWcZQzjSYfgO-q-R2oo2hNM5HBBsQN4ARtGK_acG-NGG
WM3CQfahbEjZPAJe_B8M7HfIu_G5jOLZCw2EUcGo8BvEwGcLWB2WqEgRM0-xt5-UPzoa3-FpSPG7DHk7
z9zRUeq6eB__ldb-2o4RciJmjVwHgnYqn3VvlX9oVKEgXpNFhKuYA-mWh5o7BCwhujSMmFoBOh6mbIXF
cyf5UiVqKjpqEbqPGo_AvKvIQ9VTQ"

L'insieme di intestazioni e attestazioni sono stringhe JSON. Una volta decodificati, assumono la forma seguente:

{"alg":"RS256","kid":"7d680d8c70d44e947133cbd499ebc1a61c3d5abc","typ":"JWT"}

{
   "aud":"https://example.com",
   "azp":"113774264463038321964",
   "email":"gae-gcp@appspot.gserviceaccount.com",
   "sub":"113774264463038321964",
   "email_verified":true,
   "exp":1550185935,
   "iat":1550182335,
   "iss":"https://accounts.google.com"
  }

I token associati alle richieste inviate agli endpoint push potrebbero risalire fino a un'ora prima.

Configurare Pub/Sub per l'autenticazione push

L'esempio seguente mostra come impostare l'account di servizio dell'autenticazione push su un account di servizio a tua scelta e come concedere all'account di servizio gestito da Google service-{PROJECT_NUMBER}@gcp-sa-pubsub.iam.gserviceaccount.com il ruolo iam.serviceAccountTokenCreator.

Console

Vai alla pagina Sottoscrizioni Pub/Sub.

Vai alla pagina Abbonamenti
Fai clic su Crea sottoscrizione.
Nel campo ID abbonamento, inserisci un nome.
Seleziona un argomento.
Seleziona Push come Tipo di pubblicazione.
Inserisci l'URL di un endpoint.
Seleziona Attiva autenticazione.
Seleziona un account di servizio.
Assicurati che l'account di servizio gestito da Google service-{PROJECT_NUMBER}@gcp-sa-pubsub.iam.gserviceaccount.com abbia il ruolo iam.serviceAccountTokenCreator nella dashboard IAM del tuo progetto. Se all'account di servizio non è stato concesso il ruolo, fai clic su Concedi nella dashboard IAM per farlo.
(Facoltativo) Inserisci un segmento di pubblico.
Fai clic su Crea.

gcloud

# Configure the push subscription
gcloud pubsub subscriptions (create|update|modify-push-config) ${SUBSCRIPTION} \
 --topic=${TOPIC} \
 --push-endpoint=${PUSH_ENDPOINT_URI} \
 --push-auth-service-account=${SERVICE_ACCOUNT_EMAIL} \
 --push-auth-token-audience=${OPTIONAL_AUDIENCE_OVERRIDE}

# Your Google-managed service account
# `service-{PROJECT_NUMBER}@gcp-sa-pubsub.iam.gserviceaccount.com` needs to have the
# `iam.serviceAccountTokenCreator` role.
PUBSUB_SERVICE_ACCOUNT="service-${PROJECT_NUMBER}@gcp-sa-pubsub.iam.gserviceaccount.com"
gcloud projects add-iam-policy-binding ${PROJECT_ID} \
 --member="serviceAccount:${PUBSUB_SERVICE_ACCOUNT}"\
 --role='roles/iam.serviceAccountTokenCreator'

Quando attivi l'autenticazione per un abbonamento push, potresti riscontrare un errore permission denied o not authorized. Per risolvere il problema, concedi all'entità che avvia la creazione o l'aggiornamento dell'abbonamento l'autorizzazione iam.serviceAccounts.actAs nell'account di servizio. Per ulteriori informazioni, consulta la sezione Autenticazione in "Creare sottoscrizioni push".

Se utilizzi un abbonamento push autenticato con un'applicazione App Engine protetta con Identity-Aware Proxy, devi fornire l'ID client IAP come pubblico del token di autenticazione push. Per abilitare IAP nella tua applicazione App Engine, consulta Abilitazione di IAP. Per trovare l'ID client IAP, cerca l'ID client IAP-App-Engine-app nella pagina Credenziali.

Richieste di indennizzo

Il JWT può essere utilizzato per verificare che le dichiarazioni, incluse quelle email e aud, siano firmate da Google. Per saperne di più su come le API OAuth 2.0 di Google possono essere utilizzate sia per l'autenticazione che per l'autorizzazione, consulta OpenID Connect.

Esistono due meccanismi che rendono queste affermazioni significative. Innanzitutto, Pub/Sub richiede che l'account utente o di servizio che effettua la chiamata CreateSubscription, UpdateSubscription o ModificaPushConfig abbia un ruolo con l'autorizzazione iam.serviceAccounts.actAs nell'account di servizio di autenticazione push. Un esempio di questo ruolo è il ruolo roles/iam.serviceAccountUser.

Secondo, l'accesso ai certificati utilizzati per firmare i token è strettamente controllato. Per creare il token, Pub/Sub deve chiamare un servizio Google interno utilizzando un'identità dell'account di servizio di firma separata, ovvero l'account di servizio gestito da Google service-${PROJECT_NUMBER}@gcp-sa-pubsub.iam.gserviceaccount.com. Questo account di servizio di firma deve avere l'autorizzazione iam.serviceAccounts.getOpenIdToken o un ruolo Creatore token account di servizio (roles/iam.serviceAccountTokenCreator) nell'account di servizio di autenticazione push (o su qualsiasi risorsa predecessore, ad esempio il progetto, dell'account di servizio di autenticazione push).

Convalida token

La convalida dei token inviati da Pub/Sub all'endpoint push riguarda:

Controllo dell'integrità del token mediante la convalida della firma.
Assicurarsi che le attestazioni email e audience nel token corrispondano ai valori impostati nella configurazione dell'abbonamento push.

L'esempio seguente illustra come autenticare una richiesta push a un'applicazione App Engine non protetta con Identity-Aware Proxy. Se la tua applicazione App Engine è protetta con IAP, l'intestazione della richiesta HTTP che contiene il JWT IAP è x-goog-iap-jwt-assertion e deve essere convalidata di conseguenza.

protocollo

Richiesta:

GET https://oauth2.googleapis.com/tokeninfo?id_token={BEARER_TOKEN}

Risposta:

200 OK

{
    "alg": "RS256",
    "aud": "example.com",
    "azp": "104176025330667568672",
    "email": "{SERVICE_ACCOUNT_NAME}@{YOUR_PROJECT_NAME}.iam.gserviceaccount.com",
    "email_verified": "true",
    "exp": "1555463097",
    "iat": "1555459497",
    "iss": "https://accounts.google.com",
    "kid": "3782d3f0bc89008d9d2c01730f765cfb19d3b70e",
    "sub": "104176025330667568672",
    "typ": "JWT"
}

C#

Prima di provare questo esempio, segui le istruzioni di configurazione di C# nella Guida rapida sull'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API C# di Pub/Sub.

        /// <summary>
        /// Extended JWT payload to match the pubsub payload format.
        /// </summary>
        public class PubSubPayload : JsonWebSignature.Payload
        {
            [JsonProperty("email")]
            public string Email { get; set; }
            [JsonProperty("email_verified")]
            public string EmailVerified { get; set; }
        }
        /// <summary>
        /// Handle authenticated push request coming from pubsub.
        /// </summary>
        [HttpPost]
        [Route("/AuthPush")]
        public async Task<IActionResult> AuthPushAsync([FromBody] PushBody body, [FromQuery] string token)
        {
            // Get the Cloud Pub/Sub-generated "Authorization" header.
            string authorizaionHeader = HttpContext.Request.Headers["Authorization"];
            string verificationToken = token ?? body.message.attributes["token"];
            // JWT token comes in `Bearer <JWT>` format substring 7 specifies the position of first JWT char.
            string authToken = authorizaionHeader.StartsWith("Bearer ") ? authorizaionHeader.Substring(7) : null;
            if (verificationToken != _options.VerificationToken || authToken is null)
            {
                return new BadRequestResult();
            }
            // Verify and decode the JWT.
            // Note: For high volume push requests, it would save some network
            // overhead if you verify the tokens offline by decoding them using
            // Google's Public Cert; caching already seen tokens works best when
            // a large volume of messages have prompted a single push server to
            // handle them, in which case they would all share the same token for
            // a limited time window.
            var payload = await JsonWebSignature.VerifySignedTokenAsync<PubSubPayload>(authToken);

            // IMPORTANT: you should validate payload details not covered
            // by signature and audience verification above, including:
            //   - Ensure that `payload.Email` is equal to the expected service
            //     account set up in the push subscription settings.
            //   - Ensure that `payload.Email_verified` is set to true.

            var messageBytes = Convert.FromBase64String(body.message.data);
            string message = System.Text.Encoding.UTF8.GetString(messageBytes);
            s_authenticatedMessages.Add(message);
            return new OkResult();
        }

Go

// receiveMessagesHandler validates authentication token and caches the Pub/Sub
// message received.
func (a *app) receiveMessagesHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != "POST" {
		http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
		return
	}

	// Verify that the request originates from the application.
	// a.pubsubVerificationToken = os.Getenv("PUBSUB_VERIFICATION_TOKEN")
	if token, ok := r.URL.Query()["token"]; !ok || len(token) != 1 || token[0] != a.pubsubVerificationToken {
		http.Error(w, "Bad token", http.StatusBadRequest)
		return
	}

	// Get the Cloud Pub/Sub-generated JWT in the "Authorization" header.
	authHeader := r.Header.Get("Authorization")
	if authHeader == "" || len(strings.Split(authHeader, " ")) != 2 {
		http.Error(w, "Missing Authorization header", http.StatusBadRequest)
		return
	}
	token := strings.Split(authHeader, " ")[1]
	// Verify and decode the JWT.
	// If you don't need to control the HTTP client used you can use the
	// convenience method idtoken.Validate instead of creating a Validator.
	v, err := idtoken.NewValidator(r.Context(), option.WithHTTPClient(a.defaultHTTPClient))
	if err != nil {
		http.Error(w, "Unable to create Validator", http.StatusBadRequest)
		return
	}
	// Please change http://example.com to match with the value you are
	// providing while creating the subscription.
	payload, err := v.Validate(r.Context(), token, "http://example.com")
	if err != nil {
		http.Error(w, fmt.Sprintf("Invalid Token: %v", err), http.StatusBadRequest)
		return
	}
	if payload.Issuer != "accounts.google.com" && payload.Issuer != "https://accounts.google.com" {
		http.Error(w, "Wrong Issuer", http.StatusBadRequest)
		return
	}

	// IMPORTANT: you should validate claim details not covered by signature
	// and audience verification above, including:
	//   - Ensure that `payload.Claims["email"]` is equal to the expected service
	//     account set up in the push subscription settings.
	//   - Ensure that `payload.Claims["email_verified"]` is set to true.
	if payload.Claims["email"] != "test-service-account-email@example.com" || payload.Claims["email_verified"] != true {
		http.Error(w, "Unexpected email identity", http.StatusBadRequest)
		return
	}

	var pr pushRequest
	if err := json.NewDecoder(r.Body).Decode(&pr); err != nil {
		http.Error(w, fmt.Sprintf("Could not decode body: %v", err), http.StatusBadRequest)
		return
	}

	a.messagesMu.Lock()
	defer a.messagesMu.Unlock()
	// Limit to ten.
	a.messages = append(a.messages, pr.Message.Data)
	if len(a.messages) > maxMessages {
		a.messages = a.messages[len(a.messages)-maxMessages:]
	}

	fmt.Fprint(w, "OK")
}

Java

@WebServlet(value = "/pubsub/authenticated-push")
public class PubSubAuthenticatedPush extends HttpServlet {
  private final String pubsubVerificationToken = System.getenv("PUBSUB_VERIFICATION_TOKEN");
  private final MessageRepository messageRepository;
  private final GoogleIdTokenVerifier verifier =
      new GoogleIdTokenVerifier.Builder(new NetHttpTransport(), new GsonFactory())
          /**
           * Please change example.com to match with value you are providing while creating
           * subscription as provided in @see <a
           * href="https://github.com/GoogleCloudPlatform/java-docs-samples/tree/main/appengine-java8/pubsub">README</a>.
           */
          .setAudience(Collections.singletonList("example.com"))
          .build();
  private final Gson gson = new Gson();

  @Override
  public void doPost(HttpServletRequest req, HttpServletResponse resp)
      throws IOException, ServletException {

    // Verify that the request originates from the application.
    if (req.getParameter("token").compareTo(pubsubVerificationToken) != 0) {
      resp.setStatus(HttpServletResponse.SC_BAD_REQUEST);
      return;
    }
    // Get the Cloud Pub/Sub-generated JWT in the "Authorization" header.
    String authorizationHeader = req.getHeader("Authorization");
    if (authorizationHeader == null
        || authorizationHeader.isEmpty()
        || authorizationHeader.split(" ").length != 2) {
      resp.setStatus(HttpServletResponse.SC_BAD_REQUEST);
      return;
    }
    String authorization = authorizationHeader.split(" ")[1];

    try {
      // Verify and decode the JWT.
      // Note: For high volume push requests, it would save some network overhead
      // if you verify the tokens offline by decoding them using Google's Public
      // Cert; caching already seen tokens works best when a large volume of
      // messsages have prompted a single push server to handle them, in which
      // case they would all share the same token for a limited time window.
      GoogleIdToken idToken = verifier.verify(authorization);

      GoogleIdToken.Payload payload = idToken.getPayload();
      // IMPORTANT: you should validate claim details not covered by signature
      // and audience verification above, including:
      //   - Ensure that `payload.getEmail()` is equal to the expected service
      //     account set up in the push subscription settings.
      //   - Ensure that `payload.getEmailVerified()` is set to true.

      messageRepository.saveToken(authorization);
      messageRepository.saveClaim(payload.toPrettyString());
      // parse message object from "message" field in the request body json
      // decode message data from base64
      Message message = getMessage(req);
      messageRepository.save(message);
      // 200, 201, 204, 102 status codes are interpreted as success by the Pub/Sub system
      resp.setStatus(102);
      super.doPost(req, resp);
    } catch (Exception e) {
      resp.setStatus(HttpServletResponse.SC_BAD_REQUEST);
    }
  }

  private Message getMessage(HttpServletRequest request) throws IOException {
    String requestBody = request.getReader().lines().collect(Collectors.joining("\n"));
    JsonElement jsonRoot = JsonParser.parseString(requestBody).getAsJsonObject();
    String messageStr = jsonRoot.getAsJsonObject().get("message").toString();
    Message message = gson.fromJson(messageStr, Message.class);
    // decode from base64
    String decoded = decode(message.getData());
    message.setData(decoded);
    return message;
  }

  private String decode(String data) {
    return new String(Base64.getDecoder().decode(data));
  }

  PubSubAuthenticatedPush(MessageRepository messageRepository) {
    this.messageRepository = messageRepository;
  }

  public PubSubAuthenticatedPush() {
    this(MessageRepositoryImpl.getInstance());
  }
}

Node.js

app.post('/pubsub/authenticated-push', jsonBodyParser, async (req, res) => {
  // Verify that the request originates from the application.
  if (req.query.token !== PUBSUB_VERIFICATION_TOKEN) {
    res.status(400).send('Invalid request');
    return;
  }

  // Verify that the push request originates from Cloud Pub/Sub.
  try {
    // Get the Cloud Pub/Sub-generated JWT in the "Authorization" header.
    const bearer = req.header('Authorization');
    const [, token] = bearer.match(/Bearer (.*)/);
    tokens.push(token);

    // Verify and decode the JWT.
    // Note: For high volume push requests, it would save some network
    // overhead if you verify the tokens offline by decoding them using
    // Google's Public Cert; caching already seen tokens works best when
    // a large volume of messages have prompted a single push server to
    // handle them, in which case they would all share the same token for
    // a limited time window.
    const ticket = await authClient.verifyIdToken({
      idToken: token,
      audience: 'example.com',
    });

    const claim = ticket.getPayload();

    // IMPORTANT: you should validate claim details not covered
    // by signature and audience verification above, including:
    //   - Ensure that `claim.email` is equal to the expected service
    //     account set up in the push subscription settings.
    //   - Ensure that `claim.email_verified` is set to true.

    claims.push(claim);
  } catch (e) {
    res.status(400).send('Invalid token');
    return;
  }

  // The message is a unicode string encoded in base64.
  const message = Buffer.from(req.body.message.data, 'base64').toString(
    'utf-8'
  );

  messages.push(message);

  res.status(200).send();
});

Python

@app.route("/push-handlers/receive_messages", methods=["POST"])
def receive_messages_handler():
    # Verify that the request originates from the application.
    if request.args.get("token", "") != current_app.config["PUBSUB_VERIFICATION_TOKEN"]:
        return "Invalid request", 400

    # Verify that the push request originates from Cloud Pub/Sub.
    try:
        # Get the Cloud Pub/Sub-generated JWT in the "Authorization" header.
        bearer_token = request.headers.get("Authorization")
        token = bearer_token.split(" ")[1]
        TOKENS.append(token)

        # Verify and decode the JWT. `verify_oauth2_token` verifies
        # the JWT signature, the `aud` claim, and the `exp` claim.
        # Note: For high volume push requests, it would save some network
        # overhead if you verify the tokens offline by downloading Google's
        # Public Cert and decode them using the `google.auth.jwt` module;
        # caching already seen tokens works best when a large volume of
        # messages have prompted a single push server to handle them, in which
        # case they would all share the same token for a limited time window.
        claim = id_token.verify_oauth2_token(
            token, requests.Request(), audience="example.com"
        )

        # IMPORTANT: you should validate claim details not covered by signature
        # and audience verification above, including:
        #   - Ensure that `claim["email"]` is equal to the expected service
        #     account set up in the push subscription settings.
        #   - Ensure that `claim["email_verified"]` is set to true.

        CLAIMS.append(claim)
    except Exception as e:
        return f"Invalid token: {e}\n", 400

    envelope = json.loads(request.data.decode("utf-8"))
    payload = base64.b64decode(envelope["message"]["data"])
    MESSAGES.append(payload)
    # Returning any 2xx status indicates successful receipt of the message.
    return "OK", 200

Ruby

post "/pubsub/authenticated-push" do
  halt 400 if params[:token] != PUBSUB_VERIFICATION_TOKEN

  begin
    bearer = request.env["HTTP_AUTHORIZATION"]
    token = /Bearer (.*)/.match(bearer)[1]
    claim = Google::Auth::IDTokens.verify_oidc token, aud: "example.com"

    # IMPORTANT: you should validate claim details not covered by signature
    # and audience verification above, including:
    #   - Ensure that `claim["email"]` is equal to the expected service
    #     account set up in the push subscription settings.
    #   - Ensure that `claim["email_verified"]` is set to true.

    claims.push claim
  rescue Google::Auth::IDTokens::VerificationError => e
    puts "VerificationError: #{e.message}"
    halt 400, "Invalid token"
  end

  message = JSON.parse request.body.read
  payload = Base64.decode64 message["message"]["data"]

  messages.push payload
end

Per informazioni sulla variabile di ambiente PUBSUB_VERIFICATION_TOKEN utilizzata negli esempi di codice sopra riportati, consulta Scrittura e risposta ai messaggi Pub/Sub.

Puoi trovare ulteriori esempi su come convalidare il JWT di connessione in questa guida per l'accesso con Google per i siti web. Una panoramica più ampia dei token OpenID è disponibile nella guida alla connessione a OpenID, che include un elenco di librerie client che consentono di convalidare i JWT.

Autenticazione da altri servizi Google Cloud

Cloud Run, App Engine e Cloud Functions autenticano le chiamate HTTP da Pub/Sub verificando i token generati da Pub/Sub. L'unica configurazione di cui hai bisogno è concedere i ruoli IAM necessari all'account chiamante.

Consulta le guide e i tutorial seguenti per diversi casi d'uso con questi servizi:

Cloud Run

Attivazione da push di Pub/Sub: il tuo account di servizio di autenticazione push deve avere il ruolo roles/run.invoker ed essere associato a un servizio Cloud Run per richiamare un servizio Cloud Run corrispondente
Tutorial sull'utilizzo di Pub/Sub con Cloud Run

App Engine

Scrittura e risposta a messaggi Pub/Sub

Cloud Functions

Trigger HTTP: il tuo account di servizio di autenticazione push deve avere il ruolo roles/cloudfunctions.invoker per richiamare una funzione se intendi utilizzare le richieste push di Pub/Sub come trigger HTTP per la funzione
Trigger di Google Cloud Pub/Sub: i ruoli e le autorizzazioni IAM vengono configurati automaticamente se utilizzi i trigger Pub/Sub per richiamare una funzione.

Nota: nei runtime di App Engine di prima generazione, le richieste di push agli URL di endpoint nel formato /_ah/push-handlers/.* nello stesso progetto sono autorizzate come utenti amministratore. Questo meccanismo ACL non è più supportato nei runtime di App Engine di seconda generazione. Nei runtime App Engine di seconda generazione, concedi i ruoli IAM per l'utilizzo amministrativo all'account di servizio di autenticazione push con cui è configurato l'abbonamento push. Per maggiori dettagli, visita le pagine Autenticazione degli utenti e Informazioni sul controllo degli accessi.