Google มุ่งมั่นที่จะพัฒนาความเท่าเทียมทางเชื้อชาติให้กับชุมชนคนผิวดำ ดูวิธีการ

ปกป้องบัญชีผู้ใช้ด้วยการป้องกันข้ามบัญชี

หากแอปของคุณอนุญาตให้ผู้ใช้ลงชื่อเข้าใช้บัญชีของตนโดยใช้ Google คุณสามารถปรับปรุงความปลอดภัยของบัญชีของผู้ใช้ที่แชร์เหล่านี้ได้โดยรับฟังและตอบสนองต่อการแจ้งเตือนเหตุการณ์ด้านความปลอดภัยที่ให้บริการการป้องกันข้ามบัญชี

การแจ้งเตือนเหล่านี้แจ้งให้คุณทราบถึงการเปลี่ยนแปลงที่สำคัญในบัญชี Google ของผู้ใช้ของคุณซึ่งมักจะมีผลกระทบด้านความปลอดภัยสำหรับบัญชีของพวกเขากับแอปของคุณ ตัวอย่างเช่นหากบัญชี Google ของผู้ใช้ถูกไฮแจ็คอาจนำไปสู่การบุกรุกบัญชีของผู้ใช้กับแอปของคุณผ่านการกู้คืนบัญชีอีเมลหรือการใช้การลงชื่อเพียงครั้งเดียว

เพื่อช่วยคุณลดความเสี่ยงที่อาจเกิดขึ้นจากเหตุการณ์ดังกล่าว Google จะส่งออบเจ็กต์บริการของคุณที่เรียกว่าโทเค็นเหตุการณ์ความปลอดภัย โทเค็นเหล่านี้เปิดเผยข้อมูลน้อยมากเพียงแค่ประเภทของเหตุการณ์ความปลอดภัยและเวลาที่เกิดขึ้นและตัวระบุของผู้ใช้ที่ได้รับผลกระทบ - แต่คุณสามารถใช้เพื่อดำเนินการที่เหมาะสมในการตอบสนอง ตัวอย่างเช่นหากบัญชี Google ของผู้ใช้ถูกบุกรุกคุณสามารถปิดใช้งานการลงชื่อเข้าใช้ Google ชั่วคราวสำหรับผู้ใช้รายนั้นและป้องกันไม่ให้อีเมลกู้คืนบัญชีถูกส่งไปยังที่อยู่ Gmail ของผู้ใช้

การป้องกันข้ามบัญชีเป็นไปตาม มาตรฐาน RISC ซึ่งพัฒนาโดย OpenID Foundation

ภาพรวม

ในการใช้การป้องกันข้ามบัญชีกับแอปหรือบริการของคุณคุณต้องดำเนินการดังต่อไปนี้:

  1. ตั้งค่าโครงการของคุณใน API Console

  2. สร้างปลายทางผู้รับเหตุการณ์ซึ่ง Google จะส่งโทเค็นเหตุการณ์ความปลอดภัย จุดสิ้นสุดนี้มีหน้าที่ตรวจสอบความถูกต้องของโทเค็นที่ได้รับจากนั้นตอบสนองต่อเหตุการณ์ความปลอดภัยไม่ว่าคุณจะเลือกวิธีใด

  3. ลงทะเบียนปลายทางของคุณกับ Google เพื่อเริ่มรับโทเค็นเหตุการณ์ความปลอดภัย

ข้อกำหนดเบื้องต้น

คุณจะได้รับโทเค็นเหตุการณ์ความปลอดภัยสำหรับผู้ใช้ Google ที่ให้สิทธิ์บริการของคุณในการเข้าถึงข้อมูลโปรไฟล์หรือที่อยู่อีเมลของพวกเขาเท่านั้น คุณได้รับอนุญาตนี้โดยการขอ profile หรือขอบเขต email SDK การ ลงชื่อเข้าใช้ของ Google จะ ขอขอบเขตเหล่านี้โดยค่าเริ่มต้น แต่ถ้าคุณไม่ได้ใช้การตั้งค่าเริ่มต้นหรือหากคุณเข้าถึง ปลายทาง OpenID Connect ของ Google โดยตรงให้ตรวจสอบว่าคุณกำลังขอขอบเขตเหล่านี้อย่างน้อยหนึ่งขอบเขต

ตั้งค่าโครงการใน API Console

ก่อนที่คุณจะสามารถเริ่มรับโทเค็นเหตุการณ์ความปลอดภัยคุณต้องสร้างบัญชีบริการและเปิดใช้งาน RISC API ในโปรเจ็กต์ API Console ของคุณ คุณต้องใช้โปรเจ็กต์ API Console เดียวกับที่คุณใช้เพื่อเข้าถึงบริการของ Google เช่น Google Sign-in ในแอปของคุณ

ในการสร้างบัญชีบริการ:

  1. เปิด API Console Credentials page เมื่อได้รับแจ้งให้เลือกโครงการ API Console ที่คุณใช้เพื่อเข้าถึงบริการของ Google ในแอปของคุณ

  2. คลิก สร้างข้อมูลรับรอง> รหัสบัญชีบริการ

  3. สร้างบัญชีบริการใหม่ด้วยบทบาทบรรณาธิการ

    เลือกประเภทคีย์ JSON จากนั้นคลิก สร้าง เมื่อสร้างคีย์แล้วคุณจะดาวน์โหลดไฟล์ JSON ที่มีข้อมูลรับรองบัญชีบริการของคุณ เก็บไฟล์นี้ไว้ในที่ที่ปลอดภัย แต่ยังสามารถเข้าถึงปลายทางผู้รับเหตุการณ์ของคุณได้ด้วย

ในขณะที่คุณอยู่ในหน้าข้อมูลรับรองของโปรเจ็กต์ของคุณให้จดรหัสไคลเอ็นต์ที่คุณใช้สำหรับการลงชื่อเข้าใช้ Google ด้วย โดยทั่วไปคุณมีรหัสไคลเอ็นต์สำหรับแต่ละแพลตฟอร์มที่คุณรองรับ คุณจะต้องใช้รหัสไคลเอ็นต์เหล่านี้เพื่อตรวจสอบโทเค็นเหตุการณ์ความปลอดภัยตามที่อธิบายไว้ในส่วนถัดไป

ในการเปิดใช้งาน RISC API:

  1. เปิดหน้า RISC API ใน API Console ตรวจสอบให้แน่ใจว่าโครงการที่คุณใช้เพื่อเข้าถึงบริการของ Google ยังคงถูกเลือกอยู่

  2. อ่าน ข้อกำหนด RISC และตรวจสอบว่าคุณเข้าใจข้อกำหนด

    หากคุณเปิดใช้ API สำหรับโครงการที่องค์กรเป็นเจ้าของตรวจสอบให้แน่ใจว่าคุณได้รับอนุญาตให้ผูกองค์กรของคุณกับข้อกำหนด RISC

  3. คลิก เปิดใช้งาน ก็ต่อเมื่อคุณยินยอมตามข้อกำหนด RISC

สร้างปลายทางผู้รับเหตุการณ์

หากต้องการรับการแจ้งเตือนเหตุการณ์ความปลอดภัยจาก Google คุณต้องสร้างปลายทาง HTTPS ที่จัดการคำขอ HTTPS POST หลังจากที่คุณลงทะเบียนปลายทางนี้ (ดูด้านล่าง) Google จะเริ่มโพสต์สตริงที่มีการลงนามแบบเข้ารหัสที่เรียกว่าโทเค็นเหตุการณ์ความปลอดภัยไปยังปลายทาง โทเค็นเหตุการณ์ความปลอดภัยเป็น JWT ที่ลงนามซึ่งมีข้อมูลเกี่ยวกับเหตุการณ์ที่เกี่ยวข้องกับความปลอดภัยเดียว

สำหรับโทเค็นเหตุการณ์ความปลอดภัยแต่ละรายการที่คุณได้รับที่จุดสิ้นสุดขั้นแรกให้ตรวจสอบความถูกต้องและถอดรหัสโทเค็นจากนั้นจัดการเหตุการณ์ความปลอดภัยตามความเหมาะสมสำหรับบริการของคุณ ส่วนต่อไปนี้อธิบายถึงงานเหล่านี้:

1. ถอดรหัสและตรวจสอบความถูกต้องของโทเค็นเหตุการณ์ความปลอดภัย

เนื่องจากโทเค็นเหตุการณ์ความปลอดภัยเป็นประเภทเฉพาะของ JWT คุณสามารถใช้ไลบรารี JWT ใดก็ได้เช่นไลบรารีที่แสดงรายการบน jwt.io เพื่อถอดรหัสและตรวจสอบความถูกต้อง ไม่ว่าคุณจะใช้ไลบรารีใดรหัสการตรวจสอบโทเค็นของคุณจะต้องดำเนินการดังต่อไปนี้:

  1. รับตัวระบุผู้ออกการป้องกันข้ามบัญชี ( issuer ) และลงนามใบรับรองคีย์ URI ( jwks_uri ) จากเอกสารการกำหนดค่า RISC ของ Google ซึ่งคุณสามารถดูได้ที่ https://accounts.google.com/.well-known/risc-configuration
  2. ใช้ไลบรารี JWT ที่คุณเลือกรับ ID คีย์การลงนามจากส่วนหัวของโทเค็นเหตุการณ์ความปลอดภัย
  3. จากเอกสารใบรับรองคีย์การลงนามของ Google รับคีย์สาธารณะพร้อมรหัสคีย์ที่คุณได้รับในขั้นตอนก่อนหน้า หากเอกสารไม่มีคีย์ที่มี ID ที่คุณกำลังค้นหาอาจเป็นไปได้ว่าโทเค็นเหตุการณ์ความปลอดภัยไม่ถูกต้องและปลายทางของคุณควรส่งคืนข้อผิดพลาด HTTP 400
  4. ใช้ไลบรารี JWT ที่คุณเลือกตรวจสอบสิ่งต่อไปนี้:
    • โทเค็นเหตุการณ์ความปลอดภัยจะถูกเซ็นชื่อโดยใช้คีย์สาธารณะที่คุณได้รับในขั้นตอนก่อนหน้านี้
    • aud เรียกร้องของโทเค็นเป็นหนึ่งในรหัสลูกค้าของแอป
    • iss เรียกร้องของโทเค็นการแข่งขันที่ผู้ออกหุ้นกู้ระบุคุณได้จากเอกสารที่ค้นพบ RISC โปรดทราบว่าคุณไม่จำเป็นต้องตรวจสอบการหมดอายุของโทเค็น ( exp ) เนื่องจากโทเค็นเหตุการณ์ความปลอดภัยแสดงถึงเหตุการณ์ในอดีตดังนั้นจึงไม่หมดอายุ

ตัวอย่างเช่น:

Java

ใช้ java-jwt และ 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)

หากโทเค็นถูกต้องและถอดรหัสสำเร็จให้คืนสถานะ HTTP 202 จากนั้นจัดการเหตุการณ์ความปลอดภัยที่โทเค็นระบุ

2. จัดการเหตุการณ์ด้านความปลอดภัย

เมื่อถอดรหัสโทเค็นเหตุการณ์ความปลอดภัยจะมีลักษณะดังตัวอย่างต่อไปนี้:

{
  "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"
    }
  }
}

การอ้างสิทธิ์ iss และ aud ระบุผู้ออกโทเค็น (Google) และผู้รับที่ตั้งใจไว้ของโทเค็น (บริการของคุณ) คุณได้ยืนยันการอ้างสิทธิ์เหล่านี้ในขั้นตอนก่อนหน้า

การอ้างสิทธิ์ jti เป็นสตริงที่ระบุเหตุการณ์ความปลอดภัยเดียวและไม่ซ้ำกับสตรีม คุณสามารถใช้ตัวระบุนี้เพื่อติดตามเหตุการณ์ด้านความปลอดภัยที่คุณได้รับ

การอ้างสิทธิ์ events ประกอบด้วยข้อมูลเกี่ยวกับเหตุการณ์ความปลอดภัยที่โทเค็นแสดง การอ้างสิทธิ์นี้เป็นการจับคู่จากตัวระบุประเภทเหตุการณ์ไปยังการอ้างสิทธิ์ subject ซึ่งระบุผู้ใช้ที่เกี่ยวข้องกับเหตุการณ์นี้และรายละเอียดเพิ่มเติมเกี่ยวกับเหตุการณ์ที่อาจมีให้

การอ้างสิทธิ์ subject ระบุผู้ใช้เฉพาะด้วยรหัสบัญชี Google ที่ไม่ซ้ำกันของผู้ใช้ ( sub ) รหัสนี้เหมือนกับตัวระบุที่มีอยู่ในโทเค็น ID ที่สร้างโดย Google Sign-in เมื่อ subject_type ของการอ้างสิทธิ์คือ id_token_claims อาจมีช่อง email พร้อมที่อยู่อีเมลของผู้ใช้ด้วย

ใช้ข้อมูลในการอ้างสิทธิ์ events เพื่อดำเนินการที่เหมาะสมกับประเภทเหตุการณ์ในบัญชีของผู้ใช้ที่ระบุ

ประเภทเหตุการณ์ที่รองรับ

การป้องกันข้ามบัญชีรองรับเหตุการณ์ความปลอดภัยประเภทต่อไปนี้:

ประเภทเหตุการณ์ คุณลักษณะ วิธีการตอบสนอง
https://schemas.openid.net/secevent/risc/event-type/sessions-revoked จำเป็น : รักษาความปลอดภัยบัญชีของผู้ใช้อีกครั้งโดยสิ้นสุดเซสชันที่เปิดอยู่ในปัจจุบัน
https://schemas.openid.net/secevent/oauth/event-type/tokens-revoked

จำเป็น : หากโทเค็นมีไว้สำหรับการลงชื่อเข้าใช้ Google ให้ยุติเซสชันที่เปิดอยู่ในปัจจุบัน นอกจากนี้คุณอาจต้องการแนะนำให้ผู้ใช้ตั้งค่าวิธีการลงชื่อเข้าใช้แบบอื่น

แนะนำ : หากโทเค็นมีไว้สำหรับการเข้าถึง Google APIs อื่น ๆ ให้ลบโทเค็น OAuth ของผู้ใช้ที่คุณเก็บไว้

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

จำเป็น : หากเหตุผลที่บัญชีถูกปิดใช้งานคือการ hijacking ให้รักษาความปลอดภัยบัญชีของผู้ใช้อีกครั้งโดยสิ้นสุดเซสชันที่เปิดอยู่ในปัจจุบัน

แนะนำ : หากสาเหตุที่บัญชีถูกปิดใช้งานเป็น bulk-account ให้วิเคราะห์กิจกรรมของผู้ใช้ในบริการของคุณและกำหนดการดำเนินการติดตามผลที่เหมาะสม

แนะนำ : หากไม่ได้ระบุเหตุผลไว้ให้ปิดใช้งานการลงชื่อเข้าใช้ Google สำหรับผู้ใช้และปิดใช้งานการกู้คืนบัญชีโดยใช้ที่อยู่อีเมลที่เชื่อมโยงกับบัญชี Google ของผู้ใช้ (โดยปกติ แต่ไม่จำเป็นต้องเป็นบัญชี Gmail) เสนอวิธีการลงชื่อเข้าใช้แบบอื่นแก่ผู้ใช้

https://schemas.openid.net/secevent/risc/event-type/account-enabled แนะนำ : เปิดใช้งานการลงชื่อเข้าใช้ Google อีกครั้งสำหรับผู้ใช้และเปิดใช้งานการกู้คืนบัญชีอีกครั้งด้วยที่อยู่อีเมลบัญชี Google ของผู้ใช้
https://schemas.openid.net/secevent/risc/event-type/account-purged แนะนำ : ลบบัญชีของผู้ใช้หรือระบุวิธีการลงชื่อเข้าใช้ทางเลือกอื่น
https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required แนะนำ : ระวังกิจกรรมที่น่าสงสัยในบริการของคุณและดำเนินการตามความเหมาะสม
https://schemas.openid.net/secevent/risc/event-type/verification state = state แนะนำ : บันทึกว่าได้รับโทเค็นทดสอบ

กิจกรรมซ้ำและพลาด

การป้องกันข้ามบัญชีจะพยายามส่งเหตุการณ์ที่เชื่อว่าไม่มีการส่งมอบอีกครั้ง ดังนั้นบางครั้งคุณอาจได้รับเหตุการณ์เดียวกันหลายครั้ง หากสิ่งนี้อาจทำให้เกิดการดำเนินการซ้ำ ๆ ซึ่งทำให้ผู้ใช้ของคุณไม่สะดวกให้พิจารณาใช้การอ้างสิทธิ์ jti (ซึ่งเป็นตัวระบุเฉพาะสำหรับเหตุการณ์) เพื่อยกเลิกการปิดบังเหตุการณ์ มีเครื่องมือภายนอกเช่น Google Cloud Dataflow ที่อาจช่วยให้คุณดำเนินการ dataflow ได้

โปรดทราบว่ากิจกรรมจะถูกส่งด้วยการลองซ้ำแบบ จำกัด ดังนั้นหากผู้รับของคุณหยุดทำงานเป็นระยะเวลานานคุณอาจพลาดกิจกรรมบางอย่างไปอย่างถาวร

ลงทะเบียนผู้รับของคุณ

ในการเริ่มรับเหตุการณ์ความปลอดภัยให้ลงทะเบียนปลายทางผู้รับของคุณโดยใช้ RISC API การเรียกไปยัง RISC API ต้องมาพร้อมกับโทเค็นการอนุญาต

คุณจะได้รับกิจกรรมด้านความปลอดภัยสำหรับผู้ใช้แอปของคุณเท่านั้นดังนั้นคุณต้องมีหน้าจอคำยินยอม OAuth ที่ กำหนดค่าไว้ ในโปรเจ็กต์ GCP ของคุณเป็นข้อกำหนดเบื้องต้นสำหรับขั้นตอนที่อธิบายด้านล่าง

1. สร้างโทเค็นการอนุญาต

ในการสร้างโทเค็นการอนุญาตสำหรับ RISC API ให้สร้าง JWT ด้วยการอ้างสิทธิ์ต่อไปนี้:

{
  "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
}

ลงชื่อ JWT โดยใช้คีย์ส่วนตัวของบัญชีบริการของคุณซึ่งคุณจะพบได้ในไฟล์ JSON ที่คุณดาวน์โหลดเมื่อคุณสร้างคีย์บัญชีบริการ

ตัวอย่างเช่น:

Java

การใช้ java-jwt และ ไลบรารีรับรองความถูกต้องของ 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')

โทเค็นการอนุญาตนี้สามารถใช้เพื่อทำการเรียก RISC API เป็นเวลาหนึ่งชั่วโมง เมื่อโทเค็นหมดอายุให้สร้างใหม่เพื่อทำการเรียก RISC API ต่อไป

2. เรียกใช้ RISC stream configuration API

เมื่อคุณมีโทเค็นการอนุญาตแล้วคุณสามารถใช้ RISC API เพื่อกำหนดค่าสตรีมเหตุการณ์ความปลอดภัยของโปรเจ็กต์รวมถึงการลงทะเบียนปลายทางผู้รับของคุณ

ในการดำเนินการดังกล่าวให้ส่งคำขอ HTTPS POST ไปที่ https://risc.googleapis.com/v1beta/stream:update ระบุปลายทางผู้รับและ ประเภทของเหตุการณ์ความปลอดภัยที่ คุณสนใจ:

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
  ]
}

ตัวอย่างเช่น:

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'])

หากคำขอส่งคืน HTTP 200 แสดงว่าสตรีมเหตุการณ์ได้รับการกำหนดค่าสำเร็จและปลายทางผู้รับของคุณควรเริ่มรับโทเค็นเหตุการณ์ความปลอดภัย ส่วนถัดไปจะอธิบายถึงวิธีทดสอบการกำหนดค่าสตรีมและปลายทางเพื่อตรวจสอบว่าทุกอย่างทำงานร่วมกันได้อย่างถูกต้อง

รับและอัปเดตการกำหนดค่าสตรีมปัจจุบันของคุณ

หากในอนาคตคุณต้องการแก้ไขการกำหนดค่าสตรีมของคุณคุณสามารถทำได้โดยส่งคำขอ GET ที่ได้รับอนุญาตไปที่ https://risc.googleapis.com/v1beta/stream เพื่อรับการกำหนดค่าสตรีมปัจจุบันแก้ไขเนื้อหาการตอบสนอง แล้วโพสต์การกำหนดค่าที่แก้ไขกลับไปที่ https://risc.googleapis.com/v1beta/stream:update ตามที่อธิบายไว้ข้างต้น

หยุดและดำเนินการสตรีมกิจกรรมต่อ

หากคุณจำเป็นต้องหยุดสตรีมกิจกรรมจาก Google โปรดส่งคำขอ POST ที่ได้รับอนุญาตไปที่ https://risc.googleapis.com/v1beta/stream/status:update พร้อมกับ { "status": "disabled" } ในเนื้อหาคำขอ ในขณะที่สตรีมถูกปิดใช้งาน Google จะไม่ส่งเหตุการณ์ไปยังปลายทางของคุณและจะไม่บัฟเฟอร์เหตุการณ์ด้านความปลอดภัยเมื่อเกิดขึ้น หากต้องการเปิดใช้งานสตรีมเหตุการณ์อีกครั้งให้โพสต์ { "status": "enabled" } ไปที่ปลายทางเดียวกัน

3. ไม่บังคับ: ทดสอบการกำหนดค่าสตรีมของคุณ

คุณสามารถตรวจสอบได้ว่าการกำหนดค่าสตรีมและปลายทางของผู้รับทำงานร่วมกันอย่างถูกต้องโดยการส่งโทเค็นการยืนยันผ่านสตรีมเหตุการณ์ของคุณ โทเค็นนี้สามารถมีสตริงเฉพาะที่คุณสามารถใช้เพื่อยืนยันว่าโทเค็นได้รับที่ปลายทางของคุณ

หากต้องการขอโทเค็นการยืนยันให้ส่งคำขอ HTTPS POST ที่ได้รับอนุญาตไปที่ https://risc.googleapis.com/v1beta/stream:verify ในเนื้อหาของคำขอระบุสตริงการระบุบางส่วน:

{
  "state": "ANYTHING"
}

ตัวอย่างเช่น:

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()))

หากคำขอสำเร็จโทเค็นการยืนยันจะถูกส่งไปยังปลายทางที่คุณลงทะเบียน จากนั้นตัวอย่างเช่นหากปลายทางของคุณจัดการโทเค็นการยืนยันโดยเพียงแค่บันทึกไว้คุณสามารถตรวจสอบบันทึกของคุณเพื่อยืนยันว่าได้รับโทเค็นแล้ว

การอ้างอิงรหัสข้อผิดพลาด

ข้อผิดพลาดต่อไปนี้สามารถส่งคืนได้โดย RISC API:

รหัสข้อผิดพลาด ข้อความผิดพลาด การดำเนินการที่แนะนำ
400 การกำหนดค่าสตรีมต้องมีฟิลด์ $ fieldname คำขอของคุณไปยัง https://risc.googleapis.com/v1beta/stream:update endpoint ไม่ถูกต้องหรือไม่สามารถแยกวิเคราะห์ได้ กรุณาใส่ $ fieldname ในคำขอของคุณ
401 ไม่ได้รับอนุญาต การให้สิทธิ์ล้มเหลว ตรวจสอบให้แน่ใจว่าคุณได้แนบ โทเค็นการอนุญาตมา พร้อมกับคำขอและโทเค็นนั้นถูกต้องและยังไม่หมดอายุ
403 ปลายทางการจัดส่งต้องเป็น URL HTTPS ปลายทางการจัดส่งของคุณ (เช่นปลายทางที่คุณคาดว่าจะส่งเหตุการณ์ RISC ไปให้) ต้องเป็น HTTPS เราไม่ส่งเหตุการณ์ RISC ไปยัง HTTP URL
403 การกำหนดค่าสตรีมที่มีอยู่ไม่มีวิธีการจัดส่งที่ตรงตามข้อกำหนดสำหรับ RISC โครงการ Google Cloud ของคุณต้องมีการกำหนดค่า RISC อยู่แล้ว หากคุณใช้ Firebase และเปิดใช้งานการลงชื่อเข้าใช้ Google Firebase จะจัดการ RISC สำหรับโครงการของคุณ คุณจะไม่สามารถสร้างการกำหนดค่าแบบกำหนดเองได้ หากคุณไม่ได้ใช้ Google Sign-In สำหรับโปรเจ็กต์ Firebase ของคุณโปรดปิดการใช้งานจากนั้นลองอัปเดตอีกครั้งหลังจากผ่านไปหนึ่งชั่วโมง
403 ไม่พบโครงการ ตรวจสอบว่าคุณใช้บัญชีบริการที่ถูกต้องสำหรับโครงการที่ถูกต้อง คุณอาจกำลังใช้บัญชีบริการที่เชื่อมโยงกับโปรเจ็กต์ที่ถูกลบ เรียนรู้ วิธีดูบัญชีบริการทั้งหมดที่เชื่อมโยงกับโครงการ
403 บัญชีบริการต้องมีสิทธิ์แก้ไขในโปรเจ็กต์ของคุณ ไปที่คอนโซล Google Cloud Platform ของโปรเจ็กต์และให้สิทธิ์บัญชีบริการที่กำลังทำการโทรแก้ไข / สิทธิ์เจ้าของโปรเจ็กต์ของคุณโดยทำตาม คำแนะนำเหล่านี้
403 API การจัดการสตรีมควรเรียกใช้โดยบัญชีบริการเท่านั้น ข้อมูลเพิ่มเติมเกี่ยวกับ วิธีเรียก Google API ด้วยบัญชีบริการ
403 ปลายทางการจัดส่งไม่ได้อยู่ในโดเมนของโครงการของคุณ ทุกโครงการมีชุด โดเมนที่ได้รับอนุญาต หากปลายทางการจัดส่งของคุณ (เช่นปลายทางที่คุณคาดว่าจะจัดส่งเหตุการณ์ RISC) ไม่ได้ถูกโฮสต์ไว้ในหนึ่งในนั้นเราต้องการให้คุณเพิ่มโดเมนของปลายทางลงในชุดนั้น
403 ในการใช้ API นี้โครงการของคุณต้องมีไคลเอ็นต์ OAuth ที่กำหนดค่าไว้อย่างน้อยหนึ่งรายการ RISC ใช้งานได้ก็ต่อเมื่อคุณสร้างแอปที่รองรับการ ลงชื่อเข้าใช้ Google การเชื่อมต่อนี้ต้องใช้ไคลเอ็นต์ OAuth หากโครงการของคุณไม่มีไคลเอนต์ OAuth อาจเป็นไปได้ว่า RISC จะไม่มีประโยชน์สำหรับคุณ เรียนรู้เพิ่มเติมเกี่ยวกับ การใช้ OAuth ของ Google สำหรับ API ของเรา
403

สถานะที่ไม่รองรับ

สถานะไม่ถูกต้อง

ในขณะนี้เรารองรับสถานะสตรีมที่ " enabled " และ " disabled " เท่านั้น
404

โครงการไม่มีการกำหนดค่า RISC

โครงการไม่มีการกำหนดค่า RISC ไม่สามารถอัปเดตสถานะได้

โทรไปที่ https://risc.googleapis.com/v1beta/stream:update endpoint เพื่อสร้างการกำหนดค่าสตรีมใหม่
4XX / 5XX ไม่สามารถอัปเดตสถานะ ตรวจสอบข้อความแสดงข้อผิดพลาดโดยละเอียดสำหรับข้อมูลเพิ่มเติม

เข้าถึงขอบเขตโทเค็น

หากคุณตัดสินใจใช้โทเค็นการเข้าถึงสำหรับการตรวจสอบสิทธิ์ RISC API นี่คือขอบเขตที่แอปพลิเคชันของคุณต้องร้องขอ:

จุดสิ้นสุด ขอบเขต
https://risc.googleapis.com/v1beta/stream/status https://www.googleapis.com/auth/risc.status.readonly หรือ 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 หรือ 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

ต้องการความช่วยเหลือ?

ขั้นแรกตรวจสอบส่วน การอ้างอิงรหัสข้อผิดพลาด ของเรา หากคุณยังคงมีคำถามให้โพสต์ไว้ใน Stack Overflow พร้อมด้วยแท็ก #SecEvents