Ochrona kont użytkowników za pomocą ochrony obejmującej wiele kont

Jeśli użytkownicy w Twojej aplikacji mogą logować się na swoje konta w Google, możesz zwiększyć bezpieczeństwo tych kont, odpowiadając na powiadomienia dotyczące zdarzeń związanych z bezpieczeństwem w ramach ochrony obejmującej wiele kont.

Powiadomienia informują o ważnych zmianach na kontach Google użytkowników, co często może mieć wpływ na bezpieczeństwo ich aplikacji. Jeśli na przykład konto Google użytkownika zostało przejęte, jego konto może zostać przejęte w ramach odzyskiwania konta e-mail lub logowania jednokrotnego.

Aby ograniczyć ryzyko związane z takimi zdarzeniami, Google wysyła obiekty usługi nazywane tokenami zabezpieczeń. Zawierają one bardzo mało informacji – tylko typ zdarzenia związanego z bezpieczeństwem i czas wystąpienia zdarzenia oraz identyfikator użytkownika, u którego wystąpił problem. Możesz ich jednak użyć do podjęcia odpowiednich działań. Jeśli na przykład doszło do przejęcia konta Google użytkownika, możesz tymczasowo wyłączyć dla niego funkcję Zaloguj się przez Google i uniemożliwić wysyłanie na jego adres e-mail odzyskiwania.

Ochrona wszystkich kont działa na podstawie standardu RISC opracowanego przez organizację OpenID Foundation.

Przegląd

Aby korzystać z ochrony obejmującej wiele kont w swojej aplikacji lub usłudze, musisz wykonać te czynności:

1. Skonfiguruj projekt w API Console.

2. Utwórz punkt końcowy odbiornika zdarzeń, do którego Google będzie wysyłać tokeny zdarzeń zabezpieczeń. Ten punkt końcowy odpowiada za weryfikację tokenów, które otrzymuje, a następnie odpowiadanie na zdarzenia związane z bezpieczeństwem w dowolnie wybrany sposób.

3. Zarejestruj punkt końcowy w Google, aby zacząć otrzymywać tokeny zdarzeń zabezpieczeń.

Warunek wstępny

Tokeny zdarzeń związanych z bezpieczeństwem otrzymują tylko użytkownicy Google, którzy przyznali Twojej usłudze dostęp do danych jej profili lub adresów e-mail. Aby uzyskać to uprawnienie, poproś o zakres profile lub email. Nowsze pakiety SDK Sign In with Google i starsze pakiety Sign-in Google wysyłają prośbę o domyślne zakresy, ale jeśli nie korzystasz z ustawień domyślnych lub uzyskujesz dostęp bezpośrednio do punktu końcowego OpenID Google, sprawdź, czy żądasz co najmniej jednego z tych zakresów.

Konfigurowanie projektu w API Console

Zanim zaczniesz otrzymywać tokeny zdarzeń zabezpieczeń, musisz utworzyć konto usługi i włączyć interfejs RISC API w projekcieAPI Console . Musisz używać w swojej aplikacji tego samegoAPI Console projektu, którego używasz do uzyskiwania dostępu do usług Google, takich jak Logowanie przez Google.

Aby utworzyć konto usługi:

1. Otwórz API Console Credentials page. Gdy pojawi się taka prośba, wybierz projektAPI Console, którego używasz w aplikacji do uzyskiwania dostępu do usług Google.

2. Kliknij Utwórz dane logowania > Konto usługi.

3. Utwórz nowe konto usługi z rolą administratora konfiguracji RISC (roles/riscconfigs.admin), postępując zgodnie z tymi instrukcjami.

4. Utwórz klucz dla nowo utworzonego konta usługi. Wybierz typ klucza JSON, a następnie kliknij Utwórz. Po utworzeniu klucza pobierzesz plik JSON zawierający dane logowania do konta usługi. Zachowaj ten plik w bezpiecznym miejscu, ale będzie też dostępny dla punktu końcowego odbiornika zdarzeń.

Na stronie „Dane logowania” w projekcie zwróć uwagę na identyfikatory klienta, których używasz do logowania się przez Google lub logowania starszego typu. Zwykle dla każdej obsługiwanej platformy masz identyfikator klienta. Te identyfikatory klienta będą potrzebne do weryfikacji tokenów zdarzeń zgodnie z opisem w następnej sekcji.

Aby włączyć interfejs RISC API:

1. Otwórz stronę interfejsu API RISC w:API Console. Upewnij się, że projekt, którego używasz do uzyskiwania dostępu do usług Google, jest nadal wybrany.

2. Zapoznaj się z warunkami RISC i upewnij się, że rozumiesz je.

   Jeśli włączasz interfejs API dla projektu należącego do organizacji, upewnij się, że masz uprawnienia do powiązania organizacji z warunkami RISC.

3. Kliknij Włącz tylko wtedy, gdy zgadzasz się na warunki RISC.

Tworzenie punktu końcowego odbiornika zdarzeń

Aby otrzymywać od Google powiadomienia o zdarzeniach związanych z bezpieczeństwem, musisz utworzyć punkt końcowy HTTPS, który obsługuje żądania HTTPS POST. Gdy zarejestrujesz ten punkt końcowy (patrz poniżej), Google zacznie publikować kryptograficznie ciągi znaków zwane tokenami zabezpieczeń i punkt końcowy. Tokeny zdarzeń zabezpieczeń są podpisanymi tokenami JWT, które zawierają informacje o pojedynczym zdarzeniu związanym z bezpieczeństwem.

W przypadku każdego tokena zdarzenia zabezpieczeń, który otrzymasz w punkcie końcowym, najpierw zweryfikuj i zdekoduj token, a następnie zajmij się zdarzeniem zabezpieczeń odpowiednim dla Twojej usługi. Zweryfikuj token zdarzenia przed dezaktywacją, by zapobiec złośliwym atakom hakerów. Tematy w tych sekcjach:

1. Zdekoduj i zweryfikuj token zdarzenia zabezpieczeń

Tokeny zdarzeń zabezpieczeń to specjalny rodzaj tokena JWT, dlatego możesz go dezaktywować i zweryfikować za pomocą dowolnej biblioteki JWT, np. wymienionej na stronie jwt.io. Niezależnie od używanej biblioteki kod weryfikacyjny tokena musi mieć postać:

1. Pobierz identyfikator wydawcy ochrony dla wielu kont (issuer) i identyfikator URI certyfikatu podpisywania klucza (jwks_uri) z dokumentu konfiguracji RISC Google, który znajdziesz pod adresem https://accounts.google.com/.well-known/risc-configuration.
2. Użyj wybranej biblioteki tokena JWT, aby uzyskać identyfikator klucza podpisywania z nagłówka tokena zdarzenia zabezpieczeń.
3. Z dokumentu certyfikatu klucza podpisywania Google uzyskaj klucz publiczny z identyfikatorem klucza otrzymanym w poprzednim kroku. Jeśli dokument nie zawiera klucza o identyfikatorze, którego szukasz, prawdopodobnie token zdarzenia zabezpieczeń jest nieprawidłowy, a punkt końcowy powinien zwracać błąd HTTP 400.
4. Korzystając z wybranej biblioteki JWT, sprawdź:
   • Token zdarzenia dotyczącego zabezpieczeń został podpisany przy użyciu klucza publicznego otrzymanego w poprzednim kroku.
   • Żądanie aud do tokena jest jednym z identyfikatorów klienta aplikacji.
   • Żądanie iss tokena odpowiada identyfikatorowi wydawcy uzyskanemu w dokumencie wykrywania RISC. Pamiętaj, że nie musisz weryfikować ważności tokena (exp), ponieważ tokeny zdarzeń związanych z bezpieczeństwem odzwierciedlają wydarzenia historyczne, dlatego nie wygasają.

Przykład:

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)

Jeśli token jest prawidłowy i zdekodowany, ustaw stan HTTP 202. Następnie zarządzaj zdarzeniem zabezpieczeń wskazanym przez token.

2. Obsługa zdarzeń związanych z bezpieczeństwem

Po zdekodowaniu token zdarzenia zabezpieczeń wygląda tak:

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

Roszczenia iss i aud wskazują wystawcę tokena (Google) oraz adresata, do którego token jest przypisany (Twoja usługa). Te roszczenia zostały zweryfikowane w poprzednim kroku.

Roszczenie jti to ciąg znaków identyfikujący pojedyncze zdarzenie dotyczące bezpieczeństwa, które jest unikalne dla strumienia. Możesz go użyć, aby śledzić, jakie zdarzenia związane z bezpieczeństwem otrzymały.

Deklaracja events zawiera informacje o zdarzeniu zabezpieczeń reprezentowanym przez token. To roszczenie odnosi się do mapowania typu identyfikatora zdarzenia na deklarację subject, która określa użytkownika, którego dotyczy to zdarzenie, oraz wszelkie dodatkowe informacje o dostępnym zdarzeniu.

Żądanie subject identyfikuje konkretnego użytkownika za pomocą unikalnego identyfikatora konta Google (sub). Identyfikator konta Google to ten sam identyfikator (sub) zawarty w tokenach identyfikatora JWT udostępnionych przez nowszą bibliotekę Zaloguj się przez Google (JavaScript, HTML), starszą bibliotekę Logowanie przez Google lub OpenID Connect. Gdy subject_type zawiera roszczenie id_token_claims, może też zawierać pole email z adresem e-mail użytkownika.

Skorzystaj z informacji podanych w deklaracji events, aby podjąć odpowiednie działanie dla określonego typu zdarzenia na koncie określonego użytkownika.

Identyfikatory tokenów OAuth

W przypadku zdarzeń OAuth dotyczących poszczególnych tokenów typ identyfikatora token token zawiera te pola:

• token_type: obsługiwana jest tylko wartość refresh_token.

• token_identifier_alg: możliwe wartości znajdziesz w tabeli poniżej.

• token: zapoznaj się z tabelą poniżej.

W przypadku integracji z tymi zdarzeniami sugerujemy indeksowanie tokenów na podstawie podanych wartości, aby zapewnić szybkie dopasowanie po otrzymaniu zdarzenia.

Obsługiwane typy zdarzeń

Ochrona wszystkich kont obsługuje te typy zdarzeń związanych z bezpieczeństwem:

Zduplikowane i pominięte zdarzenia

Funkcja ochrony wszystkich kont spróbuje ponownie przesłać zdarzenia, które ich zdaniem nie zostały dostarczone. Dlatego czasami możesz otrzymać to samo zdarzenie kilka razy. Jeśli może to powodować powtarzające się działania niewygodne dla użytkowników, spróbuj usunąć twierdzenie jti (jest to unikalny identyfikator zdarzenia). Dostępne są zewnętrzne narzędzia, takie jak Google Cloud Dataflow, które mogą ułatwić Ci usunięcie zbędnego przepływu danych.

Pamiętaj, że wydarzenia są dostarczane z ograniczoną liczbą ponownych prób, więc jeśli odbiornik będzie przez dłuższy czas niedostępny, możesz na stałe przegapić niektóre wydarzenia.

Rejestrowanie odbiornika

Aby zacząć otrzymywać zdarzenia związane z bezpieczeństwem, zarejestruj punkt końcowy odbiornika za pomocą interfejsu API RISC. Wywołaniom interfejsu RISC API musi towarzyszyć token autoryzacji.

Zdarzenia dotyczące bezpieczeństwa będą otrzymywać tylko dla użytkowników aplikacji, więc musisz skonfigurować ekran zgody OAuth w swoim projekcie GCP, wykonując czynności opisane poniżej.

1. Generowanie tokena autoryzacji

Aby wygenerować token autoryzacji dla interfejsu RISC API, utwórz token JWT z tymi roszczeniami:

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

Podpisz token JWT za pomocą klucza prywatnego konta usługi, który znajdziesz w pliku JSON pobranym podczas tworzenia klucza konta usługi.

Przykład:

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

Ten token autoryzacji może służyć do wykonywania wywołań interfejsu API RISC na godzinę. Po wygaśnięciu tokena wygeneruj nowy, aby kontynuować wywołania interfejsu RISC API.

2. Wywołaj interfejs API konfiguracji strumienia RISC

Po utworzeniu tokena autoryzacji możesz użyć interfejsu RISC API do skonfigurowania strumienia zdarzeń związanych z bezpieczeństwem projektu, w tym zarejestrowania punktu końcowego odbiornika.

Aby to zrobić, wyślij żądanie HTTPS POST do https://risc.googleapis.com/v1beta/stream:update, określając punkt końcowy odbiornika i interesujące Cię typy zdarzeń zabezpieczeń:

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

Przykład:

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

Jeśli żądanie zwróci HTTP 200, strumień zdarzeń został skonfigurowany, a punkt końcowy odbiornika powinien zacząć otrzymywać tokeny zabezpieczeń. W następnej sekcji opisujemy, jak możesz przetestować konfigurację strumienia i punkt końcowy, by sprawdzić, czy wszystko działa prawidłowo.

Pobieranie i aktualizowanie bieżącej konfiguracji strumienia

Jeśli w przyszłości zechcesz zmienić konfigurację strumienia, możesz to zrobić, autoryzując żądanie GET do strony https://risc.googleapis.com/v1beta/stream, aby pobrać bieżącą konfigurację strumienia, modyfikując treść odpowiedzi, a następnie przesyłając zmodyfikowaną konfigurację z powrotem do https://risc.googleapis.com/v1beta/stream:update w sposób opisany powyżej.

Zatrzymaj i wznów strumień wydarzenia

Jeśli chcesz zatrzymać strumień zdarzeń od Google, wyślij żądanie POST do https://risc.googleapis.com/v1beta/stream/status:update z użyciem { "status": "disabled" } w treści żądania. Gdy strumień jest dezaktywowany, Google nie wysyła zdarzeń do punktu końcowego ani nie buforuje zdarzeń zabezpieczeń, gdy występują. Aby ponownie włączyć strumień zdarzeń, wyślij żądanie { "status": "enabled" } do tego samego punktu końcowego.

3. Opcjonalnie: przetestuj konfigurację strumienia

Możesz sprawdzić, czy konfiguracja strumienia i punktu końcowego odbiornika działają prawidłowo, wysyłając token weryfikacyjny przez strumień zdarzeń. Ten token może zawierać unikalny ciąg znaków, którego możesz użyć do sprawdzenia, czy token został odebrany w punkcie końcowym.

Aby wysłać prośbę o token weryfikacyjny, wyślij żądanie POST do protokołu HTTPS do: https://risc.googleapis.com/v1beta/stream:verify. W treści żądania podaj ciąg identyfikujący:

{
  "state": "ANYTHING"
}

Przykład:

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

Jeśli żądanie się powiedzie, token weryfikacyjny zostanie wysłany do zarejestrowanego punktu końcowego. Jeśli na przykład punkty końcowe obsługują tokeny weryfikacyjne, wystarczy je zarejestrować, aby można było sprawdzić logi, czy token został odebrany.

Dokumentacja kodu błędu

Interfejs RISC API może zwrócić te błędy:

Zakresy tokenów dostępu

Jeśli zdecydujesz się na używanie tokenów dostępu do uwierzytelniania w interfejsie RISC API, poproś o to te zakresy:

Potrzebujesz pomocy?

Najpierw zapoznaj się z sekcją Informacje o kodach błędów. Jeśli nadal masz pytania, opublikuj je na stronie Stack Overflow z tagiem #SecEvents.