Lindungi akun pengguna dengan Perlindungan Lintas Akun

Jika aplikasi Anda mengizinkan pengguna masuk ke akun mereka menggunakan Google, Anda dapat meningkatkan keamanan akun pengguna bersama ini dengan mendengarkan dan menanggapi pemberitahuan peristiwa keamanan yang disediakan oleh layanan Perlindungan Lintas Akun.

Notifikasi ini mengingatkan Anda tentang perubahan besar pada Akun Google pengguna Anda, yang seringkali juga memiliki implikasi keamanan untuk akun mereka dengan aplikasi Anda. Misalnya, jika Akun Google pengguna dibajak, akun pengguna tersebut berpotensi disusupi dengan aplikasi Anda melalui pemulihan akun email atau penggunaan sistem masuk tunggal.

Untuk membantu Anda mengurangi potensi risiko peristiwa semacam itu, Google mengirimkan objek layanan Anda yang disebut token peristiwa keamanan. Token ini mengekspos informasi yang sangat sedikit—hanya jenis peristiwa keamanan dan waktu terjadinya, serta pengidentifikasi pengguna yang terpengaruh—tetapi Anda dapat menggunakannya untuk mengambil tindakan yang sesuai sebagai tanggapan. Misalnya, jika Akun Google pengguna disusupi, Anda dapat menonaktifkan sementara Masuk 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, Anda harus menyelesaikan tugas-tugas berikut:

  1. Siapkan proyek Anda di API Console.

  2. Buat titik akhir penerima peristiwa, yang akan dikirimi token peristiwa keamanan oleh Google. Titik akhir ini bertanggung jawab untuk memvalidasi token yang diterimanya dan kemudian menanggapi peristiwa keamanan dengan cara apa pun yang Anda pilih.

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

Prasyarat

Anda hanya menerima token peristiwa keamanan untuk pengguna Google yang telah memberikan izin layanan Anda untuk mengakses informasi profil atau alamat email mereka. Anda mendapatkan izin ini dengan meminta profile atau cakupan email . Masuk Dengan Google yang lebih baru atau SDK Masuk Google lama meminta cakupan ini secara default, tetapi jika Anda tidak menggunakan setelan default, atau jika Anda mengakses titik akhir OpenID Connect Google secara langsung, pastikan Anda meminta setidaknya salah satu dari ini lingkup.

Siapkan proyek di API Console

Sebelum Anda dapat mulai menerima token peristiwa keamanan, Anda harus membuat akun layanan dan mengaktifkan API RISC di proyekAPI Console Anda. Anda harus menggunakan proyekAPI Console yang sama dengan yang Anda gunakan untuk mengakses layanan Google, seperti Google Sign-in, di aplikasi Anda.

Untuk membuat akun layanan:

  1. Buka API ConsoleCredentials page . Saat diminta, pilih proyekAPI Consoleyang Anda gunakan untuk mengakses layanan Google di aplikasi Anda.

  2. Klik Buat kredensial > Akun layanan .

  3. Buat akun layanan baru dengan peran Editor.

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

Saat Anda berada di halaman Kredensial proyek Anda, perhatikan juga ID klien yang Anda gunakan untuk Masuk Dengan Google atau Masuk dengan Google (lawas). Biasanya, Anda memiliki ID klien untuk setiap platform yang Anda dukung. Anda akan memerlukan ID klien ini untuk memvalidasi token peristiwa keamanan, seperti yang dijelaskan di bagian berikutnya.

Untuk mengaktifkan API RISC:

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

  2. Baca Persyaratan RISC dan pastikan Anda memahami persyaratannya.

    Jika Anda mengaktifkan API untuk proyek yang dimiliki oleh suatu organisasi, pastikan Anda berwenang untuk mengikat organisasi Anda dengan Persyaratan RISC.

  3. Klik Aktifkan hanya jika Anda menyetujui Persyaratan RISC.

Buat titik akhir penerima acara

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

Untuk setiap token peristiwa keamanan yang Anda terima di titik akhir, validasi dan dekode token terlebih dahulu, lalu tangani peristiwa keamanan yang sesuai untuk layanan Anda. Sangat penting untuk memvalidasi token peristiwa sebelum decoding untuk mencegah serangan jahat dari aktor jahat. Bagian berikut menjelaskan tugas-tugas ini:

1. Dekode dan validasi token peristiwa keamanan

Karena token peristiwa keamanan adalah jenis JWT tertentu, Anda dapat menggunakan pustaka JWT apa pun, seperti yang terdaftar di jwt.io , untuk memecahkan kode dan memvalidasinya. Pustaka mana pun yang Anda gunakan, kode validasi token Anda harus melakukan hal berikut:

  1. Dapatkan pengidentifikasi 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. Menggunakan perpustakaan 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 di langkah sebelumnya. Jika dokumen tidak berisi kunci dengan ID yang Anda cari, kemungkinan token peristiwa keamanan tidak valid, dan titik akhir Anda akan mengembalikan kesalahan HTTP 400.
  4. Menggunakan perpustakaan JWT pilihan Anda, verifikasi berikut ini:
    • Token peristiwa keamanan ditandatangani menggunakan kunci publik yang Anda dapatkan di langkah sebelumnya.
    • Klaim aud dari token adalah salah satu ID klien aplikasi Anda.
    • Klaim iss dari token cocok dengan pengidentifikasi penerbit yang Anda dapatkan dari dokumen penemuan RISC. Perhatikan bahwa Anda tidak perlu memverifikasi kedaluwarsa token ( exp ) karena token peristiwa keamanan mewakili peristiwa historis dan dengan demikian, tidak kedaluwarsa.

Sebagai contoh:

Jawa

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 didekodekan, kembalikan status HTTP 202. Kemudian, tangani peristiwa keamanan yang ditunjukkan oleh token.

2. Menangani acara keamanan

Saat diterjemahkan, token peristiwa keamanan 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 yang dituju token (layanan Anda). Anda memverifikasi klaim ini di langkah sebelumnya.

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

Klaim events berisi informasi tentang peristiwa keamanan yang diwakili oleh token. Klaim ini adalah pemetaan dari pengidentifikasi jenis peristiwa ke klaim subject , yang menetapkan pengguna terkait peristiwa ini, dan ke detail tambahan apa pun tentang peristiwa yang mungkin tersedia.

Klaim subject mengidentifikasi pengguna tertentu dengan ID Akun Google unik pengguna ( sub ). ID Akun Google ini adalah pengenal yang sama ( sub ) yang terdapat dalam token ID JWT yang dikeluarkan oleh pustaka Masuk Dengan Google ( Javascript , HTML ) yang lebih baru, pustaka Masuk Google lawas, atau OpenID Connect . Jika subject_type klaim adalah id_token_claims , mungkin juga menyertakan bidang email dengan alamat email pengguna.

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

Jenis acara yang didukung

Perlindungan Lintas Akun mendukung jenis peristiwa keamanan berikut:

Jenis Acara Atribut Bagaimana Menanggapi
https://schemas.openid.net/secevent/risc/event-type/sessions-revoked Diperlukan : Amankan kembali akun pengguna dengan mengakhiri sesi yang sedang mereka buka.
https://schemas.openid.net/secevent/oauth/event-type/tokens-revoked

Diperlukan : Jika token untuk Google Sign-in, hentikan sesi yang sedang dibuka. Selain itu, Anda mungkin ingin menyarankan kepada pengguna untuk menyiapkan metode masuk alternatif.

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

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

Diperlukan : Jika alasan penonaktifan akun adalah hijacking , amankan kembali akun pengguna dengan mengakhiri sesi yang mereka buka saat ini.

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

Disarankan : Jika tidak ada alasan yang diberikan, nonaktifkan Google Sign-in untuk pengguna dan nonaktifkan pemulihan akun menggunakan alamat email yang terkait dengan Akun Google pengguna (biasanya, tetapi tidak harus, akun Gmail). Tawarkan kepada pengguna metode masuk alternatif.

https://schemas.openid.net/secevent/risc/event-type/account-enabled Disarankan : Aktifkan kembali Google Sign-in 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 masuk alternatif.
https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required Disarankan : Waspadai aktivitas mencurigakan pada layanan Anda dan ambil tindakan yang sesuai.
https://schemas.openid.net/secevent/risc/event-type/verification negara = state Disarankan : Catat bahwa token uji telah diterima.

Acara yang digandakan dan terlewatkan

Perlindungan Lintas-Akun akan mencoba untuk mengirimkan kembali peristiwa yang diyakini belum terkirim. Oleh karena itu, terkadang Anda mungkin menerima acara yang sama beberapa kali. Jika hal ini dapat menyebabkan tindakan berulang yang membuat pengguna Anda tidak nyaman, pertimbangkan untuk menggunakan klaim jti (yang merupakan pengidentifikasi unik untuk suatu peristiwa) untuk menghapus duplikat peristiwa tersebut. Ada alat eksternal seperti Google Cloud Dataflow yang dapat membantu Anda menjalankan aliran data de-dup.

Perhatikan bahwa acara dikirimkan dengan percobaan ulang terbatas sehingga jika penerima Anda tidak aktif untuk waktu yang lama, Anda mungkin melewatkan beberapa acara secara permanen.

Daftarkan penerima Anda

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

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

1. Buat token otorisasi

Untuk menghasilkan 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 Anda, yang dapat Anda temukan di file JSON yang Anda unduh saat Anda membuat kunci akun layanan.

Sebagai contoh:

Jawa

Menggunakan Java-jwt dan perpustakaan auth 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. Saat token kedaluwarsa, buat token baru untuk terus melakukan panggilan API RISC.

2. Panggil API konfigurasi aliran RISC

Sekarang setelah Anda memiliki token otorisasi, Anda dapat menggunakan RISC API untuk mengonfigurasi aliran peristiwa keamanan proyek Anda, termasuk mendaftarkan titik akhir penerima Anda.

Untuk melakukannya, buat permintaan HTTPS POST ke https://risc.googleapis.com/v1beta/stream:update , tentukan titik akhir penerima Anda 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
  ]
}

Sebagai contoh:

Jawa

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 mengembalikan HTTP 200, aliran peristiwa berhasil dikonfigurasi dan titik akhir penerima Anda akan mulai menerima token peristiwa keamanan. Bagian berikutnya menjelaskan bagaimana Anda dapat menguji konfigurasi streaming dan titik akhir Anda untuk memverifikasi bahwa semuanya bekerja dengan benar bersama-sama.

Dapatkan dan perbarui konfigurasi streaming Anda saat ini

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

Hentikan dan lanjutkan aliran acara

Jika Anda perlu menghentikan aliran acara dari Google, buat permintaan POST resmi ke https://risc.googleapis.com/v1beta/stream/status:update dengan { "status": "disabled" } di badan permintaan. Saat aliran dinonaktifkan, Google tidak mengirim peristiwa ke titik akhir Anda dan tidak menyangga peristiwa keamanan saat terjadi. Untuk mengaktifkan kembali aliran acara, POST { "status": "enabled" } ke titik akhir yang sama.

3. Opsional: Uji konfigurasi streaming Anda

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

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

{
  "state": "ANYTHING"
}

Sebagai contoh:

Jawa

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 titik akhir yang Anda daftarkan. Kemudian, misalnya, jika titik akhir Anda menangani token verifikasi hanya dengan mencatatnya, Anda dapat memeriksa log Anda untuk mengonfirmasi bahwa token telah diterima.

Referensi kode kesalahan

Kesalahan berikut dapat dikembalikan oleh RISC API:

Kode Kesalahan Pesan eror Tindakan yang Disarankan
400 Konfigurasi aliran harus berisi bidang $fieldname . Permintaan Anda ke https://risc.googleapis.com/v1beta/stream:update endpoint tidak valid atau tidak dapat diuraikan. Harap sertakan $fieldname dalam permintaan Anda.
401 Tidak sah. Otorisasi gagal. Pastikan Anda melampirkan token otorisasi dengan permintaan dan bahwa token tersebut valid dan belum kedaluwarsa.
403 Titik akhir pengiriman harus berupa URL HTTPS. Titik akhir pengiriman Anda (yaitu titik akhir yang Anda harapkan untuk dikirimi peristiwa RISC) harus berupa HTTPS. Kami tidak mengirim acara RISC ke URL HTTP.
403 Konfigurasi aliran yang ada tidak memiliki metode pengiriman yang sesuai dengan spesifikasi untuk RISC. Proyek Google Cloud Anda harus sudah memiliki konfigurasi RISC. Jika Anda menggunakan Firebase dan mengaktifkan Login dengan Google, maka Firebase akan mengelola RISC untuk proyek Anda; Anda tidak akan dapat membuat konfigurasi khusus. Jika Anda tidak menggunakan Google Sign-In untuk proyek Firebase Anda, harap nonaktifkan, lalu coba perbarui lagi setelah satu jam.
403 Proyek tidak dapat ditemukan. Pastikan Anda menggunakan akun layanan yang benar untuk proyek yang benar. Anda mungkin menggunakan akun layanan yang terkait dengan proyek yang dihapus. Pelajari cara melihat semua akun layanan yang terkait dengan proyek .
403 Akun layanan harus memiliki izin editor di proyek Anda. Buka konsol Google Cloud Platform proyek Anda dan berikan akun layanan yang membuat izin pemilik/editor panggilan ke proyek Anda dengan mengikuti petunjuk ini .
403 API pengelolaan aliran hanya boleh dipanggil oleh akun layanan. Berikut informasi selengkapnya tentang cara memanggil Google API dengan akun layanan .
403 Titik akhir pengiriman bukan milik salah satu domain proyek Anda. Setiap proyek memiliki satu set domain resmi. Jika titik akhir pengiriman Anda (yaitu titik akhir yang Anda harapkan untuk dikirimi peristiwa RISC) tidak dihosting di salah satunya, kami mengharuskan Anda menambahkan domain titik akhir ke set tersebut.
403 Untuk menggunakan API ini, proyek Anda harus memiliki setidaknya satu klien OAuth yang dikonfigurasi. RISC hanya berfungsi jika Anda membuat aplikasi yang mendukung Google Sign In . Koneksi ini memerlukan klien OAuth. Jika proyek Anda tidak memiliki klien OAuth, kemungkinan RISC tidak akan berguna bagi Anda. Pelajari lebih lanjut tentang penggunaan OAuth oleh Google untuk API kami .
403

Status tidak didukung.

Status tidak valid.

Kami hanya mendukung status streaming " enabled " dan " disabled " saat ini.
404

Proyek tidak memiliki konfigurasi RISC.

Proyek tidak memiliki konfigurasi RISC, tidak dapat memperbarui status.

Panggil https://risc.googleapis.com/v1beta/stream:update endpoint untuk membuat konfigurasi streaming baru.
4XX/5XX Tidak dapat memperbarui status. Periksa pesan kesalahan terperinci untuk informasi lebih lanjut.

Cakupan token akses

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

Titik akhir 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

Butuh bantuan?

Pertama, lihat bagian referensi kode kesalahan kami. Jika Anda masih memiliki pertanyaan, posting di Stack Overflow dengan tag #SecEvents .