Melindungi akun pengguna dengan Perlindungan Lintas Akun

Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

Jika aplikasi Anda mengizinkan pengguna login ke akun mereka menggunakan Google, Anda dapat meningkatkan keamanan akun pengguna bersama tersebut dengan memproses dan merespons notifikasi peristiwa keamanan yang disediakan oleh layanan Perlindungan Lintas Akun.

Notifikasi ini memberi tahu Anda tentang perubahan besar pada Akun Google pengguna Anda, yang sering kali juga dapat menimbulkan implikasi keamanan bagi akun pengguna dengan aplikasi Anda. Misalnya, jika Akun Google pengguna dibajak, hal ini berpotensi menyebabkan penyusupan akun pengguna dengan aplikasi Anda melalui pemulihan akun email atau penggunaan Single Sign-On.

Untuk membantu Anda mengurangi potensi risiko peristiwa tersebut, Google mengirimkan objek layanan yang disebut token peristiwa keamanan. Token ini mengekspos sedikit sekali informasi, yaitu jenis peristiwa keamanan dan kapan terjadinya, serta pengenal pengguna yang terpengaruh, tetapi Anda dapat menggunakannya untuk mengambil tindakan yang tepat sebagai respons. Misalnya, jika Akun Google pengguna disusupi, Anda dapat menonaktifkan sementara Login dengan Google untuk pengguna tersebut dan mencegah email pemulihan akun dikirim ke alamat Gmail pengguna.

Perlindungan Lintas Akun didasarkan pada standar RISC, yang dikembangkan di OpenID Foundation.

Ringkasan

Untuk menggunakan Perlindungan Lintas Akun dengan aplikasi atau layanan, Anda harus menyelesaikan tugas-tugas berikut:

  1. Siapkan project Anda di API Console.

  2. Membuat endpoint penerima peristiwa, yang akan dikirimi token peristiwa keamanan ke Google. Endpoint ini bertanggung jawab untuk memvalidasi token yang diterima dan merespons peristiwa keamanan dengan cara apa pun yang Anda pilih.

  3. Daftarkan endpoint Anda ke Google untuk mulai menerima token peristiwa keamanan.

Prasyarat

Anda hanya menerima token peristiwa keamanan untuk pengguna Google yang telah memberikan izin kepada layanan Anda untuk mengakses informasi profil atau alamat email mereka. Anda mendapatkan izin ini dengan meminta cakupan profile atau email. Login dengan Google yang lebih baru atau SDK Login dengan Google yang lama secara default meminta cakupan ini. Namun, jika Anda tidak menggunakan setelan default, atau jika Anda mengakses endpoint Connect Open Google secara langsung, pastikan Anda meminta setidaknya salah satu cakupan ini.

Siapkan project di API Console

Sebelum dapat mulai menerima token peristiwa keamanan, Anda harus membuat akun layanan dan mengaktifkan RISC API di projectAPI Console Anda. Anda harus menggunakan project API Console yang sama dengan yang digunakan untuk mengakses layanan Google, seperti Login dengan Google, di aplikasi Anda.

Untuk membuat akun layanan:

  1. Buka API Console Credentials page. Jika diminta, pilih project API Console yang Anda gunakan untuk mengakses layanan Google di aplikasi.

  2. Klik Create credentials > Service account.

  3. Buat akun layanan baru dengan peran Editor.

  4. Buat kunci untuk akun layanan yang baru dibuat. Pilih jenis kunci JSON, lalu klik Create. Saat kunci dibuat, Anda akan mendownload file JSON yang berisi kredensial akun layanan. Simpan file ini di tempat yang aman, tetapi juga dapat diakses oleh endpoint penerima peristiwa Anda.

Saat Anda berada di halaman Kredensial project, catat juga ID klien yang Anda gunakan untuk Login dengan Google atau Login dengan Google (lama). Biasanya, Anda memiliki client ID untuk setiap platform yang didukung. Anda akan memerlukan client ID ini untuk memvalidasi token peristiwa keamanan, seperti yang dijelaskan di bagian berikutnya.

Untuk mengaktifkan RISC API:

  1. Buka halaman API RISC di API Console. Pastikan project yang Anda gunakan untuk mengakses layanan Google masih dipilih.

  2. Baca Persyaratan RISC dan pastikan Anda memahami persyaratannya.

    Jika Anda mengaktifkan API untuk project yang dimiliki oleh organisasi, pastikan Anda telah diberi otorisasi untuk mengikat organisasi ke Persyaratan RISC.

  3. Klik Enable hanya jika Anda menyetujui Persyaratan RISC.

Membuat endpoint penerima peristiwa

Untuk menerima notifikasi peristiwa keamanan dari Google, Anda membuat endpoint HTTPS yang menangani permintaan HTTPS POST. Setelah Anda mendaftarkan endpoint ini (lihat di bawah), Google akan mulai memposting string yang ditandatangani secara kriptografis yang disebut token peristiwa keamanan ke endpoint. Token peristiwa keamanan adalah JWT yang ditandatangani yang berisi informasi tentang satu peristiwa terkait keamanan.

Untuk setiap token peristiwa keamanan yang Anda terima pada endpoint, validasikan dan mendekode token terlebih dahulu, lalu tangani peristiwa keamanan yang sesuai untuk layanan Anda. Penting validasikan token peristiwa sebelum decoding untuk mencegah serangan berbahaya dari pihak tidak bertanggung jawab. Bagian berikut ini menjelaskan tugas tersebut:

1. Mendekode dan memvalidasi token peristiwa keamanan

Karena token peristiwa keamanan adalah jenis JWT tertentu, Anda dapat menggunakan semua library JWT, seperti yang tercantum di jwt.io, untuk mendekode dan memvalidasinya. Apa pun library yang Anda gunakan, kode validasi token harus melakukan hal berikut:

  1. Dapatkan ID penerbit Perlindungan Lintas Akun (issuer) dan URI sertifikat kunci penandatanganan (jwks_uri) dari dokumen konfigurasi RISC Google, yang dapat Anda temukan di https://accounts.google.com/.well-known/risc-configuration.
  2. Dengan library JWT pilihan Anda, dapatkan ID kunci penandatanganan dari header token peristiwa keamanan.
  3. Dari dokumen sertifikat kunci penandatanganan Google, dapatkan kunci publik dengan ID kunci yang Anda dapatkan pada langkah sebelumnya. Jika dokumen tidak berisi kunci dengan ID yang Anda cari, kemungkinan token peristiwa keamanan tidak valid, dan endpoint Anda harus menampilkan error HTTP 400.
  4. Dengan menggunakan library JWT pilihan Anda, pastikan hal-hal berikut:
    • Token peristiwa keamanan ditandatangani menggunakan kunci publik yang Anda dapatkan di langkah sebelumnya.
    • Klaim aud token adalah salah satu aplikasi klien Anda.
    • Klaim iss token cocok dengan ID penerbit yang Anda dapatkan dari dokumen penemuan RISC. Perhatikan bahwa Anda tidak perlu memverifikasi akhir masa berlaku token (exp) karena token peristiwa keamanan mewakili peristiwa historis dan, dengan demikian, masa berlaku token tidak berakhir.

Contoh:

Java

Menggunakan java-jwt dan jwks-rsa-java:

public DecodedJWT validateSecurityEventToken(String token) {
    DecodedJWT jwt = null;
    try {
        // In a real implementation, get these values from
        // https://accounts.google.com/.well-known/risc-configuration
        String issuer = "accounts.google.com";
        String jwksUri = "https://www.googleapis.com/oauth2/v3/certs";

        // Get the ID of the key used to sign the token.
        DecodedJWT unverifiedJwt = JWT.decode(token);
        String keyId = unverifiedJwt.getKeyId();

        // Get the public key from Google.
        JwkProvider googleCerts = new UrlJwkProvider(new URL(jwksUri), null, null);
        PublicKey publicKey = googleCerts.get(keyId).getPublicKey();

        // Verify and decode the token.
        Algorithm rsa = Algorithm.RSA256((RSAPublicKey) publicKey, null);
        JWTVerifier verifier = JWT.require(rsa)
                .withIssuer(issuer)
                // Get your apps' client IDs from the API console:
                // https://console.developers.google.com/apis/credentials?project=_
                .withAudience("123456789-abcedfgh.apps.googleusercontent.com",
                              "123456789-ijklmnop.apps.googleusercontent.com",
                              "123456789-qrstuvwx.apps.googleusercontent.com")
                .acceptLeeway(Long.MAX_VALUE)  // Don't check for expiration.
                .build();
        jwt = verifier.verify(token);
    } catch (JwkException e) {
        // Key not found. Return HTTP 400.
    } catch (InvalidClaimException e) {

    } catch (JWTDecodeException exception) {
        // Malformed token. Return HTTP 400.
    } catch (MalformedURLException e) {
        // Invalid JWKS URI.
    }
    return jwt;
}

Python

import json
import jwt       # pip install pyjwt
import requests  # pip install requests

def validate_security_token(token, client_ids):
    # Get Google's RISC configuration.
    risc_config_uri = 'https://accounts.google.com/.well-known/risc-configuration'
    risc_config = requests.get(risc_config_uri).json()

    # Get the public key used to sign the token.
    google_certs = requests.get(risc_config['jwks_uri']).json()
    jwt_header = jwt.get_unverified_header(token)
    key_id = jwt_header['kid']
    public_key = None
    for key in google_certs['keys']:
        if key['kid'] == key_id:
            public_key = jwt.algorithms.RSAAlgorithm.from_jwk(json.dumps(key))
    if not public_key:
        raise Exception('Public key certificate not found.')
        # In this situation, return HTTP 400

    # Decode the token, validating its signature, audience, and issuer.
    try:
        token_data = jwt.decode(token, public_key, algorithms='RS256',
                                options={'verify_exp': False},
                                audience=client_ids, issuer=risc_config['issuer'])
    except:
        raise
        # Validation failed. Return HTTP 400.
    return token_data

# Get your apps' client IDs from the API console:
# https://console.developers.google.com/apis/credentials?project=_
client_ids = ['123456789-abcedfgh.apps.googleusercontent.com',
              '123456789-ijklmnop.apps.googleusercontent.com',
              '123456789-qrstuvwx.apps.googleusercontent.com']
token_data = validate_security_token(token, client_ids)

Jika token valid dan berhasil didekode, tampilkan status HTTP 202. Kemudian, tangani peristiwa keamanan yang ditunjukkan dengan token.

2. Menangani peristiwa keamanan

Saat didekode, token peristiwa keamanan akan terlihat seperti contoh berikut:

{
  "iss": "https://accounts.google.com/",
  "aud": "123456789-abcedfgh.apps.googleusercontent.com",
  "iat": 1508184845,
  "jti": "756E69717565206964656E746966696572",
  "events": {
    "https://schemas.openid.net/secevent/risc/event-type/account-disabled": {
      "subject": {
        "subject_type": "iss-sub",
        "iss": "https://accounts.google.com/",
        "sub": "7375626A656374"
      },
      "reason": "hijacking"
    }
  }
}

Klaim iss dan aud menunjukkan penerbit token (Google) dan penerima token yang dimaksud (layanan Anda). Anda telah memverifikasi klaim ini pada langkah sebelumnya.

Klaim jti adalah string yang mengidentifikasi satu peristiwa keamanan, dan unik untuk aliran data. Anda dapat menggunakan ID ini untuk melacak peristiwa keamanan yang telah diterima.

Klaim events berisi informasi tentang peristiwa keamanan yang diwakili oleh token. Klaim ini merupakan pemetaan dari ID jenis peristiwa ke klaim subject, yang menentukan pengguna yang berkaitan dengan peristiwa ini, dan detail tambahan tentang peristiwa yang mungkin tersedia.

Klaim subject mengidentifikasi pengguna tertentu dengan ID Akun Google unik (sub) milik pengguna tersebut. ID Akun Google ini adalah ID yang sama (sub) yang terdapat dalam token ID JWT yang dikeluarkan oleh library Login dengan Google yang lebih baru (JavaScript, HTML), library Login dengan Google lama, atau OpenID Connect. Jika subject_type klaimnya adalah id_token_claims, kolom ini mungkin juga menyertakan kolom email dengan alamat email pengguna.

Gunakan informasi dalam klaim events untuk mengambil tindakan yang sesuai bagi jenis peristiwa pada akun pengguna yang ditentukan.

ID token OAuth

Untuk peristiwa OAuth tentang token individual, jenis ID subjek token berisi kolom berikut:

  • token_type: Hanya refresh_token yang didukung.

  • token_identifier_alg: Lihat tabel di bawah untuk mengetahui kemungkinan nilai.

  • token: Lihat tabel di bawah.

ID_token_alg token
prefix 16 karakter pertama token.
hash_base64_sha512_sha512 Hash ganda token menggunakan SHA-512.

Jika Anda mengintegrasikan peristiwa ini, sebaiknya indeks token berdasarkan nilai yang memungkinkan ini untuk memastikan kecocokan cepat saat peristiwa diterima.

Jenis peristiwa yang didukung

Perlindungan Lintas Akun mendukung jenis peristiwa keamanan berikut:

Jenis Peristiwa Atribut Cara Menanggapi
https://schemas.openid.net/secevent/risc/event-type/sessions-revoked Wajib: Mengamankan akun pengguna dengan mengakhiri sesi yang saat ini terbuka.
https://schemas.openid.net/secevent/oauth/event-type/tokens-revoked

Wajib: Jika token ditujukan untuk Login dengan Google, hentikan sesi yang sedang dibuka. Selain itu, Anda dapat menyarankan pengguna untuk menyiapkan metode login alternatif.

Disarankan: Jika token ditujukan untuk akses ke Google API lainnya, hapus token OAuth pengguna yang telah Anda simpan.

https://schemas.openid.net/secevent/oauth/event-type/token-revoked Lihat bagian ID token OAuth untuk ID token

Wajib: Jika Anda menyimpan token refresh yang sesuai, hapus token tersebut dan minta pengguna untuk memberi izin lagi saat token akses diperlukan.

https://schemas.openid.net/secevent/risc/event-type/account-disabled reason=hijacking,
reason=bulk-account

Wajib: Jika alasan akun dinonaktifkan adalah hijacking, amankan kembali akun pengguna dengan mengakhiri sesi yang saat ini terbuka.

Disarankan: Jika alasan akun dinonaktifkan adalah bulk-account, analisis aktivitas pengguna di layanan Anda dan tentukan tindakan lanjutan yang sesuai.

Disarankan: Jika tidak ada alasan yang diberikan, nonaktifkan Login dengan Google untuk pengguna dan nonaktifkan pemulihan akun menggunakan alamat email yang terkait dengan Akun Google pengguna (biasanya, tetapi tidak selalu, akun Gmail). Menawarkan metode login alternatif kepada pengguna.

https://schemas.openid.net/secevent/risc/event-type/account-enabled Disarankan: Aktifkan kembali Login dengan Google untuk pengguna dan aktifkan kembali pemulihan akun dengan alamat email Akun Google pengguna.
https://schemas.openid.net/secevent/risc/event-type/account-purged Disarankan: Hapus akun pengguna atau berikan metode login alternatif kepada mereka.
https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required Disarankan: Perhatikan aktivitas yang mencurigakan di layanan Anda dan ambil tindakan yang sesuai.
https://schemas.openid.net/secevent/risc/event-type/verification status=state Disarankan: Catat bahwa token pengujian diterima.

Acara duplikat dan yang terlewat

Perlindungan Lintas Akun akan mencoba mengirimkan ulang peristiwa yang diyakini belum ditayangkan. Oleh karena itu, Anda terkadang dapat menerima peristiwa yang sama beberapa kali. Jika hal ini dapat menyebabkan tindakan berulang yang membuat pengguna tidak nyaman, sebaiknya gunakan klaim jti (yang merupakan ID unik untuk peristiwa) untuk menghilangkan peristiwa. Ada beberapa alat eksternal seperti Google Cloud Dataflow yang dapat membantu Anda menjalankan aliran data de-dup.

Perlu diketahui bahwa peristiwa dikirimkan dengan percobaan ulang terbatas. Jadi, jika penerima Anda tidak aktif untuk jangka waktu yang lama, Anda dapat melewatkan beberapa peristiwa secara permanen.

Mendaftarkan penerima Anda

Untuk mulai menerima peristiwa keamanan, daftarkan endpoint penerima Anda menggunakan API RISC. Panggilan ke RISC API harus disertai dengan token otorisasi.

Anda hanya akan menerima peristiwa keamanan untuk pengguna aplikasi, sehingga Anda harus mengonfigurasi layar izin OAuth di project GCP Anda sebagai prasyarat untuk langkah-langkah yang dijelaskan di bawah.

1. Membuat token otorisasi

Untuk membuat token otorisasi untuk RISC API, buat JWT dengan klaim berikut:

{
  "iss": SERVICE_ACCOUNT_EMAIL,
  "sub": SERVICE_ACCOUNT_EMAIL,
  "aud": "https://risc.googleapis.com/google.identity.risc.v1beta.RiscManagementService",
  "iat": CURRENT_TIME,
  "exp": CURRENT_TIME + 3600
}

Tanda tangani JWT menggunakan kunci pribadi akun layanan, yang dapat ditemukan di file JSON yang didownload saat Anda membuat kunci akun layanan.

Contoh:

Java

Menggunakan java-jwt dan library autentikasi Google:

public static String makeBearerToken() {
    String token = null;
    try {
        // Get signing key and client email address.
        FileInputStream is = new FileInputStream("your-service-account-credentials.json");
        ServiceAccountCredentials credentials =
               (ServiceAccountCredentials) GoogleCredentials.fromStream(is);
        PrivateKey privateKey = credentials.getPrivateKey();
        String keyId = credentials.getPrivateKeyId();
        String clientEmail = credentials.getClientEmail();

        // Token must expire in exactly one hour.
        Date issuedAt = new Date();
        Date expiresAt = new Date(issuedAt.getTime() + 3600000);

        // Create signed token.
        Algorithm rsaKey = Algorithm.RSA256(null, (RSAPrivateKey) privateKey);
        token = JWT.create()
                .withIssuer(clientEmail)
                .withSubject(clientEmail)
                .withAudience("https://risc.googleapis.com/google.identity.risc.v1beta.RiscManagementService")
                .withIssuedAt(issuedAt)
                .withExpiresAt(expiresAt)
                .withKeyId(keyId)
                .sign(rsaKey);
    } catch (ClassCastException e) {
        // Credentials file doesn't contain a service account key.
    } catch (IOException e) {
        // Credentials file couldn't be loaded.
    }
    return token;
}

Python

import json
import time

import jwt  # pip install pyjwt

def make_bearer_token(credentials_file):
    with open(credentials_file) as service_json:
        service_account = json.load(service_json)
        issuer = service_account['client_email']
        subject = service_account['client_email']
        private_key_id = service_account['private_key_id']
        private_key = service_account['private_key']
    issued_at = int(time.time())
    expires_at = issued_at + 3600
    payload = {'iss': issuer,
               'sub': subject,
               'aud': 'https://risc.googleapis.com/google.identity.risc.v1beta.RiscManagementService',
               'iat': issued_at,
               'exp': expires_at}
    encoded = jwt.encode(payload, private_key, algorithm='RS256',
                         headers={'kid': private_key_id})
    return encoded

auth_token = make_bearer_token('your-service-account-credentials.json')

Token otorisasi ini dapat digunakan untuk melakukan panggilan API RISC selama satu jam. Setelah masa berlaku token habis, buat token baru untuk terus melakukan panggilan RISC API.

2. Memanggil API konfigurasi aliran data RISC

Setelah memiliki token otorisasi, Anda dapat menggunakan RISC API untuk mengonfigurasi aliran peristiwa keamanan project, termasuk mendaftarkan endpoint penerima.

Untuk melakukannya, buat permintaan POST HTTPS ke https://risc.googleapis.com/v1beta/stream:update, dengan menentukan endpoint penerima dan jenis peristiwa keamanan yang Anda minati:

POST /v1beta/stream:update HTTP/1.1
Host: risc.googleapis.com
Authorization: Bearer AUTH_TOKEN

{
  "delivery": {
    "delivery_method":
      "https://schemas.openid.net/secevent/risc/delivery-method/push",
    "url": RECEIVER_ENDPOINT
  },
  "events_requested": [
    SECURITY_EVENT_TYPES
  ]
}

Contoh:

Java

public static void configureEventStream(final String receiverEndpoint,
                                        final List<String> eventsRequested,
                                        String authToken) throws IOException {
    ObjectMapper jsonMapper = new ObjectMapper();
    String streamConfig = jsonMapper.writeValueAsString(new Object() {
        public Object delivery = new Object() {
            public String delivery_method =
                    "https://schemas.openid.net/secevent/risc/delivery-method/push";
            public String url = receiverEndpoint;
        };
        public List<String> events_requested = eventsRequested;
    });

    HttpPost updateRequest = new HttpPost("https://risc.googleapis.com/v1beta/stream:update");
    updateRequest.addHeader("Content-Type", "application/json");
    updateRequest.addHeader("Authorization", "Bearer " + authToken);
    updateRequest.setEntity(new StringEntity(streamConfig));

    HttpResponse updateResponse = new DefaultHttpClient().execute(updateRequest);
    Header[] responseContentTypeHeaders = updateResponse.getHeaders("Content-Type");
    StatusLine responseStatus = updateResponse.getStatusLine();
    int statusCode = responseStatus.getStatusCode();
    HttpEntity entity = updateResponse.getEntity();
    // Now handle response
}

// ...

configureEventStream(
        "https://your-service.example.com/security-event-receiver",
        Arrays.asList(
                "https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required",
                "https://schemas.openid.net/secevent/risc/event-type/account-disabled"),
        authToken);

Python

import requests

def configure_event_stream(auth_token, receiver_endpoint, events_requested):
    stream_update_endpoint = 'https://risc.googleapis.com/v1beta/stream:update'
    headers = {'Authorization': 'Bearer {}'.format(auth_token)}
    stream_cfg = {'delivery': {'delivery_method': 'https://schemas.openid.net/secevent/risc/delivery-method/push',
                               'url': receiver_endpoint},
                  'events_requested': events_requested}
    response = requests.post(stream_update_endpoint, json=stream_cfg, headers=headers)
    response.raise_for_status()  # Raise exception for unsuccessful requests

configure_event_stream(auth_token, 'https://your-service.example.com/security-event-receiver',
                       ['https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required',
                        'https://schemas.openid.net/secevent/risc/event-type/account-disabled'])

Jika permintaan tersebut menampilkan HTTP 200, aliran peristiwa berhasil dikonfigurasi dan endpoint penerima Anda akan mulai menerima token peristiwa keamanan. Bagian berikutnya menjelaskan cara menguji konfigurasi streaming dan endpoint untuk memverifikasi bahwa semuanya berfungsi dengan benar secara bersamaan.

Mendapatkan dan memperbarui konfigurasi streaming saat ini

Jika di masa mendatang, Anda ingin mengubah konfigurasi streaming, Anda dapat melakukannya dengan membuat permintaan GET yang diotorisasi ke https://risc.googleapis.com/v1beta/stream untuk mendapatkan konfigurasi streaming saat ini, mengubah isi respons, lalu POSTING konfigurasi yang dimodifikasi kembali ke https://risc.googleapis.com/v1beta/stream:update seperti yang dijelaskan di atas.

Menghentikan dan melanjutkan streaming acara

Jika Anda perlu menghentikan aliran peristiwa dari Google, buat permintaan POST yang diotorisasi ke https://risc.googleapis.com/v1beta/stream/status:update dengan { "status": "disabled" } dalam isi permintaan. Saat streaming dinonaktifkan, Google tidak mengirimkan peristiwa ke endpoint dan tidak melakukan buffering peristiwa keamanan saat terjadi. Untuk mengaktifkan kembali aliran peristiwa, POST { "status": "enabled" } ke endpoint yang sama.

3. Opsional: Uji konfigurasi streaming Anda

Anda dapat memastikan bahwa konfigurasi streaming dan endpoint penerima berfungsi bersama dengan benar dengan mengirimkan token verifikasi melalui streaming peristiwa. Token ini dapat berisi string unik yang dapat Anda gunakan untuk memverifikasi bahwa token telah diterima di endpoint Anda.

Untuk meminta token verifikasi, buat permintaan POST HTTPS resmi ke https://risc.googleapis.com/v1beta/stream:verify. Di bagian isi permintaan, tentukan beberapa string pengidentifikasi:

{
  "state": "ANYTHING"
}

Contoh:

Java

public static void testEventStream(final String stateString,
                                   String authToken) throws IOException {
    ObjectMapper jsonMapper = new ObjectMapper();
    String json = jsonMapper.writeValueAsString(new Object() {
        public String state = stateString;
    });

    HttpPost updateRequest = new HttpPost("https://risc.googleapis.com/v1beta/stream:verify");
    updateRequest.addHeader("Content-Type", "application/json");
    updateRequest.addHeader("Authorization", "Bearer " + authToken);
    updateRequest.setEntity(new StringEntity(json));

    HttpResponse updateResponse = new DefaultHttpClient().execute(updateRequest);
    Header[] responseContentTypeHeaders = updateResponse.getHeaders("Content-Type");
    StatusLine responseStatus = updateResponse.getStatusLine();
    int statusCode = responseStatus.getStatusCode();
    HttpEntity entity = updateResponse.getEntity();
    // Now handle response
}

// ...

testEventStream("Test token requested at " + new Date().toString(), authToken);

Python

import requests
import time

def test_event_stream(auth_token, nonce):
    stream_verify_endpoint = 'https://risc.googleapis.com/v1beta/stream:verify'
    headers = {'Authorization': 'Bearer {}'.format(auth_token)}
    state = {'state': nonce}
    response = requests.post(stream_verify_endpoint, json=state, headers=headers)
    response.raise_for_status()  # Raise exception for unsuccessful requests

test_event_stream(auth_token, 'Test token requested at {}'.format(time.ctime()))

Jika permintaan berhasil, token verifikasi akan dikirim ke endpoint yang Anda daftarkan. Kemudian, misalnya, jika endpoint Anda menangani token verifikasi dengan hanya mencatatnya dalam log, Anda dapat memeriksa log untuk mengonfirmasi bahwa token telah diterima.

Referensi kode error

Error berikut dapat ditampilkan oleh RISC API:

Kode Error Pesan Error Tindakan yang Disarankan
400 Konfigurasi streaming harus berisi kolom $fieldname. Permintaan Anda ke endpoint https://risc.googleapis.com/v1beta/stream:update tidak valid atau tidak dapat diuraikan. Sertakan $fieldname dalam permintaan Anda.
401 Tidak sah. Otorisasi gagal. Pastikan Anda melampirkan token otorisasi dengan permintaan tersebut dan bahwa token tersebut valid serta belum habis masa berlakunya.
403 Endpoint pengiriman harus berupa URL HTTPS. Endpoint pengiriman Anda (yaitu endpoint yang Anda harapkan untuk menerima peristiwa RISC) harus berupa HTTPS. Kami tidak mengirim peristiwa RISC ke URL HTTP.
403 Konfigurasi streaming yang ada tidak memiliki metode penayangan yang sesuai spesifikasi untuk RISC. Project Google Cloud Anda harus sudah memiliki konfigurasi RISC. Jika Anda menggunakan Firebase dan mengaktifkan Login dengan Google, Firebase akan mengelola RISC untuk project Anda. Anda tidak akan dapat membuat konfigurasi kustom. Jika Anda tidak menggunakan Login dengan Google untuk project Firebase Anda, nonaktifkan project tersebut, lalu coba update lagi setelah satu jam.
403 Project tidak dapat ditemukan. Pastikan Anda menggunakan akun layanan yang benar untuk project yang benar. Anda mungkin menggunakan akun layanan yang terkait dengan project yang dihapus. Pelajari cara melihat semua akun layanan yang terkait dengan project.
403 Akun layanan harus memiliki izin editor di project Anda. Buka Google Cloud Platform Console project Anda dan berikan akun layanan yang membuat izin editor/pemilik panggilan ke project Anda dengan mengikuti petunjuk ini.
403 API pengelolaan streaming hanya boleh dipanggil oleh akun layanan. Berikut informasi selengkapnya tentang cara memanggil Google API dengan akun layanan.
403 Endpoint pengiriman tidak termasuk dalam domain project Anda. Setiap project memiliki kumpulan domain yang diotorisasi. Jika endpoint pengiriman Anda (yaitu endpoint yang menjadi tujuan pengiriman peristiwa RISC) tidak dihosting di salah satu endpoint tersebut, Anda harus menambahkan domain endpoint ke kumpulan tersebut.
403 Untuk menggunakan API ini, project Anda harus memiliki setidaknya satu klien OAuth yang dikonfigurasi. RISC hanya berfungsi jika Anda mem-build aplikasi yang mendukung Login dengan Google. Koneksi ini memerlukan klien OAuth. Jika project Anda tidak memiliki klien OAuth, kemungkinan RISC tidak akan berguna untuk Anda. Pelajari lebih lanjut penggunaan OAuth untuk API kami oleh Google.
403

Status tidak didukung.

Status tidak valid.

Saat ini kami hanya mendukung status streaming “enabled” dan “disabled”.
404

Project tidak memiliki konfigurasi RISC.

Project tidak memiliki konfigurasi RISC yang ada, tidak dapat memperbarui status.

Panggil endpoint https://risc.googleapis.com/v1beta/stream:update untuk membuat konfigurasi streaming baru.
4XX/5XX Tidak dapat memperbarui status. Periksa pesan error mendetail untuk mengetahui informasi selengkapnya.

Cakupan token akses

Jika Anda memutuskan untuk menggunakan token akses untuk mengautentikasi ke RISC API, berikut adalah cakupan yang harus diminta aplikasi Anda:

Endpoint Cakupan
https://risc.googleapis.com/v1beta/stream/status https://www.googleapis.com/auth/risc.status.readonly ATAU https://www.googleapis.com/auth/risc.status.readwrite
https://risc.googleapis.com/v1beta/stream/status:update https://www.googleapis.com/auth/risc.status.readwrite
https://risc.googleapis.com/v1beta/stream https://www.googleapis.com/auth/risc.configuration.readonly ATAU https://www.googleapis.com/auth/risc.configuration.readwrite
https://risc.googleapis.com/v1beta/stream:update https://www.googleapis.com/auth/risc.configuration.readwrite
https://risc.googleapis.com/v1beta/stream:verify https://www.googleapis.com/auth/risc.verify

Perlu Bantuan?

Pertama, lihat bagian referensi kode error. Jika masih ada pertanyaan, posting pertanyaan tersebut di Stack Overflow dengan tag #SecEvents.