Google מחויבת לקידום הון גזעני לקהילות שחורות. תראה איך.

הגן על חשבונות משתמשים באמצעות הגנה בין חשבונות

אם האפליקציה שלך מאפשרת למשתמשים להיכנס לחשבונות שלהם באמצעות Google, אתה יכול לשפר את האבטחה של חשבונות משתמשים משותפים אלה על ידי האזנה ומענה להודעות על אירועי אבטחה שמספק שירות הגנה בין חשבונות.

התראות אלה מתריעות על שינויים משמעותיים בחשבונות Google של המשתמשים שלך, שלעתים קרובות יכולים להיות גם השלכות אבטחה על חשבונותיהם באפליקציה שלך. למשל, אם חשבון Google של משתמש נחטף, זה עלול להוביל לפגיעה בחשבון המשתמש באפליקציה שלך באמצעות שחזור חשבון דוא"ל או שימוש בכניסה יחידה.

כדי לעזור לך למצות את פוטנציאל הסיכון של אירועים כאלה, גוגל שולחת לאובייקטים של השירות שלך הנקראים אסימוני אירועי אבטחה. אסימונים אלה חושפים מעט מאוד מידע - רק סוג אירוע האבטחה ומתי התרחש, והמזהה של המשתמש המושפע - אך ניתן להשתמש בהם בכדי לנקוט בפעולות מתאימות בתגובה. לדוגמא, אם חשבון Google של משתמש נפגע, אתה יכול להשבית באופן זמני כניסה של Google עבור אותו משתמש ולמנוע את שליחת הודעות דוא"ל לשחזור חשבון לכתובת Gmail של המשתמש.

הגנה בין חשבונות מבוססת על תקן RISC , שפותח בקרן OpenID.

סקירה כללית

כדי להשתמש בהגנה בין חשבונות עם האפליקציה או השירות שלך, עליך לבצע את המשימות הבאות:

  1. הגדר את הפרויקט שלך ב- API Console.

  2. צור נקודת קצה של מקלט אירועים, שאליה גוגל תשלח אסימונים לאירועי אבטחה. נקודת קצה זו אחראית לאימות האסימונים שהיא מקבלת ואז להגיב לאירועי אבטחה בכל דרך שתבחר.

  3. רשום את נקודת הקצה שלך ב- Google כדי להתחיל לקבל אסימונים לאירועי אבטחה.

תְנַאִי מוּקדָם

אתה מקבל רק אסימונים לאירועי אבטחה עבור משתמשי Google שהעניקו הרשאת שירות שלך לגשת למידע הפרופיל שלהם או לכתובות הדוא"ל שלהם. אתה מקבל הרשאה זו על ידי בקשת טווח profile או email . SDK של כניסה של Google מבקש כברירת מחדל את ההיקפים הללו, אך אם אינך משתמש בהגדרות ברירת המחדל, או אם אתה ניגש ישירות לנקודת הקצה של OpenID Connect של Google, ודא שאתה מבקש לפחות אחד מהיקפים אלה.

הגדר פרויקט ב- API Console

לפני שתוכל להתחיל לקבל אסימונים לאירועי אבטחה, עליך ליצור חשבון שירות ולהפעיל את ה- RISC API בפרויקט API Console שלך. עליך להשתמש באותו פרויקט API Console שבו אתה משתמש כדי לגשת לשירותי Google, כגון כניסה של Google, באפליקציה שלך.

ליצירת חשבון השירות:

  1. פתח את API Console Credentials page . כשתתבקש, בחר בפרויקט API Console שבו אתה משתמש כדי לגשת לשירותי Google באפליקציה שלך.

  2. לחץ על צור אישורים> מפתח חשבון שירות .

  3. צור חשבון שירות חדש עם תפקיד העורך.

    בחר את סוג המפתח JSON ואז לחץ על צור . לאחר יצירת המפתח, תוריד קובץ JSON המכיל את אישורי חשבון השירות שלך. שמור על קובץ זה במקום כלשהו בטוח, אך נגיש גם לנקודת הסיום של מקלט האירוע שלך.

בזמן שאתה נמצא בדף האישורים של הפרויקט שלך, שים לב גם לזהות הלקוח שבהם אתה משתמש בכניסה של Google. בדרך כלל, יש לך מזהה לקוח עבור כל פלטפורמה שאתה תומך בה. תזדקק למזהי לקוח אלה כדי לאמת אסימונים לאירועי אבטחה, כמתואר בסעיף הבא.

להפעלת ה- API של RISC:

  1. פתח את דף ה- RISC API ב- API Console. ודא שהפרויקט שבו אתה משתמש כדי לגשת לשירותי Google עדיין נבחר.

  2. קרא את תנאי RISC וודא שאתה מבין את הדרישות.

    אם אתה מפעיל את ה- API לפרויקט שבבעלות ארגון, ודא שאתה מורשה לאגד את הארגון שלך לתנאי RISC.

  3. לחץ על הפעל רק אם אתה מסכים לתנאי RISC.

צור נקודת סיום של מקלט אירוע

כדי לקבל התראות על אירועי אבטחה מגוגל, אתה יוצר נקודת קצה של HTTPS המטפלת בבקשות HTTPS POST. לאחר שתירשם נקודת קצה זו (ראה להלן), גוגל תתחיל לפרסם מחרוזות חתומות בקריפטוגרפיה הנקראות אסימונים לאירועי אבטחה לנקודת הקצה. אסימונים לאירועי אבטחה הם JWT חתומים המכילים מידע על אירוע יחיד הקשור לאבטחה.

עבור כל אסימון אירוע אבטחה שתקבל בנקודת הקצה שלך, אמת תחילה ופענח את האסימון ואז התמודד עם אירוע האבטחה כמתאים לשירות שלך. החלקים הבאים מתארים משימות אלה:

1. לפענח ולאמת את אסימון אירוע האבטחה

מכיוון שאסימונים לאירועי אבטחה הם סוג מסוים של JWT, אתה יכול להשתמש בכל ספריית JWT, כגון אחת המופיעה ב- jwt.io , כדי לפענח ולאמתם. בכל ספרייה שתשתמש, קוד אימות האסימונים שלך חייב לבצע את הפעולות הבאות:

  1. קבל את המזהה של מנפיק הגנת החשבונות ( issuer ) ואת אישורי מפתח החתימה URI ( jwks_uri ) ממסמך תצורת ה- RISC של גוגל, שתמצא בכתובת https://accounts.google.com/.well-known/risc-configuration .
  2. באמצעות ספריית JWT לבחירתך, קבל את מזהה מפתח החתימה מכותרת אסימון אירוע האבטחה.
  3. ממסמך אישורי החתימה של גוגל, קבל את המפתח הציבורי עם מזהה המפתח שקיבלת בשלב הקודם. אם המסמך אינו מכיל מפתח עם המזהה שאתה מחפש, ככל הנראה אסימון אירוע האבטחה אינו חוקי, ונקודת הקצה שלך אמורה להחזיר שגיאת 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 טענות מצביעים מנפיקים את האסימון (Google) ואת של האסימון מיועד נמען (שירות). אימתת טענות אלה בשלב הקודם.

התביעה 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, סיים את ההפעלות שפתוחות כעת. בנוסף, ייתכן שתרצה להציע למשתמש להגדיר שיטת כניסה חלופית.

מוצע : אם האסימון מיועד לגישה לממשקי API אחרים של גוגל, מחק את אחד מסימני ה- 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 מוצע : היכנס שהתקבל אסימון בדיקה.

אירועים משוכפלים ופספסים

הגנה בין חשבונות תנסה למסור מחדש אירועים שלדעתם לא הועברו. לכן, לפעמים אתה עשוי לקבל את אותו אירוע מספר פעמים. אם זה עלול לגרום לפעולות חוזרות ונשנות שמטרידות את המשתמשים שלך, שקול להשתמש בתביעת jti (שהיא מזהה ייחודי לאירוע) כדי לבטל את הריפוי מהאירועים. ישנם כלים חיצוניים כמו Google Cloud Dataflow שעשויים לעזור לך לבצע את זרימת הנתונים de-dup.

שים לב שהאירועים מועברים עם נסיונות חוזרים מוגבלים, כך שאם המקלט שלך מושבת לתקופה ממושכת אתה עלול להחמיץ קבוע אירועים מסוימים.

רשום את המקלט שלך

כדי להתחיל לקבל אירועי אבטחה, רשום את נקודת הקצה של המקלט שלך באמצעות RISC API. יש לצרף לשיחות ל- API של RISC אסימון הרשאה.

תקבל אירועי אבטחה רק עבור המשתמשים באפליקציה שלך, לכן עליך להגדיר בפרויקט GCP שלך מסך הסכמת OAuth כתנאי מוקדם לשלבים המתוארים להלן.

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-jwt ובספריית האימות של גוגל :

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. התקשר ל- API להגדרת תצורת זרם RISC

עכשיו שיש לך אסימון הרשאה, אתה יכול להשתמש ב- 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
  ]
}

לדוגמה:

ג'אווה

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, זרם האירוע הוגדר בהצלחה ונקודת הקצה של המקלט שלך אמורה להתחיל לקבל אסימונים לאירועי אבטחה. החלק הבא מתאר כיצד ניתן לבדוק את תצורת הזרם ואת נקודת הקצה שלך כדי לוודא שהכל עובד כהלכה יחד.

קבל ועדכן את תצורת הזרם הנוכחית שלך

אם בעתיד תרצה לשנות את תצורת הזרם שלך, תוכל לעשות זאת על ידי בקשת GET מורשית לכתובת https://risc.googleapis.com/v1beta/stream כדי לקבל את תצורת הזרם הנוכחית, תוך שינוי גוף התגובה. ולאחר מכן פרסם את התצורה ששונתה בחזרה https://risc.googleapis.com/v1beta/stream:update כמתואר לעיל.

עצור וחדש את זרם האירוע

אם אי פעם תצטרך להפסיק את זרם האירועים מגוגל, הגש בקשת POST מורשית לכתובת https://risc.googleapis.com/v1beta/stream/status:update עם { "status": "disabled" } בגוף הבקשה. בזמן שהזרם מבוטל, גוגל לא שולחת אירועים לנקודת הקצה שלך ולא מאגרת אירועי אבטחה כאשר הם מתרחשים. כדי להפעיל מחדש את זרם האירוע, POST { "status": "enabled" } לאותה נקודת קצה.

3. אופציונלי: בדוק את תצורת הזרם שלך

אתה יכול לוודא שתצורת הזרם ונקודת הקצה של המקלט שלך עובדים כהלכה על ידי שליחת אסימון אימות דרך זרם האירוע שלך. אסימון זה יכול להכיל מחרוזת ייחודית בה תוכלו להשתמש כדי לוודא שהאסימון התקבל בנקודת הסיום שלכם.

כדי לבקש אסימון אימות, הגש בקשת 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()))

אם הבקשה תצליח, אסימון האימות יישלח לנקודת הקצה שרשמת. ואז, למשל, אם נקודת הקצה שלך מטפלת באסימני אימות פשוט על ידי רישום אותם, אתה יכול לבדוק את יומניך כדי לאשר שהאסימון התקבל.

הפניה לקוד שגיאה

ניתן להחזיר את השגיאות הבאות באמצעות ממשק ה- API של RISC:

קוד שגיאה הודעת שגיאה פעולות מוצעות
400 תצורת הזרם חייבת להכיל שדה $ fieldname . בקשתך ל https://risc.googleapis.com/v1beta/stream:update נקודת סיום אינה חוקית או שאי אפשר לנתח אותה. אנא כלול את $ fieldname בבקשתך .
401 לא מורשה. האישור נכשל. ודא שצירפת אסימון הרשאה עם הבקשה ושהאסימון תקף ולא פג תוקפו.
403 נקודת הקצה למשלוח חייבת להיות כתובת HTTPS. נקודת הסיום שלך למשלוח (כלומר נקודת הסיום אליה אתה מצפה שיועברו אירועי RISC) חייבת להיות HTTPS. אנו לא שולחים אירועי RISC לכתובות אתרי HTTP.
403 לתצורת הזרם הקיימת אין שיטת מסירה תואמת מפרט ל- RISC. על פרויקט Google Cloud שלך כבר להיות בעל תצורת RISC. אם אתה משתמש ב- Firebase והכניסה של Google מופעלת, Firebase תנהל את RISC עבור הפרויקט שלך; לא תוכל ליצור תצורה מותאמת אישית. אם אינך משתמש בכניסה של Google לפרויקט Firebase שלך, השבת אותו ולאחר מכן נסה לעדכן שוב לאחר שעה.
403 פרויקט לא נמצא. ודא שאתה משתמש בחשבון השירות הנכון לפרויקט הנכון. ייתכן שאתה משתמש בחשבון שירות המשויך לפרויקט שנמחק. למד כיצד לראות את כל חשבונות השירות המשויכים לפרויקט .
403 על חשבון השירות לכלול הרשאות עורך בפרויקט שלך. עבור לקונסולת Google Cloud Platform של הפרויקט שלך והעניק לחשבון השירות שמעניק לעורך / הבעלים שיחות הרשאה לפרויקט שלך על ידי ביצוע הוראות אלה .
403 ממשקי API לניהול זרמים צריכים להתקשר רק על ידי חשבון שירות. הנה מידע נוסף על האופן שבו ניתן להתקשר לממשקי API של Google באמצעות חשבון שירות .
403 נקודת הקצה למסירה אינה שייכת לאף אחד מתחומי הפרויקט שלך. לכל פרויקט יש קבוצת דומיינים מורשים. אם נקודת הסיום שלך למשלוח (כלומר נקודת הסיום אליה אתה מצפה שיועברו אירועי RISC) אינה מתארחת באחד מהם, אנו דורשים שתוסיף את הדומיין של נקודת הקצה לערכה זו.
403 כדי להשתמש ב- API זה על הפרויקט שלך להיות מוגדר לפחות לקוח OAuth אחד. RISC פועל רק אם אתה בונה אפליקציה התומכת בכניסה של Google . חיבור זה דורש לקוח OAuth. אם לפרויקט שלך אין לקוחות OAuth, סביר להניח ש- RISC לא יהיה שימושי עבורך. למידע נוסף על השימוש של Google ב- OAuth עבור ממשקי ה- API שלנו .
403

סטטוס לא נתמך.

סטטוס לא חוקי.

אנו תומכים בשלב זה רק בסטטוסי הזרם " enabled " disabled ".
404

לפרויקט אין תצורת RISC.

לפרויקט אין תצורת RISC קיימת, אינו יכול לעדכן את הסטטוס.

התקשר ל https://risc.googleapis.com/v1beta/stream:update נקודת קצה כדי ליצור תצורת זרם חדשה.
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 .