> ## Documentation Index
> Fetch the complete documentation index at: https://documentation.onesignal.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Kimlik doğrulama

> OneSignal'e gönderilen Harici Kullanıcı Kimliklerini, e-posta ve SMS aboneliklerini doğrulamak için sunucu tarafından oluşturulan JWT'ler gerektirerek kullanıcı kimliğine bürünmeyi önleyin.

## Genel Bakış

OneSignal, kullanıcı kimliğine bürünmeyi önlemeye yardımcı olmak için Kimlik Doğrulama adlı gelişmiş bir güvenlik özelliği sunar. Bu özellik, sunucunuzda güvenli bir şekilde oluşturulan JSON Web Token'ları - veya [JWT'ler](https://jwt.io/introduction)'i kullanır. Abonelik bilgilerini doğrulamak için bu token'lar uygulamanıza ve OneSignal'in API'sine iletilir.

Kimlik Doğrulamayı etkinleştirerek korunun:

* Kullanıcıları oturum açtırma
* E-posta abonelikleri ekleme
* SMS abonelikleri ekleme
* Kullanıcı kimliklerini değiştirme

<Warning>
  Kimlik Doğrulama şu anda beta aşamasındadır. Hesabınızda etkinleştirmek için `support@onesignal.com` ile iletişime geçin. Destek etkinleştirdikten sonra, bunu kontrol panelinizde etkinleştirirsiniz ([Adım 5](#enable-token-identity-verification-in-the-dashboard)'e bakın).
</Warning>

## Önkoşullar

* Yapılandırılmış push platformu olan mevcut bir OneSignal uygulaması.

* Desteklenen SDK'lardan biriyle entegre edilmiş bir mobil uygulama:

  * [OneSignal Android SDK 5.2.0+](https://github.com/OneSignal/OneSignal-Android-SDK/releases)
  * [OneSignal iOS SDK 5.3.0+](https://github.com/OneSignal/OneSignal-iOS-SDK/releases)

<Note>
  Wrapper SDK desteği (Flutter, React Native, Unity, vb.) yakında geliyor.
</Note>

## Kurulum

<Steps>
  <Step title="Yeni anahtarlar oluşturun">
    OneSignal hesabınızda oturum açın ve **Ayarlar > Anahtarlar ve Kimlikler > Kimlik Doğrulama**'ya gidin.

    <Frame caption="Kimlik Doğrulama yapılandırması">
      <img src="https://mintcdn.com/onesignal/Z6xkXGfmy814If53/images/docs/d6f1009-keys_and_ids.png?fit=max&auto=format&n=Z6xkXGfmy814If53&q=85&s=ffc30e4a1f08dcbe4e6a2e4935a7f5de" alt="Settings page showing Keys and IDs with Identity Verification section" width="2420" height="1614" data-path="images/docs/d6f1009-keys_and_ids.png" />
    </Frame>

    Yeni bir anahtar çifti oluşturmak için **Yeni Anahtarlar Oluştur**'a tıklayın.

    <Frame caption="Yeni anahtar çifti oluşturma">
      <img src="https://mintcdn.com/onesignal/56ctKxZSV4m5VEkn/images/docs/b24c1fd-Identity_Verification.png?fit=max&auto=format&n=56ctKxZSV4m5VEkn&q=85&s=73e56aa60fdef2dc8152bf929ebc1d52" alt="Generate New Keys button in the Identity Verification section" width="2350" height="686" data-path="images/docs/b24c1fd-Identity_Verification.png" />
    </Frame>

    PEM dosyasını indirin veya özel anahtarı kopyalayın, özel anahtarı güvenli bir şekilde sakladığınızdan emin olun.

    <Frame caption="Kimlik Doğrulama anahtar çifti">
      <img src="https://mintcdn.com/onesignal/56ctKxZSV4m5VEkn/images/docs/bc217af-id_keys.png?fit=max&auto=format&n=56ctKxZSV4m5VEkn&q=85&s=b8e99ccdb2f4aafd453063540148ca2e" alt="Identity Verification key pair with private key and PEM download" width="1128" height="966" data-path="images/docs/bc217af-id_keys.png" />
    </Frame>

    <Warning>
      Özel anahtarlarınızı her zaman anahtar yönetim sistemi gibi güvenli bir ortamda saklayın. Özel anahtarları istemci tarafı kodda, genel depolarda veya günlüklerde asla açığa çıkarmayın.
    </Warning>
  </Step>

  <Step title="Arka ucunuzda doğrulama JWT'si oluşturun">
    Kimlik doğrulama, son kullanıcıyı OneSignal'e oturum açtırmadan **önce** kimlik doğrulama sunucunuzla doğrulamanızı gerektirir. Son kullanıcı arka ucunuzla kimlik doğruladığında, token'ı oluşturun ve cihaza gönderilen kimlik doğrulama yanıtına dahil edin. Uygulamanız bir arka uç sunucusu çalıştırmıyorsa, kullanıcıları doğrulamak ve bu token'ları oluşturmak için hafif bir sunucu kurmayı düşünün.

    #### JWT yükü

    JWT aşağıdaki özelliklere sahip olabilir:

    <ParamField path="iss" required="true">
      OneSignal Uygulama Kimliğiniz
    </ParamField>

    <ParamField path="exp" required="true">
      Token'ın son kullanma tarihi.
    </ParamField>

    <ParamField path="identity" required="true">
      Kullanıcının takma adı.
    </ParamField>

    <ParamField path="subscriptions">
      Yalnızca bir kullanıcıya E-posta ve SMS abonelikleri eklerken gereklidir.
    </ParamField>

    #### JWT'yi imzalama

    JWT'yi ES256 algoritmasını kullanarak imzalayın. JWT'yi OneSignal'e gönderirken doğrulama sorunlarından kaçınmak için arka ucunuzun bu imzalama yöntemini kullanacak şekilde yapılandırıldığından emin olun. Bunu yapmak için bir [JWT Kütüphanesi](https://jwt.io/libraries) öneririz.

    [jsonwebtoken](https://www.npmjs.com/package/jsonwebtoken) kullanan örnek:

    <CodeGroup>
      ```typescript Node.js theme={null}
      import jwt from 'jsonwebtoken';

      const APP_ID = process.env['ONESIGNAL_APP_ID']
      const IDENTITY_VERIFICATION_SECRET = process.env['ONESIGNAL_IDENTITY_VERIFICATION_SECRET_KEY']

      // Generates JWT, potentially with subscription claims, for the user identified by the External ID
      function signOneSignalJWT(externalId, subscriptions) {
      return jwt.sign({
      iss: APP_ID,
      exp: Math.floor(Date.now() / 1000) + 3600, // 1-hour expiration
      identity: {
      'external_id': externalId,
      },
      subscriptions
      },
      IDENTITY_VERIFICATION_SECRET,
      { algorithm: 'ES256' });
      }

      // Pass this token to your mobile app to use with the `login` SDK method
      const onesignalJWT = signOneSignalJWT('EXTERNAL_ID');

      ```
    </CodeGroup>

    Özel anahtar, Kontrol Panelinden indirdiğimiz önceki adımın dosyasındadır.

    #### JWT'nizi doğrulayın

    SDK ile entegre etmeden önce, sunucunuzu başlatarak ve uç noktayı çağırarak JWT'nizin doğru oluşturulduğunu doğrulayın:

    <CodeGroup>
      ```typescript Node.js theme={null}
        node server.js
      ```
    </CodeGroup>

    <CodeGroup>
      ```bash cURL theme={null}
        curl http://localhost:3000/generate-jwt/your-external-id
      ```
    </CodeGroup>

    Aşağıdaki gibi bir yanıt almalısınız:

    ```json theme={null}
    {
      "jwt": "eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9..."
    }
    ```

    JWT değerini [jwt.io](https://jwt.io) adresine yapıştırın ve kodu çözülmüş yükün aşağıdaki parametreleri içerdiğini onaylayın:

    ```json theme={null}
    {
      "iss": "your-onesignal-app-id",
      "exp": 1234567890,
      "identity": {
        "external_id": "your-external-id"
      }
    }
    ```

    Bir sonraki adıma geçmeden önce aşağıdakileri onaylayın:

    * `iss` değerinin **Settings > Keys & IDs**'deki OneSignal Uygulama Kimliğinizle eşleştiğini
    * `identity.external_id` değerinin mevcut olduğunu ve `OneSignal.login()`'e ileteceğiniz değerle eşleştiğini
    * `exp` değerinin gelecekteki bir zaman damgası olduğunu — süresi dolmuş bir token OneSignal tarafından reddedilecektir

    #### Abonelikleri dahil etme

    İdeal olarak, e-posta veya telefon numarası gibi abonelik ayrıntıları, bir kullanıcıyı oturum açtırırken JWT yüküne dahil edilir. Bu ayrıntılar önceden mevcut değilse, doğrulama sunucunuz abonelik bilgileri kullanılabilir hale geldikçe token'ları dinamik olarak oluşturmak için bir uç nokta sağlamalıdır.

    Örnek: Abonelik eklemek için JWT oluşturma

    <CodeGroup>
      ```typescript Node.js theme={null}
      const subscriptions = [
        {
            "type": "Email",
            "token": "[email protected]"
        },
        {
            "type": "SMS",
            "token": "+12345678"
        }
      ]
      const onesignalJWT = signOneSignalJWT('EXTERNAL_ID', subscriptions)
      ```
    </CodeGroup>
  </Step>

  <Step title="`login` yöntemine JWT'yi iletin">
    Arka ucunuz JWT'yi oluşturduktan sonra, bununla `login` yöntemini çağırın. Bu token, e-posta veya SMS aboneliği ekleme gibi herhangi bir değişiklik yapılmadan önce kullanıcının kimliğinin doğrulanmasını sağlar.

    Oturum açma örneği:

    <CodeGroup>
      ```java java theme={null}
      String externalId = "YOUR_EXTERNAL_ID";
      String onesignalJWT = "YOUR_JWT_TOKEN";

      OneSignal.login(externalId, onesignalJWT);
      ```

      ```kotlin kotlin theme={null}
      val externalId = "YOUR_EXTERNAL_ID"
      val onesignalJWT = "YOUR_JWT_TOKEN"

      OneSignal.login(externalId, onesignalJWT)
      ```

      ```swift Swift theme={null}
      let externalId = "YOUR_EXTERNAL_ID"
      let onesignalJWT = "YOUR_JWT_TOKEN"

      OneSignal.login(externalId: externalId, token: onesignalJWT)
      ```

      ```c objective-c theme={null}
      NSString* externalId = @"YOUR_EXTERNAL_ID";
      NSString* onesignalJWT = @"YOUR_JWT_TOKEN";

      [OneSignal login:externalId withToken:onesignalJWT];
      ```
    </CodeGroup>
  </Step>

  <Step title="Handle JWT lifecycle events">
    You’ll need to implement a dedicated endpoint on your backend to handle scenarios like token invalidation. This endpoint should provide a refreshed JWT when OneSignal requests an update.

    Example of handling token invalidation and refreshing the JWT:

    <CodeGroup>
      ```java java theme={null}
      OneSignal.addUserJwtInvalidatedListener(event -> {
        // Get the expired user's External ID
        String externalId = event.getExternalId();

        // Fetch a new JWT from your backend for the user
        String onesignalJWT = "yourUpdatedToken";

        // Provide the new JWT to the SDK
        OneSignal.updateUserJwt(externalId, onesignalJWT);
      });
      ```

      ```kotlin kotlin theme={null}
      OneSignal.addUserJwtInvalidatedListener(
         object : IUserJwtInvalidatedListener {
             override fun onUserJwtInvalidated(event: UserJwtInvalidatedEvent) {
               val externalId = event.externalId
               val onesignalJWT = ""
               updateUserJwt(externalId, onesignalJWT)
             }
         },
      )
      ```

      ```swift Swift theme={null}
      class AppDelegate: UIResponder, UIApplicationDelegate, OSUserJwtInvalidatedListener {
        func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil) -> Bool {
          // Set self to listen for JWT invalidated events
          OneSignal.addUserJwtInvalidatedListener(self)

          // Remove the JWT listener as needed by calling:
          // `OneSignal.removeUserJwtInvalidatedListener(self)`
        }

        // Required to conform to `OSUserJwtInvalidatedListener` protocol
        func onUserJwtInvalidated(event: OneSignalUser.OSUserJwtInvalidatedEvent) {
          // Get the expired user's External ID
          let externalId = event.externalId

          // Fetch a new JWT from your backend for the user
          let onesignalJWT = "yourUpdatedToken"

          // Provide the new JWT to the SDK
          OneSignal.updateUserJwt(externalId: externalId, token: onesignalJWT)
        }
      }
      ```

      ```c objective-c theme={null}
      @interface MyListener: NSObject<OSUserJwtInvalidatedListener>
      @end

      @implementation MyListener
      - (void)onUserJwtInvalidatedWithEvent:(OSUserJwtInvalidatedEvent * _Nonnull)event {
        // Get the expired user's External ID
        NSString *externalId = event.externalId;

        // Fetch a new JWT from your backend for the user
        NSString *onesignalJWT = @"yourUpdatedToken";

        // Provide the new JWT to the SDK
      	[OneSignal updateUserJwt:externalId withToken:onesignalJWT];
      }

      // Add or remove your User Jwt Invalidated Listener
      [OneSignal addUserJwtInvalidatedListener:myListener];
      [OneSignal removeUserJwtInvalidatedListener:myListener];
      ```
    </CodeGroup>

    This ensures that when a user’s JWT is invalidated, a new one can be fetched from your backend and passed to OneSignal. You can also use this function to generate a token with an email and phone number, allowing you to manage email and SMS subscriptions if the token created during authentication does not contain them.
  </Step>

  <Step title="Enable token identity verification in the dashboard">
    From **Settings > Keys & IDs**, toggle **Token Identity Verification** to enable.

    <Frame caption="Enabling Token Identity Verification">
      <img src="https://mintcdn.com/onesignal/YOTSrtBSoqdrJ37A/images/docs/4887367-identity_verification_enabled.png?fit=max&auto=format&n=YOTSrtBSoqdrJ37A&q=85&s=26d06ca0a008e841d5206093bfbf2a8c" alt="Token Identity Verification toggle enabled in dashboard settings" width="2350" height="686" data-path="images/docs/4887367-identity_verification_enabled.png" />
    </Frame>

    Etkinleştirildikten sonra, uygulamanızın abonelik özgünlüğünü doğrulamak için OneSignal JWT'lerini göndermesi gerekir. Ek olarak, uygulamanızın kimlik doğrulama token sunucunuz tarafından oluşturulan bir JWT kullanarak `login` yöntemini çağırması gerekir.
  </Step>
</Steps>

## Abonelik ekleme

Mobil uygulamanızdan abonelik eklemek için ekstra adımlar atmanıza gerek yoktur; login yöntemini çağırmak bunu sizin için otomatik olarak halleder.

<Tabs>
  <Tab title="E-posta ekleyin">
    <CodeGroup>
      ```java java theme={null}
      OneSignal.getUser().addEmail(emailAddress);
      ```

      ```kotlin kotlin theme={null}
      OneSignal.getUser().addEmail(emailAddress)
      ```

      ```swift Swift theme={null}
      // If you have not already included it in your JWT token, update the JWT with the email
      let onesignalJWT = "newTokenThatContainsTheEmailToAdd"
      OneSignal.updateUserJwt(externalId: externalId, token: onesignalJWT)

      // Add the email
      OneSignal.User.addEmail(emailAddress)
      ```

      ```c objective-c theme={null}
      // If you have not already included it in your JWT token, update the JWT with the email
      NSString *onesignalJWT = @"newTokenThatContainsTheEmailToAdd";
      [OneSignal updateUserJwt:externalId withToken:onesignalJWT];

      // Add the email
      [OneSignal.User addEmail:emailAddress];
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Telefon numarası ekleyin">
    <CodeGroup>
      ```java java theme={null}
      OneSignal.getUser().addSms(smsNumber);
      ```

      ```kotlin kotlin theme={null}
      OneSignal.getUser().addSms(smsNumber)
      ```

      ```swift Swift theme={null}
      // If you have not already included it in your JWT token, update the JWT with the sms
      let onesignalJWT = "newTokenThatContainsTheSmsToAdd"
      OneSignal.updateUserJwt(externalId: externalId, token: onesignalJWT)

      // Add the sms number
      OneSignal.User.addSms(smsNumber)
      ```

      ```c objective-c theme={null}
      // If you have not already included it in your JWT token, update the JWT with the sms
      NSString *onesignalJWT = @"newTokenThatContainsTheSmsToAdd";
      [OneSignal updateUserJwt:externalId withToken:onesignalJWT];

      // Add the sms number
      [OneSignal.User addSms:smsNumber];
      ```
    </CodeGroup>
  </Tab>
</Tabs>

***

## REST API

Token Kimlik Doğrulama etkinleştirildiğinde, aşağıdaki API'lere yapılan tüm istekler başlıklarda bir bearer token olarak sunucu tarafından oluşturulan bir JWT içermelidir, örneğin, `Authorization: Bearer <JWT>`.

* [Create user](/reference/create-user)
* [View user](/reference/view-user)
* [Update user](/reference/update-user)
* [Delete user](/reference/delete-user)
* [View user identity](/reference/fetch-aliases)
* [Create alias](/reference/create-alias)
* [Delete alias](/reference/delete-alias)
* [Create subscription](/reference/create-subscription)
* [Update subscription](/reference/update-subscription)

***

## SSS

### Kimlik doğrulama gerekli midir?

Hayır, ancak şiddetle tavsiye edilir. Olmadan, bir kullanıcının Harici Kimliğini bilen herhangi bir istemci o kullanıcının kimliğine bürünebilir ve aboneliklerini veya verilerini değiştirebilir.

### Oturum sırasında JWT süresi dolarsa ne olur?

SDK bir JWT geçersizleştirme olayı tetikler. Arka ucunuzdan yenilenmiş bir token almak ve `updateUserJwt`'ye iletmek için `addUserJwtInvalidatedListener`'ı uygulayın ([JWT yaşam döngüsü olaylarını işleme](#handle-jwt-lifecycle-events) bölümüne bakın).

### Hangi SDK'lar kimlik doğrulamayı destekler?

Şu anda yerel Android SDK (5.2.0+) ve iOS SDK (5.3.0+). Wrapper SDK desteği (Flutter, React Native, Unity, vb.) yakında geliyor.

### REST API için kimlik doğrulama gerekli midir?

Token Kimlik Doğrulama etkinleştirildiğinde, [desteklenen API'lere](#rest-api) yapılan tüm istekler `Authorization` başlığında bearer token olarak sunucu tarafından oluşturulan bir JWT içermelidir. JWT, SDK kullanımıyla aynı şekilde oluşturulur.

### JWT hangi algoritmayı kullanır?

Kimlik Doğrulama, **ES256** algoritmasıyla (P-256 ve SHA-256 kullanan ECDSA) imzalanmış JWT'ler gerektirir. Diğer algoritmalar reddedilecektir.

***