## Giriş [Logto](https://logto.io/) geliştiricilerimize ve iş gruplarımıza kapsamlı bir Müşteri Kimlik ve Erişim Yönetimi (CIAM) çözümü sağlar. Farklı platformlar ve uygulama çerçeveleri için çok sayıda kullanıma hazır SDK'lar sunuyoruz. Logto bulut hizmetimizle birleştiğinde, uygulamanız için çok yüksek güvenlikli bir kullanıcı yetkilendirme akışını birkaç dakikada kolayca oluşturabilirsiniz. Bir geliştirici topluluğundan doğan bir şirket olan Logto, topluluk katılımını benimser ve değer verir. Resmi olarak geliştirilen Logto SDK'larına ek olarak, topluluktan geliştiricilerin, çeşitli platformlar ve çerçeveler için eşsiz ihtiyaçları karşılayacak daha çeşitli ve kullanıcı dostu SDK'lar oluşturarak uzmanlıklarını katkıda bulunmalarını sürekli olarak teşvik eder ve sıcak bir şekilde karşılar. Bu makalede, bir OIDC standart auth SDK'sını adım adım nasıl uygulayacağımızı kısaca göstereceğiz. Logto'da uygulamanızı oluşturun ## Bağlam OpenID Connect (OIDC) akışı, OAuth 2.0 çerçevesi üzerine inşa edilen bir kimlik doğrulama protokolüdür ve kimlik doğrulama ve tek oturum açma yetenekleri sağlar. Kullanıcıların bir uygulamayla kimliklerini doğrulamalarını ve herhangi bir özel kaynağa güvenli bir şekilde daha fazla erişim için yetkili olmalarını sağlar. Daha fazla detay için lütfen OIDC özelliklerine başvurun. ### İş Akışı Standart bir yetkilendirme-kodu akışı, aşağıdaki adımları içerir: ```mermaid sequenceDiagram actor user as Bitiş Kullanıcısı participant app as İstemci Uygulaması participant server as Yetkilendirme Sunucus participant resource as Özel Kaynaklar user ->> app: anonim ziyaretçi girişi app ->> server: kimlik doğrulama isteği gönder server -->> user: kullanıcı giriş sayfasına yönlendir user ->> server: kimlik bilgileriyle giriş yap server -->> app: yetkilendirme_kodu ile istemci uygulamasına geri yönlendir app ->> server: yetkilendirme_kodu ile token değişim isteği server ->> app: id_token'u, access_token ve refresh_token yetkilendir app -->> user: kimlik doğrulanmış app ->> resource: access_token ile birlikte özel api isteği resource --> server: imza anahtarını senkronize et resource -->> resource: token doğrulaması resource ->> app: 200 OK ``` #### Kimlik Doğrulama Akışı 1. **Kullanıcı oturum açma isteğini başlatır:** Anonim bir kullanıcı, kamuya açık bir girişten uygulamanıza gelir. Kimlik doğrulaması için girişimde bulunur ve belki de üçüncü taraf bir uygulama veya hizmette korunan bir kaynağa daha fazla istek yapar. 2. **Kullanıcı kimlik doğrulaması:** İstemci uygulaması bir kimlik doğrulama URI'si oluşturur ve kullanıcısını giriş sayfasına yönlendiren yetkilendirme sunucusuna bir istek gönderir. Kullanıcı, geniş bir giriş yöntemleri yelpazesini kullanarak giriş sayfasıyla et interacted girer ve yetkilendirme sunucusu tarafından kimlik doğrulamalarını alır. 3. **Giriş geri çağrısını işleme:** Başarılı bir kimlik doğrulamasının ardından, kullanıcı bir yetkili `authorization_code` ile uygulamanıza geri yönlendirilecektir . Bu `authorization_code`, authentication durumu ve istenen yetkilendirme verisi ile ilişkilendirilen tüm ilgili izinleri içerir. 4. **Token değişimi**: Yukarıdaki redirect adresinden elde edilen `authorization_code` kullanılarak token değişimi talep ediliyor. Buna karşılık olarak grilenler: - `id_token`: Doğrulanmış kullanıcı hakkında kimlik bilgilerini içeren dijital olarak imzalanmış bir JWT. - `access_token`: Kullanıcının temel bilgilerine erişim sağlamak için kullanılabilen saydam bir `access_token`. - `refresh_token`: Bir `access_token` alışverişi için kullanıcının sürekli değişim için izin veren kimlik bilgileri token. #### Yetkilendirme Akışı 1. **Kullanıcı bilgilerine erişim**: Daha fazla kullanıcı bilgisi elde etmek için, uygulama ilk token takas akışından elde edilen saydam `access_token` kullanarak UserInfo uç noktasına ek istekler yapabilir. Bu, kullanıcının e-posta adresi veya profil resmi gibi kullanıcı hakkında daha fazla ayrıntıyı almayı sağlar. 2. **Korumalı kaynağa erişim yetkisi**: Gerekirse, uygulama, `refresh_token` ile birlikte `resource` ve `scope` parametrelerini kullanarak token değişim uç noktasına ek istekler yapabilir, buradan kullanıcıya hedef kaynağa erişim için özel bir `access_token` alabilir. Bu işlem, korumalı kaynağa erişim için gerekli yetkilendirme bilgilerini içeren bir JWT formatlanmış `access_token`ın verilmesi şeklinde sonuçlanır. ## Uygulama Kendi istemci uygulamanız için basit bir SDK oluşturma sürecini göstermek için @logto/client JavaScript SDK'mızdaki bazı tasarım stratejilerini izleyeceğiz. Lütfen detaylı kod yapısının, üzerinde çalıştığınız istemci çerçevesine bağlı olarak farklı olabileceğini aklınızda bulundurun. Kendi SDK projeniz için örnek olarak herhangi bir Logto resmi SDK'yı seçmekten çekinmeyin. ### Önizleme ```ts class LogtoClient { protected readonly logtoConfig: LogtoConfig; protected readonly storage: Storage; protected oidcConfig: OidcConfig; protected accessTokenMap: Map constructor(logtoConfig: LogtoConfig) {} get async idToken(){} private async getOidcConfig(){} private async getJwksFunction() {} private async verifyIdToken() {} private async saveTokens() {} private async setSignInSession() {} private async getSignInSession() {} private async getAccessTokenByRefreshToken() {} async signIn(redirectUri: string) {} async handlerSignInCallback (callbackUri: string) {} async getUserInfo() {} async getAccessToken(resource?: string, scopes?: string[]) {} } ``` ### Constructor Constructor, giriş olarak [logtoConfig](#logto-config)'u almalıdır. Bu, bu SDK aracılığıyla auth bağlantısını kurmak için ihtiyaç duyacağınız tüm gerekli yapılandırmaları sağlar. SDK için kullandığınız platform veya çerçeveye bağlı olarak, bir persistent yerel depolama örneğini constructor'a geçirebilirsiniz. Bu depolama örneği, tüm yetkilendirme ile ilgili token'lar ve sırları depolamak için kullanılacaktır. ```ts class LogtoClient { constructor(logtoConfig: LogtoConfig, storage: Storage) {} } ``` ### Kullanıcı kimlik doğrulamasını başlat Bir kimlik doğrulama istek URL'si oluşturmadan önce, güvenli bir süreci garanti etmek için birkaç hazırlık adımını tamamlamak gereklidir. #### Yetkilendirme sunucusundan OIDC yapılandırmalarını alın Yetkilendirme sunucusunun keşif uç noktasından OIDC yapılandırmalarını almak için bir private yöntem `getOidcConfigs` tanımlayın. OIDC yapılandırmaları yanıtı, istemci'nin yetkilendirme sunucusuyla et interacted girerek sunucu'nun uç nokta konumlarını ve sunucu'nun yeteneklerini içeren tüm metadataya sahip olur. (Daha fazla detay için, lütfen [OAuth OAuth Yetkilendirme Sunucusu Metadata Özelliklerine](https://datatracker.ietf.org/doc/html/rfc8414) bakın.) ```ts const discoveryPath = "/oidc/.well-known/openid-configuration"; private async getOidcConfigs() { if (this.oidcConfig) { return this.oidcConfig; } const response = await fetch(`${this.logtoConfig.endpoint}${discoveryPath}`) this.oidcConfig = await response.json(); return this.oidcConfig; } ``` #### PKCE Generator Bir [PKCE(Proof Key for Code Exchange)](https://datatracker.ietf.org/doc/html/rfc7636) doğrulama akışı, tüm kamu istemci yetkilendirme kodu değişim akışları için esastır. Yetkilendirme_kodunun interception saldırısının riskini azaltır. Böylece tüm kamu istemci uygulamaları (ör. yerli uygulama ve SPA) yetkilendirme isteklerinde bir `code_challenge` ve `code_verifier` gereklidir. Uygulama yöntemleri dillerinize ve kullandığınız çerçevelere bağlı olarak değişebilir. Lütfen daha detaylı tanımlar için [code_challenge](https://datatracker.ietf.org/doc/html/rfc7636#section-4.2) ve [code_verifier](https://datatracker.ietf.org/doc/html/rfc7636#section-4.1) özelliklerine başvurun. Confidential bir client üzerinde çalışıyorsanız veya server rendered web uygulamaları gibi express veya nextjs üzerinde çalışıyorsanız, doğrudan bir sonraki adıma geçin. PKCE ve kamu client ile confidential client arasındaki fark hakkında daha fazla bilgi için [OAuth güvenlik özeti]'mize (https://blog.logto.io/oauth-security-recap) bakınız. ```ts class PKCE { readonly codeVerifier: string; readonly codeChallenge: string; constructor() { this.codeVerifier = this.generateCodeVerifier(); this.codeChallenge = this.generateCodeChallenge(this.codeVerifier); } /** * Generates code verifier * * @link [Client Creates a Code Verifier](https://datatracker.ietf.org/doc/html/rfc7636#section-4.1) */ private generateCodeVerifier() { return generateRandomString(); } /** * Calculates the S256 PKCE code challenge for an arbitrary code verifier and encodes it in url safe base64 * * @param {String} codeVerifier Code verifier to calculate the S256 code challenge for * @link [Client Creates the Code Challenge](https://datatracker.ietf.org/doc/html/rfc7636#section-4.2) */ private async generateCodeChallenge(codeVerifier: string) { const encodedCodeVerifier = new TextEncoder().encode(codeVerifier); const codeChallenge = new Uint8Array( await crypto.subtle.digest('SHA-256', encodedCodeVerifier) ); } } ``` #### State parametresi oluştur Yetkilendirme akışında, [state parametresi](https://blog.logto.io/oauth-security-recap/#state) istemci tarafından gönderilen yetkilendirme isteğine dahil edilen rastgele oluşturulmuş bir değerdir. Bu, cross-site request forgery (CSRF) saldırılarını önlemek amacıyla bir güvenlik önlemi olarak hareket eder. ```ts const state = generateRandomString(); ``` #### Ara session bilgisini sakla Kullanıcının kimlik doğrulandıktan ve client tarafına geri yönlendirildikten sonraki doğrulama amacıyla depolanması gereken birkaç parametre vardır. Bu ara parametreleri depolamak için bir yöntem uygulayacağız. ```ts protected async setSignInSession (data: { codeVerifier: string; redirectUri: string; state: string; }) { await this.storage.setItem('signInSession', data); } ``` #### Sign-in Yukarıda uygulanan her şeyi paketleyelim, bir kullanıcı oturum açma URL'si oluşturan ve kullanıcıyı kimlik doğrulamak için yetkilendirme sunucusuna yönlendiren bir yöntem tanımlayalım. ```ts async signIn(redirectUri: string) { const { appId, resources, scopes } = this.logtoConfig; const { authorizationEndpoint } = await this.getOidcConfig(); // Sadece public client uygulamaları için const pkce = new PKCE(); const state = generateRandomString(); const queryParameters = new URLSearchParams({ client_id: appId, redirect_uri: redirectUri, code_challenge: pkce.codeChallenge, code_challenge_method: 'S256', state, response_type: 'code', prompt: 'consent', scopes: [...reservedScopes, scopes], }); // Varsa tüm kaynak belirticilerini ekleyin for (const resource of resources ?? []) { urlSearchParameters.append('resource', resource); } const signInUrl = new URL(`${authorizationEndpoint}?${urlSearchParameters.toString()}`); await this.setSignInSession({ redirectUri, state, codeVerifier: pkce.codeVerifier }); navigate(signInUrl); } ``` ### Kullanıcı oturum açma geri çağrısını işleme Önceki bölümde, kullanıcı kimlik doğrulaması için bir URL içeren bir sign-in yöntemi oluşturduk. Bu URL, bir client uygulamasından kimlik doğrulama akışını başlatmak için gereken tüm gerekli parametreleri içerir. Kullanıcıyı autenticasyon için yetkilendirme sunucusunun giriş sayfasına yönlendirir. Başarılı bir sign-in'in ardından, kullanıcı üstte sağlanan redirect_uri konumuna yeniden yönlendirilir. Gerekli tüm parametreler, aşağıdaki token değişim akışlarını tamamlamak için redirect_uri'de taşınır. #### Geri çağrı URL'sini çıkar ve doğrula Bu doğrulama adımı, her tür sahte yetkilendirme callback saldırısını önlemek için son derece önemlidir. Callback URL **MUTLAKA** dikkatlice doğrulanmalıdır ve ardından yetkilendirme sunucusuna daha fazla kod değişim talebi gönderilmelidir. Öncelikle, uygulama depolamasından sakladığımız signInSession verilerini almamız gerekiyor. ```ts protected async getSignInSession () { session = await this.storage.getItem('signInSession', data); if (!session) { throw Error('Session not found'); } } ``` Daha sonra token değişim isteği göndermeden önce callback URL’nin parametrelerinin doğrulanmasını yapın. - Daha önce sakladığımız `redirectUri`'yi kullanarak `callbackUri`'nin yetkilendirme sunucusuna gönderdiğimizle aynı olup olmadığını doğrulayın. - Daha önce sakladığımız `state`'i kullanarak geri dönen `state`'in yetkilendirme sunucusuna gönderdiğimizle aynı olup olmadığını doğrulayın. - Yetkilendirme sunucusu tarafından herhangi bir hatanın dönüp dönmediğini kontrol edin - Geri dönen `authorization_code`'un varlığını kontrol edin ```ts verifyAndParseCodeFromCallbackUri(callbackUri: string, redirectUri: string, state: string) { const url = new URL(callbackUri) const parameters = url.searchParams; if (!callbackUri.startWith(redirectUri)) { throw new Error('redirect_uri_mismatched') } // Check the error message. // If the authentication fails, the user will be redirected back with error parameters attached const error = parameters.get('error'); const errorDescription = parameters.get('error_description'); if (error || errorDescription) { throw new Error(`${error}:${errorDescription}`) } // State verification const callbackState = parameter.get('state'); if (callbackState !== state) { throw new Error('state_mismatch'); } // Extract authorization code const code = parameters.get('code'); if (!code) { throw new Error('authorization_code_not_found') } return code; } ``` #### Kod değişim talebini gönder Kullanıcı kimlik doğrulama akışının son adımı olarak, döndürülen `authorization_code`'u kullanarak bir token değişim talebi gönderip gerekli yetkilendirme token'larını elde edeceğiz. İstek parametrelerinin tanımlamaları hakkında daha fazla detay için, lütfen [token değişim özelliklerine](https://datatracker.ietf.org/doc/html/rfc8693#section-2) başvurun. - code: callback URI'den aldığımız `authorization_code` - clientId: uygulama ID - redirectUri: Kullanıcı için oturum açma URL'si oluştururken kullanılan aynı değer. - codeVerifier: PKCE kod doğrulayıcı. redirectUri'ye benzer bir şekilde, yetkilendirme sunucusu bu değeri, gelen token değişim isteğinin doğrulanmasını sağlamak için daha önce gönderdiğimiz değerle karşılaştırır. ```ts const getTokenByAuthorizationCode = async (payload: { code: string; clientId: string; tokenEndpoint: string; redirectUri: string; codeVerifier: string; }) => { const parameters = new URLSearchParams({ client_id: payload.clientId, code: payload.code, code_verifier: payload.codeVerifier, redirect_uri: payload.redirectUri, grant_type: 'authorization_code', }); return fetch(tokenEndpoint, { method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded' } body: parameters, }); } ``` #### Kullanıcı oturum açma geri çağrısını işleme Elimizde olduğu her şeyi toplayalım. signInCallback işleme yöntemini oluşturalım: ```ts private async saveTokens({refreshToken, idToken, accessToken}) { this.storage.setItem('refreshToken', refreshToken); this.storage.setItem('idToken', idToken); // resource indicator specification olmadan saydam erişim token this.accessTokenMap.setItem('', accessToken) } async handleSignInCallback(callbackUri: string){ const signInSession = await this.getSignInSession(); if (!signInSession) { throw new Error('sign_in_session.not_found'); } const { redirectUri, state, codeVerifier } = signInSession; const code = verifyAndParseCodeFromCallbackUri(callbackUri, redirectUri, state); const { appId } = this.logtoConfig; const { tokenEndpoint } = await this.getOidcConfig(); const response = await getTokenByAuthorizationCode({ code, clientId: appId, tokenEndpoint, redirectUri, codeVerifier, }); await this.saveTokens(response); } ``` Sonuç olarak, token değişim talebi aşağıdaki token'ları dönecektir: - `id_token`: OIDC idToken, doğrulanmış kullanıcı hakkında kimlik bilgilerini içeren bir JSON Web Token (JWT). id_token aynı zamanda kullanıcıların kimlik doğrulama durumunun Tek Gerçek Kaynağı (SSOT) olarak kullanılabilir. - `access_token`: Yetkilendirme sunucusu tarafından döndürülen varsayılan yetkilendirme kodu. kullanıcı bilgi uç noktasını çağırmak ve kimlik doğrulanmış kullanıcı bilgilerini almak için kullanılabilir. - `refresh_token`: (offline_access scope yetkilendirme isteğinde mevcutsa): Bu refresh token, kullanıcının yeniden kimlik doğrulaması yapmasını gerektirmeksizin kullanıcı kimlik doğrulama sürecinden daha uzun süre erişebilmek için yeni bir access token elde etmesine izin verir. - `expires_in`: Access token'ın süresi dolmadan önce geçerli olan saniye cinsi zaman süreci. ### ID token doğrulaması `id_token`'ı doğrulamak ve claims'i çıkarmak, kimlik doğrulama sürecindeki token'ın otantisite ve bütünlüğünü sağlamak için önemli bir adımdır. İşte `idToken`'ı doğrulamak için yer alan ana adımlar: - İmza Doğrulama: `id_token`, yetkilendirme sunucusu tarafından özel anahtarıyla dijital olarak imzalandı. İstemci uygulaması, yetkilendirme sunucusunun genel anahtarı ile imzayı doğrulamalıdır. Bu, token'ın değiştirilmediğini ve gerçek yetkilendirme sunucusu tarafından düzenlendiğini garanti eder. - Issuer Doğrulaması**: **`id_token`'daki "iss" (publisher) claim'i beklenen değer ile eşleşiyor, bu da token'ın doğru yetkilendirme sunucusu tarafından düzenlendiğini gösterir. - Audience Doğrulaması: `id_token`'daki "aud" (audience) claim'in istemci uygulamasının client ID'si ile eşleştiğini kontrol edin, bu token'ın istemci için niyetlenildiğini garanti eder. - Süre Kontrolü:`id_token`'da bulunan"iat" (issued at) claim’in geçerli zamanın üzerinden geçip geçmediğini kontrol edin ki bu token'ın hala geçerli olduğunu garanti eder. Ağ işlem maliyetlerine sahip olunduğundan iat claim'i doğrularken bir çıktı süresi toleransı belirlememiz gerekiyor. Dönen id_token, standart bir JavaScript Web Token (JWT)'dir. Kullandığınız çerçeveye bağlı olarak, token'i çözme ve doğrulamada yardımcı olacak bir dizi uygun JWT token doğrulama eklentisi bulabilirsiniz. Bu örnekte, token doğrulama ve çözme işlemini kolaylaştırmak için JavaScript SDK'mızda [jose](https://www.npmjs.com/package/jose) kullanacağız. ```sh npm install jose ``` ```ts import {createRemoteJWKSet, jwtVerify} from 'jose'; private async getJwksFunction() { const { jwksUri } = await this.getOidcConfig(); return createRemoteJWKSet(new URL(jwksUri))(); } private async verifyIdToken( idToken: string, clientId: string, issuer: string, ) { const jwks = await this.getJwksFunction(); const result = await jwtVerify(idToken, jwks, { audience: clientId, issuer }); if (Math.abs((result.payload.iat ?? 0) - Date.now() / 1000) > issuedAtTimeTolerance) { throw new Error('id_token.invalid_iat'); } return result; }; ``` ### Kullanıcı bilgilerini al Başarılı bir kullanıcı kimlik doğrulamasının ardından, yetkilendirme sunucusu tarafından düzenlenen OIDC `id_token`'dan temel kullanıcı bilgileri alınabilir. Ancak, performans kaygıları nedeniyle, JWT token'ın içeriği sınırlıdır. Daha ayrıntılı kullanıcı profili bilgilerini elde etmek için, OIDC uyumlu yetkilendirme sunucuları, belirli kullanıcı profili kapsamlarını talep ederek ek kullanıcı profili verilerini almanızı sağlayan bir user info uç noktası sunar. Bir token değişim uç noktasını belirli bir API kaynağını belirtmeden çağırırken, yetkilendirme sunucusu varsayılan olarak şeffaf bir tür `access_token` çıkarır. Bu `access_token`, temel kullanıcı profil bilgilerini almayı sağlayan user info uç noktasına erişmek için kullanılabilir. ```ts async getUserInfo() { const { userinfoEndpoint } = await this.getOidcConfig(); const accessToken = await this.getAccessToken(); return fetch(userinfoEndpoint, { headers: { Authorization: `Bearer ${accessToken}` } }); } ``` ### Korumalı kaynak yetkilendirmesi için erişim tokenı al Çoğu durumda, bir istemci uygulaması sadece kullanıcı kimlik doğrulamasına ihtiyaç duymaz, aynı zamanda belirli korunan kaynaklara veya API uç noktalarına erişim almak için kullanıcı yetkilendirmesine de ihtiyaç duyar. Burada, oturum açma sırasında elde edilen `refresh_token`'ı kullanarak belirli kaynakları yönetmek için özellikle yetkilendirilmiş `access_token(s)` elde edeceğiz. Bu, korunan API'lerin kullanılabilir hale gelmesini sağlar. Kullanıcı oturum açma sırasında, tüm API kaynak belirticilerini yetkilendirme sunucusuna sağlamak çok önemlidir. Başarıyla kimlik doğrulama tamamlandıktan sonra, sadece ön yapılandırılan belirli kaynaklar için `access_tokens` alabiliriz. Bunu gerçekleştirmek için, oturum açma URL'si oluşturmadan önce, istemci uygulamanın yapılandırma ayarlarına tüm gereken API kaynak belirticilerini önceden yapılandırın. ```ts private async getAccessTokenByRefreshToken(resource?:string, scopes?: string[]){ const { appId } = this.logtoConfig; const { tokenEndpoint } = await this.getOidcConfig(); const { refreshToken } = await this.storage.getItem('refreshToken'); const parameters = new URLSearchParams({ 'grant_type': 'refresh_token', 'client_id': appId, 'refresh_token': }); if (resource) { parameters.append('resource', resource); } if (scopes?.length) { parameters.append('scope', scopes.join(' ')); } const response = await fetch(tokenEndpoint, { method: 'POST', grant_type: 'authorization_code', body: parameters, }); // save and replace the latest returned refreshToken await this.storage.setItem('refreshToken', response.refreshToken); await this.accessTokenMap.setItem(`${resource}:${scopes.join(_)}`, response.accessToken); return response.accessToken; } async getAccessToken(resource?:string, scopes?: string[]) { if (!this.idToken) { throw new Error('User not authenticated'); } const accessTokenInStorage = this.accessTokenMap.getItem(`${resource}:${scopes.join(_)}`); if (accessTokenInStorage && accessTokenInStorage.expiresAt > Date.now() / 1000) { return accessToken.token; } return await this.getAccessTokenByRefreshToken(resource, scopes); } ``` ## Özet Müşteri tarafı uygulamanın kullanıcı kimlik doğrulaması ve yetkilendirme süreci için temel yöntem uygulamalarını sunduk. Özel senaryonuza bağlı olarak, SDK mantığını düzenleyip optimize edebilirsiniz. Lütfen farklı platformlar ve çerçeveler nedeniyle farklılıkların olabileceğini unutmayın. Daha fazla detay için, Logto tarafından sunulan SDK paketlerini keşfedin. Daha fazla kullanıcının geliştirmeye katılmasını ve bizimle tartışmalara girmesini teşvik ediyoruz. SDK'nın yeteneklerini genişletme ve geliştirme sürecimiz boyunca geri bildirimleriniz ve katkılarınız çok değerlidir. ## Ek ### Ayrılmış kapsamlar Başlangıç auth talebi sırasında geçirmeniz gereken Logto ayrılmış kapsamlar. Bu kapsamlar ya OIDC ayrılmış ya da başarılı bir yetkilendirme akışını tamamlamak için Logto'da ayrılmış temel kapsamlardır. | Scope adı | Açıklama | | -------------- | --------------------------------------------------------------------------------------------------------------------------------- | | openid | Başarılı bir kimlik doğrulamadan sonra `id_token`'u yetkili bir şekilde sağlama gereklidir. | | offline-access | Ekran dışında bir `access_token` yenilemek ve takas etmek için kullanıcınızın uzatılabilir erişim sağlama konusunda yetkili olması gerekir. | | profile | Temel kullanıcı bilgilerine erişim yetkisi sağlama gerekir. | ### Logto Config | Özellik adı | Tip | Gerekli | Açıklama | Varsayılan Değer | | ------------- | ----------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------- | | appId | string | true | Eşsiz uygulama belirleyicisi. İstemci uygulamayı tanımlamak için yetkilendirme sunucusu tarafından oluşturulur. | | | appSecret | string | | Uygulama sırrı, uygulama ID ile birlikte, isteğin kimliğini doğrulamak için kullanılır. Go web veya Next.js web uygulamaları gibi gizli clientlar için gereklidir ve native veya tek sayfalı uygulamalar (SPA'lar) gibi kamu clientları için opsiyoneldir | | | endpoint | string | true | Yetkilendirme sunucusu kök uç noktası. Yetkilendirme isteklerini oluşturmak için genellikle kullanılır. | | | scopes | string list | | Kullanıcının belirli bir korumanın altındaki herhangi bir kaynağa erişmek için yetkili olması gereken tüm gerekli kaynak kapsamlarını gösterir. | [reservedScopes] | | resources | string list | | Kullanıcının erişim talep edebileceği tüm korunan kaynak belirticileri | | ### Util metotları #### generateRandomString ```ts const generateRandomString = (length = 64) => fromUint8Array(crypto.getRandomValues(new Uint8Array(length)), true); ``` Bugün Logto Cloud'u deneyin