क्रॉस-खाता सुरक्षा के साथ उपयोगकर्ता खातों को सुरक्षित रखें

यदि आपका ऐप उपयोगकर्ताओं को Google का उपयोग करके अपने खातों में साइन इन करने देता है, तो आप क्रॉस-खाता सुरक्षा सेवा द्वारा प्रदान की गई सुरक्षा ईवेंट सूचनाओं को सुनकर और उनका जवाब देकर इन साझा उपयोगकर्ताओं के खातों की सुरक्षा में सुधार कर सकते हैं।

ये सूचनाएं आपको आपके उपयोगकर्ताओं के Google खातों में बड़े बदलावों के लिए सचेत करती हैं, जो अक्सर आपके ऐप के साथ उनके खातों के लिए सुरक्षा निहितार्थ भी हो सकते हैं। उदाहरण के लिए, यदि किसी उपयोगकर्ता के Google खाते को अपहृत किया गया था, तो यह संभावित रूप से ईमेल खाता पुनर्प्राप्ति या एकल साइन-ऑन के उपयोग के माध्यम से आपके ऐप के साथ उपयोगकर्ता के खाते का समझौता कर सकता है।

इस तरह के आयोजनों की जोखिम क्षमता को कम करने में आपकी मदद करने के लिए, Google आपकी सेवा वस्तुओं को सुरक्षा ईवेंट टोकन कहता है। ये टोकन बहुत कम जानकारी को उजागर करते हैं - बस सुरक्षा घटना का प्रकार और जब यह हुआ, और प्रभावित उपयोगकर्ता की पहचानकर्ता- लेकिन आप प्रतिक्रिया में उचित कार्रवाई करने के लिए उनका उपयोग कर सकते हैं। उदाहरण के लिए, यदि किसी उपयोगकर्ता के Google खाते से छेड़छाड़ की गई थी, तो आप उस उपयोगकर्ता के लिए Google साइन-इन को अस्थायी रूप से अक्षम कर सकते हैं और खाता पुनर्प्राप्ति ईमेल को उपयोगकर्ता के Gmail पते पर भेजे जाने से रोक सकते हैं।

क्रॉस-अकाउंट प्रोटेक्शन RISC मानक पर आधारित है, जिसे OpenID फाउंडेशन में विकसित किया गया है।

अवलोकन

अपने ऐप या सेवा के साथ क्रॉस-अकाउंट प्रोटेक्शन का उपयोग करने के लिए, आपको निम्नलिखित कार्यों को पूरा करना होगा:

  1. अपना प्रोजेक्ट API Console में सेट करें।

  2. एक ईवेंट रिसीवर एंडपॉइंट बनाएं, जिस पर Google सुरक्षा ईवेंट टोकन भेजेगा। यह समापन बिंदु इसके द्वारा प्राप्त टोकन को सत्यापित करने और फिर आपके द्वारा चुने जाने पर सुरक्षा घटनाओं पर प्रतिक्रिया देने के लिए जिम्मेदार है।

  3. सुरक्षा ईवेंट टोकन प्राप्त करना प्रारंभ करने के लिए Google के साथ अपना समापन बिंदु पंजीकृत करें।

शर्त

आप केवल उन Google उपयोगकर्ताओं के लिए सुरक्षा ईवेंट टोकन प्राप्त करते हैं, जिन्होंने अपनी प्रोफ़ाइल जानकारी या ईमेल पतों तक पहुँचने के लिए आपकी सेवा की अनुमति दी है। आपको profile या email स्कोप का अनुरोध करके यह अनुमति मिलती है। Google साइन-इन SDK डिफ़ॉल्ट रूप से इन क्षेत्रों का अनुरोध करते हैं, लेकिन यदि आप डिफ़ॉल्ट सेटिंग्स का उपयोग नहीं करते हैं, या यदि आप सीधे Google के OpenID Connect समापन बिंदु तक पहुंचते हैं, तो सुनिश्चित करें कि आप इनमें से कम से कम एक क्षेत्र का अनुरोध कर रहे हैं।

API Console में एक प्रोजेक्ट सेट करें

इससे पहले कि आप सुरक्षा ईवेंट टोकन प्राप्त करना शुरू कर सकें, आपको एक सेवा खाता बनाना होगा और अपने API Console प्रोजेक्ट में RISC API को सक्षम करना होगा। आपको उसी API Console प्रोजेक्ट का उपयोग करना चाहिए जिसका उपयोग आप अपने ऐप में Google सेवाओं, जैसे Google साइन-इन तक पहुंचने के लिए करते हैं।

सेवा खाता बनाने के लिए:

  1. API Console Credentials page खोलें। जब संकेत दिया जाता है, तो अपने ऐप में Google सेवाओं का उपयोग करने के लिए उपयोग किए जाने वाले API Console प्रोजेक्ट को चुनें।

  2. क्रेडेंशियल बनाएं > सेवा खाता कुंजी क्लिक करें .

  3. संपादक की भूमिका के साथ एक नया सेवा खाता बनाएँ।

    JSON कुंजी प्रकार चुनें और फिर बनाएँ पर क्लिक करें । जब कुंजी बनाई जाती है, तो आप एक JSON फ़ाइल डाउनलोड करेंगे जिसमें आपके सेवा खाते के क्रेडेंशियल होंगे। इस फ़ाइल को कहीं सुरक्षित रखें, लेकिन आपके ईवेंट रिसीवर एंडपॉइंट के लिए भी सुलभ है।

जब आप अपने प्रोजेक्ट के क्रेडेंशियल पृष्ठ पर हों, तो Google साइन-इन के लिए आपके द्वारा उपयोग की जाने वाली क्लाइंट आईडी पर भी ध्यान दें। आमतौर पर, आपके पास प्रत्येक प्लेटफ़ॉर्म के लिए एक क्लाइंट आईडी होती है जिसका आप समर्थन करते हैं। सुरक्षा क्लाइंट टोकन को मान्य करने के लिए आपको इन क्लाइंट आईडी की आवश्यकता होगी, जैसा कि अगले भाग में बताया गया है।

आरआईएससी एपीआई को सक्षम करने के लिए:

  1. API Console में RISC API पेज खोलें। सुनिश्चित करें कि आप जिस प्रोजेक्ट का उपयोग Google सेवाओं तक पहुंचने के लिए करते हैं वह अभी भी चयनित है।

  2. RISC नियम पढ़ें और सुनिश्चित करें कि आप आवश्यकताओं को समझते हैं।

    यदि आप किसी संगठन के स्वामित्व वाली परियोजना के लिए API को सक्षम कर रहे हैं, तो सुनिश्चित करें कि आप अपने संगठन को RISC शर्तों से बाँधने के लिए अधिकृत हैं।

  3. केवल तभी सक्षम करें पर क्लिक करें जब आप RISC शर्तों से सहमत हों।

इवेंट रिसीवर एंडपॉइंट बनाएं

Google से सुरक्षा ईवेंट सूचनाएं प्राप्त करने के लिए, आप एक HTTPS समापन बिंदु बनाते हैं जो HTTPS POST अनुरोधों को संभालता है। आपके द्वारा इस समापन बिंदु को पंजीकृत करने के बाद (नीचे देखें), Google अंत बिंदु पर सुरक्षा ईवेंट टोकन नामक क्रिप्टोग्राफ़िक रूप से हस्ताक्षरित स्ट्रिंग्स पोस्ट करना शुरू कर देगा। सुरक्षा घटना टोकन जेडब्ल्यूटी पर हस्ताक्षर किए जाते हैं जिसमें एकल सुरक्षा-संबंधित घटना के बारे में जानकारी होती है।

आपके समापन बिंदु पर प्राप्त होने वाले प्रत्येक सुरक्षा ईवेंट टोकन के लिए, पहले टोकन को मान्य और डीकोड करें, फिर अपनी सेवा के लिए उपयुक्त सुरक्षा ईवेंट को संभालें। निम्नलिखित अनुभाग इन कार्यों का वर्णन करते हैं:

1. सुरक्षा घटना टोकन को डीकोड और मान्य करें

चूँकि सुरक्षा ईवेंट टोकन एक विशिष्ट प्रकार के JWT हैं, आप किसी भी JWT लाइब्रेरी का उपयोग कर सकते हैं, जैसे कि jwt.io पर सूचीबद्ध, को डिकोड और मान्य करने के लिए। आप जो भी पुस्तकालय का उपयोग करते हैं, आपका टोकन सत्यापन कोड निम्नलिखित कार्य करना चाहिए:

  1. Google के RISC कॉन्फ़िगरेशन दस्तावेज़ से क्रॉस-खाता सुरक्षा जारीकर्ता पहचानकर्ता ( issuer ) और हस्ताक्षर कुंजी प्रमाणपत्र URI ( jwks_uri ) प्राप्त करें, जिसे आप https://accounts.google.com/.well-known/risc-configuration पर देख सकते हैं।
  2. अपनी पसंद के JWT लाइब्रेरी का उपयोग करके, सुरक्षा ईवेंट टोकन के हेडर से साइनिंग कुंजी आईडी प्राप्त करें।
  3. Google के साइनिंग की सर्टिफिकेट दस्तावेज़ से, सार्वजनिक कुंजी को उस कुंजी आईडी के साथ प्राप्त करें जो आपको पिछले चरण में मिली थी। यदि दस्तावेज़ में उस आईडी की कुंजी नहीं है जिसे आप ढूंढ रहे हैं, तो यह संभावना है कि सुरक्षा ईवेंट टोकन अमान्य है, और आपका समापन बिंदु HTTP त्रुटि 400 लौटाएगा।
  4. अपनी पसंद की JWT लाइब्रेरी का उपयोग करते हुए, निम्नलिखित को सत्यापित करें:
    • पिछले चरण में आपको मिली सार्वजनिक कुंजी का उपयोग करके सुरक्षा ईवेंट टोकन पर हस्ताक्षर किए गए हैं।
    • टोकन का aud दावा आपके ऐप्स की क्लाइंट आईडी में से एक है।
    • iss टोकन मैचों जारीकर्ता पहचानकर्ता आप RISC खोज दस्तावेज़ से मिल गया के दावे। ध्यान दें कि आपको टोकन की समाप्ति ( exp ) को सत्यापित करने की आवश्यकता नहीं है क्योंकि सुरक्षा घटना टोकन ऐतिहासिक घटनाओं का प्रतिनिधित्व करते हैं और इस तरह, समाप्त नहीं होते हैं।

उदाहरण के लिए:

जावा

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

अजगर

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 दावों से संकेत मिलता है टोकन (गूगल) और टोकन का जारीकर्ता प्राप्तकर्ता (आपकी सेवा) करना है। आपने पिछले चरण में इन दावों की पुष्टि की थी.

jti दावा एक स्ट्रिंग है जो एकल सुरक्षा घटना की पहचान करता है, और धारा के लिए अद्वितीय है। इस पहचानकर्ता का उपयोग आप ट्रैक कर सकते हैं कि आपको कौन सी सुरक्षा घटनाएं प्राप्त हुई हैं।

events दावे में टोकन द्वारा दर्शाए गए सुरक्षा ईवेंट के बारे में जानकारी होती है। यह दावा एक घटना प्रकार पहचानकर्ता से एक subject दावे के लिए एक मानचित्रण है, जो उस उपयोगकर्ता को निर्दिष्ट करता है जो इस घटना से संबंधित है, और उस घटना के बारे में कोई अतिरिक्त विवरण जो उपलब्ध हो सकता है।

subject दावा उपयोगकर्ता की विशिष्ट Google खाता आईडी ( sub ) के साथ किसी विशेष उपयोगकर्ता की पहचान करता है। यह आईडी Google साइन-इन द्वारा निर्मित आईडी टोकन में निहित पहचानकर्ता के समान है । जब 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 API तक पहुंच के लिए है, तो आपके द्वारा संग्रहीत उपयोगकर्ता के किसी भी OAuth टोकन को हटा दें।

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

आवश्यक : यदि खाता अक्षम करने का कारण hijacking था, तो उपयोगकर्ता के वर्तमान खुले सत्रों को समाप्त करके उसके खाते को फिर से सुरक्षित करें।

सुझाव : यदि खाता अक्षम करने का कारण bulk-account , तो अपनी सेवा पर उपयोगकर्ता की गतिविधि का विश्लेषण करें और उचित अनुवर्ती कार्रवाई निर्धारित करें।

सुझाया गया : यदि कोई कारण नहीं दिया गया था, तो उपयोगकर्ता के लिए Google साइन-इन अक्षम करें और उपयोगकर्ता के Google खाते से संबद्ध ईमेल पते का उपयोग करके खाता पुनर्प्राप्ति अक्षम करें (आमतौर पर, लेकिन जरूरी नहीं कि एक जीमेल खाता)। उपयोगकर्ता को वैकल्पिक साइन-इन विधि की पेशकश करें।

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 सुझाव : लॉग करें कि एक परीक्षण टोकन प्राप्त हुआ था।

दोहराई गई और छूटी हुई घटनाएं

क्रॉस-अकाउंट प्रोटेक्शन उन ईवेंट को फिर से डिलीवर करने का प्रयास करेगा, जिनके बारे में उसे लगता है कि डिलीवर नहीं किया गया है। इसलिए, आप कभी-कभी एक ही घटना को कई बार प्राप्त कर सकते हैं। यदि इससे बार-बार ऐसी कार्रवाइयां हो सकती हैं जो आपके उपयोगकर्ताओं को असुविधा jti , तो jti दावे (जो किसी घटना के लिए एक विशिष्ट पहचानकर्ता है) का उपयोग करने पर विचार करें ताकि घटनाओं को डी-डुप किया जा सके। Google क्लाउड डेटाफ़्लो जैसे बाहरी उपकरण हैं जो डी-डुप डेटाफ़्लो को निष्पादित करने में आपकी सहायता कर सकते हैं।

ध्यान दें कि ईवेंट सीमित पुनर्प्रयासों के साथ वितरित किए जाते हैं, इसलिए यदि आपका रिसीवर लंबे समय तक बंद रहता है तो आप कुछ ईवेंट को स्थायी रूप से याद कर सकते हैं।

अपना रिसीवर पंजीकृत करें

सुरक्षा ईवेंट प्राप्त करना शुरू करने के लिए, RISC API का उपयोग करके अपना रिसीवर एंडपॉइंट पंजीकृत करें। आरआईएससी एपीआई को कॉल के साथ एक प्राधिकरण टोकन होना चाहिए।

आपको अपने ऐप के उपयोगकर्ताओं के लिए केवल सुरक्षा ईवेंट प्राप्त होंगे, इसलिए आपको नीचे वर्णित चरणों के लिए एक शर्त के रूप में आपके GCP प्रोजेक्ट में OAuth सहमति स्क्रीन कॉन्फ़िगर करने की आवश्यकता है।

1. एक प्राधिकरण टोकन उत्पन्न करें

आरआईएससी एपीआई के लिए एक प्राधिकरण टोकन उत्पन्न करने के लिए, निम्नलिखित दावों के साथ एक जेडब्ल्यूटी बनाएं:

067dacac0

अपने सेवा खाते की निजी कुंजी का उपयोग करके JWT पर हस्ताक्षर करें, जिसे आप उस JSON फ़ाइल में पा सकते हैं जिसे आपने सेवा खाता कुंजी बनाते समय डाउनलोड किया था।

उदाहरण के लिए:

जावा

जावा-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;
}

अजगर

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 स्ट्रीम कॉन्फ़िगरेशन API को कॉल करें

अब जब आपके पास एक प्राधिकरण टोकन है, तो आप अपने रिसीवर समापन बिंदु को पंजीकृत करने सहित, अपने प्रोजेक्ट की सुरक्षा इवेंट स्ट्रीम को कॉन्फ़िगर करने के लिए RISC API का उपयोग कर सकते हैं।

ऐसा करने के लिए, https://risc.googleapis.com/v1beta/stream:update एक 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
  ]
}

उदाहरण के लिए:

जावा

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

अजगर

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 देता है, तो ईवेंट स्ट्रीम को सफलतापूर्वक कॉन्फ़िगर किया गया था और आपके रिसीवर एंडपॉइंट को सुरक्षा ईवेंट टोकन प्राप्त करना शुरू करना चाहिए। अगला खंड बताता है कि आप अपने स्ट्रीम कॉन्फ़िगरेशन और एंडपॉइंट का परीक्षण कैसे कर सकते हैं ताकि यह सत्यापित किया जा सके कि सब कुछ एक साथ ठीक से काम कर रहा है।

अपना वर्तमान स्ट्रीम कॉन्फ़िगरेशन प्राप्त करें और अपडेट करें

यदि, भविष्य में, आप कभी भी अपने स्ट्रीम कॉन्फ़िगरेशन को संशोधित करना चाहते हैं, तो आप वर्तमान स्ट्रीम कॉन्फ़िगरेशन को प्राप्त करने के लिए https://risc.googleapis.com/v1beta/stream लिए एक अधिकृत GET अनुरोध करके ऐसा कर सकते हैं, प्रतिक्रिया बॉडी को संशोधित कर सकते हैं , और फिर संशोधित कॉन्फ़िगरेशन को वापस https://risc.googleapis.com/v1beta/stream:update जैसा कि ऊपर वर्णित है।

इवेंट स्ट्रीम को रोकें और फिर से शुरू करें

यदि आपको कभी भी Google की ओर से ईवेंट स्ट्रीम को रोकने की आवश्यकता हो, तो https://risc.googleapis.com/v1beta/stream/status:update with { "status": "disabled" } एक अधिकृत POST अनुरोध https://risc.googleapis.com/v1beta/stream/status:update । स्ट्रीम के निष्क्रिय होने पर, Google आपके समापन बिंदु पर ईवेंट नहीं भेजता है और सुरक्षा ईवेंट होने पर उन्हें बफ़र नहीं करता है। इवेंट स्ट्रीम को फिर से { "status": "enabled" } करने के लिए, POST { "status": "enabled" } को उसी एंडपॉइंट पर भेजें।

3. वैकल्पिक: अपने स्ट्रीम कॉन्फ़िगरेशन का परीक्षण करें

आप अपने इवेंट स्ट्रीम के माध्यम से एक सत्यापन टोकन भेजकर सत्यापित कर सकते हैं कि आपका स्ट्रीम कॉन्फ़िगरेशन और रिसीवर एंडपॉइंट एक साथ ठीक से काम कर रहे हैं। इस टोकन में एक अद्वितीय स्ट्रिंग हो सकती है जिसका उपयोग आप यह सत्यापित करने के लिए कर सकते हैं कि टोकन आपके समापन बिंदु पर प्राप्त हुआ था।

सत्यापन टोकन का अनुरोध करने के लिए, https://risc.googleapis.com/v1beta/stream:verify अधिकृत HTTPS POST अनुरोध https://risc.googleapis.com/v1beta/stream:verify । अनुरोध के मुख्य भाग में, कुछ पहचान स्ट्रिंग निर्दिष्ट करें:

{
  "state": "ANYTHING"
}

उदाहरण के लिए:

जावा

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

अजगर

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 स्ट्रीम कॉन्फ़िगरेशन में $ फ़ील्डनाम फ़ील्ड होना चाहिए। Https://risc.googleapis.com/v1beta/stream:update समापन बिंदु पर आपका अनुरोध अमान्य है या पार्स नहीं किया जा सकता है। कृपया अपने अनुरोध में $fieldname शामिल करें।
401 अनधिकृत। प्रमाणीकरण विफल। सुनिश्चित करें कि आपने अनुरोध के साथ एक प्राधिकरण टोकन संलग्न किया है और यह टोकन मान्य है और इसकी समय सीमा समाप्त नहीं हुई है।
403 वितरण समापन बिंदु एक HTTPS URL होना चाहिए। आपका वितरण समापन बिंदु (यानी आप जिस समापन बिंदु RISC घटनाओं को वितरित किया जाना चाहते हैं) HTTPS होना चाहिए। हम HTTP URL पर RISC ईवेंट नहीं भेजते हैं।
403 मौजूदा स्ट्रीम कॉन्फ़िगरेशन में RISC के लिए युक्ति-संगत वितरण विधि नहीं है। आपके Google क्लाउड प्रोजेक्ट में पहले से ही RISC कॉन्फ़िगरेशन होना चाहिए। यदि आप Firebase का उपयोग कर रहे हैं और Google साइन-इन सक्षम है, तो Firebase आपकी परियोजना के लिए RISC का प्रबंधन करेगा; आप एक कस्टम कॉन्फ़िगरेशन नहीं बना पाएंगे। यदि आप अपने फायरबेस प्रोजेक्ट के लिए Google साइन-इन का उपयोग नहीं कर रहे हैं, तो कृपया इसे अक्षम करें, और फिर एक घंटे के बाद फिर से अपडेट करने का प्रयास करें।
403 प्रोजेक्ट नहीं मिल सका। सुनिश्चित करें कि आप सही परियोजना के लिए सही सेवा खाते का उपयोग कर रहे हैं। हो सकता है कि आप किसी हटाए गए प्रोजेक्ट से संबद्ध सेवा खाते का उपयोग कर रहे हों। किसी प्रोजेक्ट से जुड़े सभी सेवा खातों को देखना सीखें।
403 सेवा खाते में आपके प्रोजेक्ट में संपादक की अनुमति होनी चाहिए। अपने प्रोजेक्ट के Google क्लाउड प्लेटफ़ॉर्म कंसोल पर जाएं और इन निर्देशों का पालन ​​करके अपने प्रोजेक्ट को कॉल संपादक / स्वामी की अनुमति देने वाले सेवा खाते को अनुदान दें
403 स्ट्रीम प्रबंधन API को केवल एक सेवा खाते द्वारा ही कॉल किया जाना चाहिए। Google API को आप सेवा खाते से कैसे कॉल कर सकते हैं, इस बारे में अधिक जानकारी यहां दी गई है।
403 वितरण समापन बिंदु आपके किसी भी प्रोजेक्ट के डोमेन से संबंधित नहीं है। प्रत्येक प्रोजेक्ट में अधिकृत डोमेन का एक सेट होता है यदि आपका वितरण समापन बिंदु (अर्थात वह समापन बिंदु जिस पर आप RISC ईवेंट वितरित किए जाने की अपेक्षा करते हैं) उनमें से किसी एक पर होस्ट नहीं किया गया है, तो हम चाहते हैं कि आप उस सेट में समापन बिंदु का डोमेन जोड़ें।
403 इस API का उपयोग करने के लिए आपके प्रोजेक्ट में कम से कम एक OAuth क्लाइंट कॉन्फ़िगर होना चाहिए। RISC केवल तभी काम करता है जब आप एक ऐसा ऐप बनाते हैं जो Google साइन इन का समर्थन करता है। इस कनेक्शन के लिए एक OAuth क्लाइंट की आवश्यकता है। यदि आपके प्रोजेक्ट में कोई OAuth क्लाइंट नहीं है, तो संभव है कि RISC आपके लिए उपयोगी नहीं होगा। Google के हमारे एपीआई के लिए OAuth के उपयोग के बारे में अधिक जानें।
403

असमर्थित स्थिति।

अमान्य स्थिति।

हम इस समय केवल स्ट्रीम स्टेटस " enabled " और " disabled " का समर्थन करते हैं।
404

प्रोजेक्ट का कोई RISC कॉन्फ़िगरेशन नहीं है।

प्रोजेक्ट में कोई मौजूदा RISC कॉन्फ़िगरेशन नहीं है, स्थिति को अपडेट नहीं कर सकता।

एक नया स्ट्रीम कॉन्फ़िगरेशन बनाने के लिए https://risc.googleapis.com/v1beta/stream:update एंडपॉइंट पर कॉल करें।
4XX/5XX स्थिति अपडेट करने में असमर्थ। अधिक जानकारी के लिए विस्तृत त्रुटि संदेश देखें।

टोकन स्कोप तक पहुंच

क्या आपको RISC API को प्रमाणित करने के लिए पहुँच टोकन का उपयोग करने का निर्णय लेना चाहिए, ये वे स्कोप हैं जिन्हें आपके आवेदन को अनुरोध करना चाहिए:

endpoint क्षेत्र
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

मदद की ज़रूरत है?

सबसे पहले, हमारी त्रुटि कोड संदर्भ अनुभाग देखें। यदि आपके पास अभी भी प्रश्न हैं, तो उन्हें स्टेक ओवरफ़्लो पर #SecEvents टैग के साथ पोस्ट करें।