Maps Static API: API-Schlüssel und Signatur abrufen

Hinweis: Du kannst dich nicht mehr für die Google Maps Platform-Premiumoption registrieren. Auch für Neukunden ist sie nicht mehr verfügbar.

Authentifizierungsmethode auswählen

Wenn du die Google Maps Platform nutzen möchtest, musst du Anfragen entweder mit einem API-Schlüssel und einer digitalen Signatur ODER mit einer Client-ID und einer digitalen Signatur authentifizieren. Verwende nach Möglichkeit einen API-Schlüssel und eine digitale Signatur, um Client-IDs im Code zu minimieren.

Welche Authentifizierungsmethode du auswählen kannst, richtet sich nach deiner Lizenz:

  • Kunden mit der Premiumoption (Google Maps Platform Premium Plan) können einen API-Schlüssel und eine digitale Signatur ODER eine Client-ID und eine digitale Signatur verwenden.
  • Kunden mit einer älteren Lizenz müssen eine Client-ID und eine digitale Signatur verwenden.

Bei der Entscheidung, welche Authentifizierungsmethode du verwenden möchtest, ist Folgendes zu berücksichtigen:

  • API-Schlüssel (Premium Plan) (bevorzugt): Falls du zur Authentifizierung von Anfragen einen API-Schlüssel verwendest, kannst du
    • alle APIs in der Google Cloud Console auf der Seite „APIs“ verwalten;
    • in der Cloud Console auf Echtzeitnutzungsdaten und Daten zum Nutzungsverlauf für bis zu 30 Tage zugreifen;
    • den Parameter channel zu Anfragen hinzufügen, um ausführlichere Nutzungsberichte zu erhalten;
    • Nutzungsberichte mit Daten für mehr als 30 Tage in der Google Cloud Console aufrufen und
    • deinen API-Schlüssel einschränken, um Missbrauch zu verhindern.
  • Client-ID (Premium Plan oder ältere Lizenz): Wenn du zur Authentifizierung von Anfragen deine Client-ID verwendest, kannst du
    • den Parameter channel zu Anfragen hinzufügen, um ausführlichere Nutzungsberichte zu erhalten;
    • Nutzungsberichte mit Daten für mehr als 30 Tage in der Google Cloud Console aufrufen und
    • Maps Analytics-Tools für die Maps JavaScript API verwenden.

Authentifizierung mit einem API-Schlüssel und einer digitalen Signatur

API-Schlüssel erstellen

Du musst mindestens einen API-Schlüssel mit deinem Projekt verknüpft haben.

So rufst du einen API-Schlüssel ab:

  1. Wechsle zur Cloud Console.
  2. Öffne das Drop-down-Menü für Projekte und wähle das Projekt aus, das beim Erwerb der Premiumoption für dich erstellt wurde. Der Name des Projekts beginnt mit „Google Maps APIs for Business“, „Google Maps for Work“ oder „Google Maps“.

    3. Hinweis: Nutzer mit der Premiumoption sollten das Projekt auswählen, das mit ihrem Premium-Konto verknüpft ist. Nur so können sie alle Funktionen der Premiumoption umfassend nutzen. Als du deine Lizenz erworben hast, wurde dir der Name des entsprechenden Projekts in folgendem Format mitgeteilt: gme-[company] > proj-[number] ([type]). Stelle sicher, dass du auf das richtige Projekt zugreifst. Melde dich dazu in der Console unter console.cloud.google.com/project/number als Projektinhaber an und ersetze dabei number durch deine Projektnummer. Den Projektinhaber findest du in deinem Begrüßungsschreiben.

  3. Klicke auf die Menüschaltfläche  und wähle Google Maps Platform > Anmeldedaten aus.
  4. Klicke auf der Seite Anmeldedaten auf Anmeldedaten erstellen > API-Schlüssel.
    Im Dialogfeld API-Schlüssel erstellt wird der neu generierte API-Schlüssel (ein verschlüsselter String) angezeigt.
  5. Klicke auf Schließen.
    Der neue API-Schlüssel wird auf der Seite Anmeldedaten unter API-Schlüssel aufgeführt.

API-Schlüssel für Anfrage angeben

Für jede Anfrage an die Google Maps Platform muss ein API-Schlüssel angegeben werden. Ersetze YOUR_API_KEY im folgenden Beispiel durch deinen API-Schlüssel.

https://maps.googleapis.com/maps/api/staticmap?center=40.714%2c%20-73.998&zoom=12&size=400x400&key=YOUR_API_KEY

HTTPS ist für Anfragen erforderlich, die einen API-Schlüssel verwenden, und wird empfohlen für Anfragen, die eine Client-ID enthalten. HTTPS ist auch für Anwendungen mit sensiblen Nutzerdaten in Anfragen notwendig, etwa dem Standort des Nutzers.

API-Schlüssel einschränken

Wenn du API-Schlüssel einschränkst, wird deine App sicherer, weil nur autorisierte Anfragen gesendet werden. Wir empfehlen dringend, den Anweisungen zum Einschränken deiner API-Schlüssel zu folgen. Weitere Informationen findest du unter Best Practices für die API-Sicherheit.

So schränkst du einen API-Schlüssel ein:

  1. Rufe Google Maps Platform > Anmeldedaten auf.

    Zur Seite „Anmeldedaten“

  2. Wähle den API-Schlüssel aus, für den du eine Einschränkung festlegen möchtest. Die Seite mit den Eigenschaften des API-Schlüssels wird angezeigt.
  3. Nimm unter Schlüsseleinschränkungen folgende Einstellungen vor:
    • App-Einschränkungen:
      1. Wenn du Anfragen von der Liste von Websites zulassen möchtest, die du selbst bereitgestellt hast, wähle in der Liste der Anwendungseinschränkungen den Eintrag HTTP-Verweis-URLs (Websites) aus.
      2. Gib eine oder mehrere Verweis-URLs (Websites) an. Beispiel: *.google.com akzeptiert alle Websites, die auf google.com enden, wie beispielsweise https://developers.google.com.

        Hinweis: Für Verweis-URLs vom Typ „file://“ muss der Schlüsseleinschränkung eine besondere Darstellung hinzugefügt werden. Der Teil „file://“ muss durch „/_file_url__“ ersetzt werden, bevor er der Schlüsseleinschränkung hinzugefügt wird. Beispiel: „file:///path/to/“ sollte das Format „__file_url__//path/to/*“ haben. Nachdem du Verweis-URLs vom Typ „file://“ aktiviert hast, solltest du die Nutzung regelmäßig überprüfen, um zu gewährleisten, dass sie deinen Erwartungen entspricht.

    • API-Einschränkungen:
      1. Klicke auf Schlüssel einschränken.
      2. Klicke im Drop-down-Menü APIs auswählen auf Google Maps Platform. Wenn die Google Maps Platform nicht aufgeführt ist, musst du sie aktivieren.
  4. Klicke abschließend auf Speichern.

Digitale Signatur generieren

Anfragen an die Google Maps Platform mit einem key-Parameter, der einen API-Schlüssel enthält, müssen auch einen signature-Parameter einschließen, der eine digitale Signatur enthält, die du mit einem gemeinsamen URL-Signatur-Secret generieren musst. Dein gemeinsames Secret ist in der Google Cloud Console verfügbar.

Beim Signaturvorgang wird ein Verschlüsselungsalgorithmus verwendet, um die URL und dein gemeinsames Secret zu kombinieren. Anhand der sich ergebenden eindeutigen Signatur kann von unseren Servern geprüft werden, ob Anfragen zur Websitegenerierung, bei denen dein API-Schlüssel verwendet wird, entsprechend autorisiert sind.

Eine digitale Signatur wird in zwei Schritten erstellt:

Schritt 1: URL-Signatur-Secret abrufen

Das kryptografische URL-Signatur-Secret ist in der Cloud Console verfügbar. Das Secret, auch als privater Schlüssel bezeichnet, wird in einem modifizierten Base64-Format für URLs codiert. Dieses Secret wird zwischen dir und Google geteilt und ist für deinen API-Schlüssel eindeutig. Achte darauf, dass dein URL-Signatur-Secret sicher ist. Es darf nicht in Anfragen übergeben, auf Websites gespeichert oder in öffentlichen Foren gepostet werden. Sollten Dritte Zugriff auf dein URL-Signatur-Secret erhalten, können sie deine Identität verwenden, um Anfragen zu senden.

Dein URL-Signatur-Secret kannst du auf dieser Seite in der Cloud Console abrufen. Wichtig: Du musst das Projekt auswählen, das für dich erstellt wurde, als du die Premiumoption erworben hast.

Alternativ kannst du dein URL-Signatur-Secret auch so abrufen:

  1. Wechsle zur Cloud Console.
  2. Klicke auf das Drop-down-Menü für Projekte und wähle das Projekt aus, das beim Erwerb der Premiumoption für dich erstellt wurde. Der Name des Projekts beginnt mit „Google Maps APIs for Business“, „Google Maps for Work“ oder „Google Maps“.
  3. Klicke auf der Dashboard-Seite in der Liste der APIs auf den Namen der Google Maps Platform. Daraufhin werden die API-Details angezeigt. Der Tab Übersicht ist geöffnet.
  4. Klicke auf den Tab URL-Signatur-Secret.

Klicke auf Secret neu generieren, um ein neues URL-Signatur-Secret anzufordern. Die Gültigkeit des vorherigen Secrets läuft 24 Stunden nach Generierung eines neuen ab. Nach Ablauf von 24 Stunden funktionieren Anfragen mit dem alten Secret nicht mehr.

Schritt 2: Digitale Signatur generieren

Informationen zum Erstellen einer digitalen Signatur für deine Anfrage findest du unter Digitale Signatur mit einem API-Schlüssel generieren.

Authentifizierung mit einer Client-ID und digitalen Signatur

Client-ID und kryptografischer Schlüssel

Beim Erwerb der Premiumoption (Google Maps Platform Premium Plan) erhältst du von Google eine Begrüßungs-E-Mail mit deiner Client-ID und deinem privaten kryptografischen Schlüssel.

  • Mit deiner Client-ID erhältst du Zugriff auf die Sonderfunktionen des Google Maps Platform Premium Plan. Ersetze im folgenden Beispiel YOUR_CLIENT_ID durch die Client-ID aus der Begrüßungs-E-Mail. Alle Client-IDs beginnen mit dem Präfix gme-.

  • Dein privater kryptografischer Schlüssel wird verwendet, um eine eindeutige digitale Signatur zu generieren. Ersetze im Codebeispiel unten SIGNATURE durch deine eindeutige digitale Signatur. Weitere Informationen findest du unter Digitale Signatur mit einer Client-ID generieren. 

    <img src="https://maps.googleapis.com/maps/api/staticmap
      ?center=-15.800513,-47.91378
      &zoom=11
      &size=300x300
      &client=YOUR_CLIENT_ID
      &signature=SIGNATURE">

Wenn du deine Client-ID oder deinen privaten kryptografischen Schlüssel verloren hast, melde dich in der Google Cloud Console an und klicke links auf Maps: Manage Client ID (Maps: Client-ID verwalten), um die ID bzw. den Schlüssel wiederherzustellen.

Optionaler Parameter für Berichte

Wenn die API-Authentifizierung mit einer Client-ID erfolgt, kann der folgende optionale Parameter verwendet werden:

  • channel wird zur Bereitstellung zusätzlicher Berichtsdetails verwendet, indem verschiedene Kanäle in deinen Berichten getrennt voneinander gruppiert werden. Weitere Informationen findest du unter Premium Plan Reporting Overview (in englischer Sprache).

Digitale Signatur generieren

Informationen zum Erstellen einer digitalen Signatur für deine Anfrage findest du unter Digitale Signatur mit einer Client-ID generieren.

Digitale Signaturen

Funktionsweise digitaler Signaturen

Digitale Signaturen werden mit einem kryptografischen URL-Signatur-Secret generiert, das in der Google Cloud Console verfügbar ist. Das Secret, auch als privater Schlüssel bezeichnet, wird in einem modifizierten Base64-Format für URLs codiert. Dieses Secret wird zwischen dir und Google geteilt und ist für deinen API-Schlüssel eindeutig.

Beim Signaturvorgang wird ein Verschlüsselungsalgorithmus verwendet, um die URL und dein gemeinsames Secret zu kombinieren. Anhand der sich ergebenden eindeutigen Signatur kann von unseren Servern geprüft werden, ob Anfragen zur Websitegenerierung, bei denen dein API-Schlüssel verwendet wird, entsprechend autorisiert sind.

Eine digitale Signatur kann mit einem API-Schlüssel oder einer Client-ID generiert werden.

Digitale Signatur mit einem API-Schlüssel generieren

So erstellst du eine digitale Signatur, die zusammen mit einem API-Schlüssel verwendet wird:

  1. Erstelle die Anfrage-URL ohne Signatur. Füge dabei deinen API-Schlüssel in den Parameter key ein. Für Nichtstandardzeichen musst du eine URL-Codierung durchführen. Beispiel:

    https://maps.googleapis.com/maps/api/staticmap?center=40.714%2c%20-73.998&zoom=12&size=400x400&key=YOUR_API_KEY

    Hinweis: Bei allen Google-Diensten müssen die Zeichen im UTF-8-Format codiert sein. Das umfasst implizit alle ASCII-Zeichen. Falls deine Anwendungen andere Zeichensätze verwenden, müssen die URLs mit UTF-8-Codierung erstellt und ordnungsgemäß prozentcodiert werden.

  2. Entferne den Domainabschnitt der Anfrage, sodass nur Pfad und Abfrage übrig bleiben:

    /maps/api/staticmap?center=40.714%2c%20-73.998&zoom=12&size=400x400&key=YOUR_API_KEY

  3. Rufe dein URL-Signatur-Secret, das in einem modifizierten Base64-Verfahren für URLs codiert ist, von der Cloud Console ab und signiere die URL oben mit dem HMAC-SHA1-Algorithmus (siehe URL-Signatur-Secret abrufen).

    Eventuell musst du dein Secret in das ursprüngliche Binärformat decodieren. In den meisten kryptografischen Bibliotheken liegt die resultierende Signatur im Binärformat vor.

    Hinweis: Beim modifizierten Base64-Verfahren für URLs werden die Zeichen + und / des Base64-Standardverfahrens durch - bzw. _ ersetzt. Deshalb ist bei diesen Base64-Signaturen keine URL-Codierung mehr erforderlich.

  4. Codiere die resultierende binäre Signatur mit dem modifizierten Base64-Verfahren für URLs und konvertiere die Signatur so, dass sie in einer URL weitergegeben werden kann.

  5. Füge der Anfrage-URL die resultierende Signatur innerhalb eines signature-Parameters hinzu. Beispiel:

    https://maps.googleapis.com/maps/api/staticmap?center=40.714%2c%20-73.998&zoom=12&size=400x400&key=YOUR_API_KEY&signature=BASE64_SIGNATURE

Beispiele für Möglichkeiten zur Implementierung der URL-Signatur mit serverseitigem Code findest du unter Beispielcode für URL-Signaturen.

Um jetzt eine URL zu signieren, gib nachfolgend deine URL und deinen geheimen URL-Schlüssel ein. Die URL muss das oben in Schritt 1 beschriebene Format haben und URL-codiert sein.

Digitale Signatur mit einer Client-ID generieren

Anfragen an die Static Maps API mithilfe des client-Parameters erfordern auch eine digitale signature, die mit dem in der Begrüßungs-E-Mail bereitgestellten privaten kryptografischen Schlüssel generiert wurde.

Beim Signiervorgang werden eine URL und der Schlüssel über einen Verschlüsselungsalgorithmus miteinander kombiniert. Anhand der resultierenden eindeutigen Signatur können unsere Server verifizieren, ob Websites, die Anfragen mit deiner Client-ID erstellen, dazu auch autorisiert sind. Darüber hinaus ist die Signatur für jede URL eindeutig. So wird sichergestellt, dass Anfragen, die deine Client-ID verwenden, nicht geändert werden können, ohne dass eine neue Signatur generiert werden muss.

Dein privater kryptografischer Schlüssel

Dein privater kryptografischer URL-Signaturschlüssel wird zusammen mit deiner Client-ID ausgegeben. Dabei handelt es sich um einen „gemeinsamen Secret-Schlüssel“, den du mit Google teilst. Dieser Signaturschlüssel gehört nur dir und ist deiner Client-ID eindeutig zugeordnet. Halte ihn also bitte geheim. Er darf nicht in Anfragen übergeben, auf Websites gespeichert oder in öffentlichen Foren gepostet werden. Sollten Dritte Zugriff auf deinen Signaturschlüssel erhalten, können sie deine Identität verwenden, um Anfragen zu senden.

Hinweis: Dieser private kryptografische Signaturschlüssel ist nicht mit den API-Schlüsseln identisch, die von der Google Cloud Console ausgegeben werden.

Wenn du deinen privaten kryptografischen Schlüssel verloren hast, meldest du dich in der Cloud Console an und klickst auf Maps: Client-ID verwalten (Maps: Client-ID verwalten), um ihn abzurufen.

Digitale Signatur mit einer Client-ID generieren

Wird versucht, mit einer ungültigen Signatur auf die Static Maps API zuzugreifen, wird der Fehler „HTTP 403 (Forbidden)“ zurückgegeben. Wenn du deine Anwendungen auf die Verwendung der URL-Signatur umstellst, solltest du unbedingt deine Signaturen testen. So lässt sich feststellen, ob damit gültige Anfragen gestartet werden. Teste dabei zuerst, ob die ursprüngliche URL gültig ist und ob du die richtigen Signaturen generierst.

So erstellst du eine digitale Signatur für deine Anfrage:

  1. Erstelle die Anfrage-URL ohne Signatur, aber mit dem Parameter client. Dabei müssen alle Sonderzeichen prozentcodiert werden:

    https://maps.googleapis.com/maps/api/staticmap?center=40.714%2c%20-73.998&zoom=12&size=400x400&client=clientID

    Hinweis: Für alle Google-Dienste muss die UTF-8-Zeichencodierung verwendet werden. Das schließt ASCII-Zeichen implizit ein. Falls deine Anwendungen andere Zeichensätze verwenden, müssen die URLs mit UTF-8-Codierung erstellt und ordnungsgemäß prozentcodiert werden.

  2. Entferne den Domainabschnitt der Anfrage, sodass nur Pfad und Abfrage übrig bleiben:

    /maps/api/staticmap?center=40.714%2c%20-73.998&zoom=12&size=400x400&client=clientID

  3. Rufe deinen privaten Schlüssel ab, der mit einem modifizierten Base64-Verfahren für URLs codiert ist, und signiere die URL oben mit dem HMAC-SHA1-Algorithmus. Eventuell muss der Schlüssel in sein ursprüngliches Binärformat decodiert werden. In den meisten kryptografischen Bibliotheken liegt die resultierende Signatur im Binärformat vor.

    Hinweis: Beim modifizierten Base64-Verfahren für URLs werden die Zeichen + und / des Base64-Standardverfahrens durch - bzw. _ ersetzt. Deshalb ist bei diesen Base64-Signaturen keine URL-Codierung mehr erforderlich.

  4. Codiere die resultierende binäre Signatur mit dem modifizierten Base64-Verfahren für URLs und konvertiere die Signatur so, dass sie in einer URL weitergegeben werden kann.

  5. Füge diese Signatur innerhalb eines signature-Parameters an die URL an:

    https://maps.googleapis.com/maps/api/staticmap?center=40.714%2c%20-73.998&zoom=12&size=400x400&client=clientID&signature=base64signature

Beispiele für Möglichkeiten zur Implementierung der URL-Signatur mit serverseitigem Code findest du unter Beispielcode für URL-Signaturen.

Um jetzt eine URL zu signieren, gib nachfolgend deine URL und deinen geheimen URL-Schlüssel ein. Die URL muss das oben in Schritt 1 beschriebene Format haben und URL-codiert sein.

Beispielcode für URL-Signaturen

In den folgenden Abschnitten findest du Möglichkeiten zur Implementierung der URL-Signatur mit serverseitigem Code. URLs müssen immer serverseitig signiert werden, damit der kryptografische Schlüssel nicht für Nutzer sichtbar ist.

Python

Im Beispiel unten werden Python-Standardbibliotheken verwendet, um eine URL zu signieren. Hier kannst du den Code herunterladen.

#!/usr/bin/python
# -*- coding: utf-8 -*-
""" Signs a URL using a URL signing secret """

import hashlib
import hmac
import base64
import urllib.parse as urlparse

def sign_url(input_url=None, secret=None):
    """ Sign a request URL with a URL signing secret.
      Usage:
      from urlsigner import sign_url
      signed_url = sign_url(input_url=my_url, secret=SECRET)
      Args:
      input_url - The URL to sign
      secret    - Your URL signing secret
      Returns:
      The signed request URL
  """

    if not input_url or not secret:
        raise Exception("Both input_url and secret are required")

    url = urlparse.urlparse(input_url)

    # We only need to sign the path+query part of the string
    url_to_sign = url.path + "?" + url.query

    # Decode the private key into its binary format
    # We need to decode the URL-encoded private key
    decoded_key = base64.urlsafe_b64decode(secret)

    # Create a signature using the private key and the URL-encoded
    # string using HMAC SHA1. This signature will be binary.
    signature = hmac.new(decoded_key, str.encode(url_to_sign), hashlib.sha1)

    # Encode the binary signature into base64 for use within a URL
    encoded_signature = base64.urlsafe_b64encode(signature.digest())

    original_url = url.scheme + "://" + url.netloc + url.path + "?" + url.query

    # Return signed URL
    return original_url + "&signature=" + encoded_signature.decode()

if __name__ == "__main__":
    input_url = input("URL to Sign: ")
    secret = input("URL signing secret: ")
    print("Signed URL: " + sign_url(input_url, secret))

Java

Im Beispiel unten wird die Klasse java.util.Base64 verwendet, die seit JDK 1.8 verfügbar ist. Für ältere Versionen muss möglicherweise Apache Commons o. ä. verwendet werden. Hier kannst du den Code herunterladen.

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URISyntaxException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;  // JDK 1.8 only - older versions may need to use Apache Commons or similar.
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class UrlSigner {

  // Note: Generally, you should store your private key someplace safe
  // and read them into your code

  private static String keyString = "YOUR_PRIVATE_KEY";

  // The URL shown in these examples is a static URL which should already
  // be URL-encoded. In practice, you will likely have code
  // which assembles your URL from user or web service input
  // and plugs those values into its parameters.
  private static String urlString = "YOUR_URL_TO_SIGN";

  // This variable stores the binary key, which is computed from the string (Base64) key
  private static byte[] key;

  public static void main(String[] args) throws IOException,
    InvalidKeyException, NoSuchAlgorithmException, URISyntaxException {

    BufferedReader input = new BufferedReader(new InputStreamReader(System.in));

    String inputUrl, inputKey = null;

    // For testing purposes, allow user input for the URL.
    // If no input is entered, use the static URL defined above.
    System.out.println("Enter the URL (must be URL-encoded) to sign: ");
    inputUrl = input.readLine();
    if (inputUrl.equals("")) {
      inputUrl = urlString;
    }

    // Convert the string to a URL so we can parse it
    URL url = new URL(inputUrl);

    // For testing purposes, allow user input for the private key.
    // If no input is entered, use the static key defined above.
    System.out.println("Enter the Private key to sign the URL: ");
    inputKey = input.readLine();
    if (inputKey.equals("")) {
      inputKey = keyString;
    }

    UrlSigner signer = new UrlSigner(inputKey);
    String request = signer.signRequest(url.getPath(),url.getQuery());

    System.out.println("Signed URL :" + url.getProtocol() + "://" + url.getHost() + request);
  }

  public UrlSigner(String keyString) throws IOException {
    // Convert the key from 'web safe' base 64 to binary
    keyString = keyString.replace('-', '+');
    keyString = keyString.replace('_', '/');
    System.out.println("Key: " + keyString);
    // Base64 is JDK 1.8 only - older versions may need to use Apache Commons or similar.
    this.key = Base64.getDecoder().decode(keyString);
  }

  public String signRequest(String path, String query) throws NoSuchAlgorithmException,
    InvalidKeyException, UnsupportedEncodingException, URISyntaxException {

    // Retrieve the proper URL components to sign
    String resource = path + '?' + query;

    // Get an HMAC-SHA1 signing key from the raw key bytes
    SecretKeySpec sha1Key = new SecretKeySpec(key, "HmacSHA1");

    // Get an HMAC-SHA1 Mac instance and initialize it with the HMAC-SHA1 key
    Mac mac = Mac.getInstance("HmacSHA1");
    mac.init(sha1Key);

    // compute the binary signature for the request
    byte[] sigBytes = mac.doFinal(resource.getBytes());

    // base 64 encode the binary signature
    // Base64 is JDK 1.8 only - older versions may need to use Apache Commons or similar.
    String signature = Base64.getEncoder().encodeToString(sigBytes);

    // convert the signature to 'web safe' base 64
    signature = signature.replace('+', '-');
    signature = signature.replace('/', '_');

    return resource + "&signature=" + signature;
  }
}

Node.js

Im Beispiel unten werden native Node.js-Module verwendet, um eine URL zu signieren. Hier kannst du den Code herunterladen.

'use strict'

const crypto = require('crypto');
const url = require('url');

/**
 * Convert from 'web safe' base64 to true base64.
 *
 * @param  {string} safeEncodedString The code you want to translate
 *                                    from a web safe form.
 * @return {string}
 */
function removeWebSafe(safeEncodedString) {
  return safeEncodedString.replace(/-/g, '+').replace(/_/g, '/');
}

/**
 * Convert from true base64 to 'web safe' base64
 *
 * @param  {string} encodedString The code you want to translate to a
 *                                web safe form.
 * @return {string}
 */
function makeWebSafe(encodedString) {
  return encodedString.replace(/\+/g, '-').replace(/\//g, '_');
}

/**
 * Takes a base64 code and decodes it.
 *
 * @param  {string} code The encoded data.
 * @return {string}
 */
function decodeBase64Hash(code) {
  // "new Buffer(...)" is deprecated. Use Buffer.from if it exists.
  return Buffer.from ? Buffer.from(code, 'base64') : new Buffer(code, 'base64');
}

/**
 * Takes a key and signs the data with it.
 *
 * @param  {string} key  Your unique secret key.
 * @param  {string} data The url to sign.
 * @return {string}
 */
function encodeBase64Hash(key, data) {
  return crypto.createHmac('sha1', key).update(data).digest('base64');
}

/**
 * Sign a URL using a secret key.
 *
 * @param  {string} path   The url you want to sign.
 * @param  {string} secret Your unique secret key.
 * @return {string}
 */
function sign(path, secret) {
  const uri = url.parse(path);
  const safeSecret = decodeBase64Hash(removeWebSafe(secret));
  const hashedSignature = makeWebSafe(encodeBase64Hash(safeSecret, uri.path));
  return url.format(uri) + '&signature=' + hashedSignature;
}

C#

Im Beispiel unten wird die Standardbibliothek System.Security.Cryptography verwendet, um eine URL-Anfrage zu signieren. Wir müssen die Base64-Standardcodierung konvertieren, um eine URL-sichere Version zu implementieren. Hier kannst du den Code herunterladen.

using System;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Web;

namespace SignUrl {

  public struct GoogleSignedUrl {

    public static string Sign(string url, string keyString) {
      ASCIIEncoding encoding = new ASCIIEncoding();

      // converting key to bytes will throw an exception, need to replace '-' and '_' characters first.
      string usablePrivateKey = keyString.Replace("-", "+").Replace("_", "/");
      byte[] privateKeyBytes = Convert.FromBase64String(usablePrivateKey);

      Uri uri = new Uri(url);
      byte[] encodedPathAndQueryBytes = encoding.GetBytes(uri.LocalPath + uri.Query);

      // compute the hash
      HMACSHA1 algorithm = new HMACSHA1(privateKeyBytes);
      byte[] hash = algorithm.ComputeHash(encodedPathAndQueryBytes);

      // convert the bytes to string and make url-safe by replacing '+' and '/' characters
      string signature = Convert.ToBase64String(hash).Replace("+", "-").Replace("/", "_");

      // Add the signature to the existing URI.
      return uri.Scheme+"://"+uri.Host+uri.LocalPath + uri.Query +"&signature=" + signature;
    }
  }

  class Program {

    static void Main() {

      // Note: Generally, you should store your private key someplace safe
      // and read them into your code

      const string keyString = "YOUR_PRIVATE_KEY";

      // The URL shown in these examples is a static URL which should already
      // be URL-encoded. In practice, you will likely have code
      // which assembles your URL from user or web service input
      // and plugs those values into its parameters.
      const  string urlString = "YOUR_URL_TO_SIGN";

      string inputUrl = null;
      string inputKey = null;

      Console.WriteLine("Enter the URL (must be URL-encoded) to sign: ");
      inputUrl = Console.ReadLine();
      if (inputUrl.Length == 0) {
        inputUrl = urlString;
      }

      Console.WriteLine("Enter the Private key to sign the URL: ");
      inputKey = Console.ReadLine();
      if (inputKey.Length == 0) {
        inputKey = keyString;
      }

      Console.WriteLine(GoogleSignedUrl.Sign(inputUrl,inputKey));
    }
  }
}

Beispiele in weiteren Sprachen

Beispiele für weitere Sprachen findest du hier.

Authentifizierungsprobleme beheben

Falls die Anfrage nicht richtig formatiert ist oder eine ungültige Signatur enthält, wird von der Google Maps Platform der Fehler HTTP 403 (Forbidden) zurückgegeben.

Wenn du Fehler für einzelne URLs beheben musst, kannst du den URL Signing Debugger verwenden. Mit ihm lässt sich eine URL und eine von deiner Anwendung generierte Signatur schnell validieren.

Nutzer mit Premiumoption, die Fehler für einzelne URLs beheben müssen, haben außerdem die Möglichkeit, sich in der Cloud Console anzumelden und dort Resources > Google Maps Platform Premium Plan online tools > URL Signing Debugger for Web Service and Image APIs (Ressourcen > Onlinetools der Google Maps Platform-Premiumoption > URL-Signaturdebugger für Web Service und Image APIs) auszuwählen.