Halaman ini diterjemahkan oleh Cloud Translation API.
Switch to English

Lindungi akun pengguna dengan Perlindungan Lintas Akun

Jika aplikasi Anda memungkinkan 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.

Pemberitahuan ini memperingatkan Anda tentang perubahan besar pada Akun Google pengguna Anda, yang sering kali 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 dari peristiwa tersebut, Google mengirimkan objek layanan Anda yang disebut token peristiwa keamanan. Token ini memperlihatkan sangat sedikit informasi — hanya jenis peristiwa keamanan dan kapan hal itu terjadi, serta pengenal pengguna yang terpengaruh — tetapi Anda dapat menggunakannya untuk mengambil tindakan yang sesuai sebagai tanggapan. Misalnya, jika Akun Google pengguna disusupi, Anda dapat menonaktifkan Masuk dengan Google untuk sementara waktu dan mencegah email pemulihan akun dikirim ke alamat Gmail pengguna.

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

Gambaran

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 merespons peristiwa keamanan dengan cara apa pun yang Anda pilih.

  3. Daftarkan titik akhir Anda dengan 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 cakupan profile atau email . Google Sign-in SDK 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 cakupan ini.

Siapkan proyek di API Console

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

Untuk membuat akun layanan:

  1. Buka file API Console Credentials page . Saat diminta, pilih proyek API Console yang Anda gunakan untuk mengakses layanan Google di aplikasi Anda.

  2. Klik Buat kredensial> Kunci akun layanan .

  3. Buat akun layanan baru dengan peran Editor.

    Pilih jenis kunci JSON lalu klik Buat . Saat kunci dibuat, Anda akan mendownload 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, catat juga ID klien yang Anda gunakan untuk Masuk dengan Google. 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 selanjutnya.

Untuk mengaktifkan RISC API:

  1. Buka halaman RISC API di API 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 organisasi, pastikan Anda berwenang untuk mengikat organisasi Anda ke 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 peristiwa terkait keamanan tunggal.

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. Bagian berikut menjelaskan tugas-tugas ini:

1. Dekode dan validasi token peristiwa keamanan

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

  1. Dapatkan pengenal penerbit Perlindungan Lintas Akun ( issuer ) dan penandatanganan sertifikat kunci URI ( jwks_uri ) dari dokumen konfigurasi RISC Google, yang dapat Anda temukan di https://accounts.google.com/.well-known/risc-configuration .
  2. Dengan menggunakan 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 di langkah sebelumnya. Jika dokumen tidak berisi kunci dengan ID yang Anda cari, kemungkinan token peristiwa keamanan tidak valid, dan titik akhir Anda akan menampilkan kesalahan HTTP 400.
  4. Menggunakan perpustakaan JWT pilihan Anda, verifikasi hal-hal berikut:
    • Token peristiwa keamanan ditandatangani menggunakan kunci publik yang Anda dapatkan di langkah sebelumnya.
    • Klaim aud token adalah salah satu ID klien aplikasi Anda.
    • Klaim iss dari token tersebut cocok dengan pengidentifikasi penerbit yang Anda dapatkan dari dokumen penemuan RISC. Perhatikan bahwa Anda tidak perlu memverifikasi berakhirnya token ( exp ) karena peristiwa keamanan token mewakili peristiwa sejarah dan karena itu, tidak berakhir.

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. Tangani peristiwa keamanan

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

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

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

Klaim subject mengidentifikasi pengguna tertentu dengan ID unik Akun Google pengguna ( sub ). ID ini sama dengan pengenal yang terdapat dalam token ID yang dihasilkan oleh Masuk dengan Google . Jika subject_type dari klaim tersebut adalah id_token_claims , ini mungkin juga menyertakan bidang email dengan alamat email pengguna.

Gunakan informasi dalam klaim events untuk mengambil tindakan yang sesuai untuk jenis peristiwa di 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 mereka yang saat ini terbuka.
https://schemas.openid.net/secevent/oauth/event-type/tokens-revoked

Diperlukan : Jika token untuk Masuk dengan Google, hentikan sesi mereka yang saat ini terbuka. Selain itu, Anda mungkin ingin menyarankan pengguna untuk menyiapkan metode masuk alternatif.

Disarankan : Jika token ditujukan 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 akun dinonaktifkan adalah hijacking , amankan kembali akun pengguna tersebut dengan mengakhiri sesi mereka yang saat ini terbuka.

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

Disarankan : Jika tidak ada alasan yang diberikan, nonaktifkan Masuk dengan Google 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 Masuk 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 mereka metode masuk alternatif.
https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required Disarankan : Waspadai aktivitas mencurigakan di layanan Anda dan ambil tindakan yang sesuai.
https://schemas.openid.net/secevent/risc/event-type/verification state = state Disarankan : Log bahwa token uji telah diterima.

Acara yang digandakan dan terlewat

Perlindungan Lintas Akun akan berusaha untuk mengirimkan kembali acara yang diyakini belum terkirim. Oleh karena itu, Anda terkadang 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 pengenal unik untuk suatu peristiwa) untuk jti peristiwa tersebut. Ada alat eksternal seperti Google Cloud Dataflow yang dapat membantu Anda menjalankan aliran data de-dup.

Perhatikan bahwa acara dikirim dengan percobaan ulang terbatas, jadi 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.

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

Sebagai contoh:

Jawa

Menggunakan java-jwt dan pustaka 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 RISC API selama satu jam. Saat token kedaluwarsa, buat yang baru untuk terus melakukan panggilan RISC API.

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 , dengan menentukan titik akhir 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
  ]
}

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 selanjutnya menjelaskan bagaimana Anda dapat menguji konfigurasi streaming dan titik akhir untuk memverifikasi semuanya berfungsi 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, dengan mengubah isi respons , lalu POST konfigurasi yang diubah kembali ke https://risc.googleapis.com/v1beta/stream:update seperti yang dijelaskan di atas.

Hentikan dan lanjutkan streaming acara

Jika Anda perlu menghentikan streaming acara dari Google, buat permintaan POST resmi ke https://risc.googleapis.com/v1beta/stream/status:update dengan { "status": "disabled" } di badan permintaan. Saat streaming dinonaktifkan, Google tidak mengirim acara ke titik akhir Anda dan tidak menyangga peristiwa keamanan saat itu terjadi. Untuk mengaktifkan kembali aliran peristiwa, POSKAN { "status": "enabled" } ke endpoint 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 acara Anda. 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 bagian isi 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 endpoint yang Anda daftarkan. Kemudian, misalnya, jika titik akhir Anda menangani token verifikasi hanya dengan mencatatnya, Anda dapat memeriksa log untuk mengonfirmasi bahwa token telah diterima.

Referensi kode kesalahan

Galat berikut ini dapat dikembalikan oleh RISC API:

Kode Kesalahan Pesan eror Tindakan yang Disarankan
400 Konfigurasi aliran harus berisi bidang $ fieldname . Permintaan Anda ke titik akhir https://risc.googleapis.com/v1beta/stream:update tidak valid atau tidak dapat diurai. Harap sertakan $ fieldname dalam permintaan Anda.
401 Tidak resmi. Otorisasi gagal. Pastikan Anda melampirkan token otorisasi dengan permintaan tersebut 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 menerima peristiwa RISC) harus 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 Google Sign-In diaktifkan, maka Firebase akan mengelola RISC untuk proyek Anda; Anda tidak akan dapat membuat konfigurasi khusus. Jika Anda tidak menggunakan Masuk dengan Google untuk proyek Firebase, 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 telah dihapus. Pelajari cara melihat semua akun layanan yang terkait dengan sebuah proyek .
403 Akun layanan harus memiliki izin editor dalam proyek Anda. Buka konsol Google Cloud Platform proyek Anda dan berikan akun layanan yang membuat panggilan ke editor / pemilik izin untuk proyek Anda dengan mengikuti petunjuk ini .
403 API manajemen aliran hanya boleh dipanggil oleh akun layanan. Berikut informasi selengkapnya tentang cara memanggil Google API dengan akun layanan .
403 Titik akhir pengiriman tidak termasuk dalam domain proyek Anda mana pun. Setiap proyek memiliki sekumpulan domain resmi. Jika titik akhir pengiriman Anda (yaitu titik akhir yang Anda harapkan untuk mengirim peristiwa RISC) tidak dihosting di salah satunya, kami meminta Anda menambahkan domain titik akhir ke set itu.
403 Untuk menggunakan API ini, proyek Anda harus memiliki setidaknya satu klien OAuth yang dikonfigurasi. RISC hanya berfungsi jika Anda membuat aplikasi yang mendukung Masuk dengan Google . Koneksi ini membutuhkan klien OAuth. Jika project Anda tidak memiliki klien OAuth, kemungkinan RISC tidak akan berguna untuk 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 " untuk saat ini.
404

Proyek tidak memiliki konfigurasi RISC.

Proyek tidak memiliki konfigurasi RISC, tidak dapat memperbarui status.

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

Akses cakupan token

Jika Anda memutuskan untuk menggunakan token akses untuk mengautentikasi ke RISC API, berikut 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 pertanyaan tersebut di Stack Overflow dengan tag #SecEvents .