Mobil, Web ve API için Kimlik Doğrulama Sağlayıcıları: Doğru Çözümü Seçmek için Eksiksiz Kılavuz

// Üretimde gerçekten çalışan Auth0 yapılandırması
const auth0Config = {
  domain: process.env.AUTH0_DOMAIN,
  clientId: process.env.AUTH0_CLIENT_ID,
  audience: process.env.AUTH0_AUDIENCE,
  // Kritik: API erişimi için uygun scope'ları ayarlayın
  scope: 'openid profile email read:users write:users',
  // Rate limit'lerden kaçınmak için token'ları düzgün önbelleğe alın
  cacheLocation: 'localstorage',
  useRefreshTokens: true,
  // Token süresinin dolmasını zarif bir şekilde ele alın
  onRedirectCallback: (appState) => {
    window.history.replaceState(
      {},
      document.title,
      appState?.returnTo || window.location.pathname
    );
  }
};

// React Native + Web için Firebase Auth kurulumu
import { initializeApp } from 'firebase/app';
import { getAuth, connectAuthEmulator } from 'firebase/auth';

const firebaseConfig = {
  apiKey: process.env.FIREBASE_API_KEY,
  authDomain: process.env.FIREBASE_AUTH_DOMAIN,
  projectId: process.env.FIREBASE_PROJECT_ID,
  // Kritik: Bunları istemci tarafı kodda açığa çıkarmayın
  storageBucket: process.env.FIREBASE_STORAGE_BUCKET,
  messagingSenderId: process.env.FIREBASE_MESSAGING_SENDER_ID,
  appId: process.env.FIREBASE_APP_ID
};

const app = initializeApp(firebaseConfig);
const auth = getAuth(app);

// Üretime hazır hata işleme
auth.onAuthStateChanged((user) => {
  if (user) {
    // Token'ı her zaman sunucu tarafında doğrulayın
    user.getIdToken(true).then((token) => {
      // Doğrulama için backend'inize gönderin
      verifyTokenOnServer(token);
    });
  }
});

// Uygun hata işleme ile Supabase Auth
import { createClient } from '@supabase/supabase-js';

const supabase = createClient(
  process.env.SUPABASE_URL!,
  process.env.SUPABASE_ANON_KEY!
);

// Üretime hazır auth hook'ları
export const useAuth = () => {
  const [user, setUser] = useState(null);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    // İlk oturumu al
    supabase.auth.getSession().then(({ data: { session } }) => {
      setUser(session?.user ?? null);
      setLoading(false);
    });

    // Auth değişikliklerini dinle
    const { data: { subscription } } = supabase.auth.onAuthStateChange(
      async (event, session) => {
        setUser(session?.user ?? null);
        setLoading(false);
      }
    );

    return () => subscription.unsubscribe();
  }, []);

  return { user, loading };
};

// CDK ile AWS Cognito
import { UserPool, UserPoolClient, AccountRecovery } from 'aws-cdk-lib/aws-cognito';
import { Duration } from 'aws-cdk-lib';

const userPool = new UserPool(this, 'MyUserPool', {
  userPoolName: 'my-app-users',
  selfSignUpEnabled: true,
  signInAliases: {
    email: true,
    phone: true,
  },
  standardAttributes: {
    email: {
      required: true,
      mutable: true,
    },
  },
  passwordPolicy: {
    minLength: 8,
    requireLowercase: true,
    requireUppercase: true,
    requireDigits: true,
    requireSymbols: true,
  },
  accountRecovery: AccountRecovery.EMAIL_ONLY,
  // Üretim için kritik: MFA'yı etkinleştir
  mfa: Mfa.REQUIRED,
  mfaSecondFactor: {
    sms: true,
    otp: true,
  },
  // Token yapılandırması
  accessTokenValidity: Duration.hours(1),
  idTokenValidity: Duration.hours(1),
  refreshTokenValidity: Duration.days(30),
});

// Uygun güvenlikle özel JWT auth
import jwt from 'jsonwebtoken';
import bcrypt from 'bcrypt';
import { randomBytes } from 'crypto';

class CustomAuthService {
  private readonly JWT_SECRET = process.env.JWT_SECRET!;
  private readonly JWT_EXPIRES_IN = '1h';
  private readonly REFRESH_TOKEN_EXPIRES_IN = '7d';

  async generateTokens(userId: string, email: string) {
    const accessToken = jwt.sign(
      { userId, email, type: 'access' },
      this.JWT_SECRET,
      { expiresIn: this.JWT_EXPIRES_IN }
    );

    const refreshToken = jwt.sign(
      { userId, type: 'refresh' },
      this.JWT_SECRET,
      { expiresIn: this.REFRESH_TOKEN_EXPIRES_IN }
    );

    // Refresh token hash'ini veritabanında sakla
    const refreshTokenHash = await bcrypt.hash(refreshToken, 12);
    await this.storeRefreshToken(userId, refreshTokenHash);

    return { accessToken, refreshToken };
  }

  async verifyToken(token: string) {
    try {
      const decoded = jwt.verify(token, this.JWT_SECRET) as any;

      // Token'ın kara listelenip listelenmediğini kontrol et
      const isBlacklisted = await this.isTokenBlacklisted(token);
      if (isBlacklisted) {
        throw new Error('Token kara listede');
      }

      return decoded;
    } catch (error) {
      throw new Error('Geçersiz token');
    }
  }

  async refreshAccessToken(refreshToken: string) {
    try {
      const decoded = jwt.verify(refreshToken, this.JWT_SECRET) as any;

      // Refresh token'ın veritabanında var olduğunu doğrula
      const isValid = await this.verifyRefreshToken(decoded.userId, refreshToken);
      if (!isValid) {
        throw new Error('Geçersiz refresh token');
      }

      // Yeni access token oluştur
      const user = await this.getUserById(decoded.userId);
      return this.generateTokens(user.id, user.email);
    } catch (error) {
      throw new Error('Geçersiz refresh token');
    }
  }
}

// Auth0 kurumsal yapılandırması
const auth0Config = {
  domain: process.env.AUTH0_DOMAIN,
  clientId: process.env.AUTH0_CLIENT_ID,
  audience: process.env.AUTH0_AUDIENCE,
  // Kurumsal özellikler
  scope: 'openid profile email read:users write:users read:logs',
  // SAML yapılandırması
  samlConfiguration: {
    signInUrl: process.env.SAML_SIGN_IN_URL,
    signOutUrl: process.env.SAML_SIGN_OUT_URL,
  },
  // Kurumsal mantık için özel kurallar
  rules: [
    {
      name: 'Kurumsal metadata ekle',
      script: `
        function (user, context, callback) {
          // Kurumsal özel claim'ler ekle
          context.idToken['https://myapp.com/enterprise'] = user.app_metadata.enterprise;
          callback(null, user, context);
        }
      `
    }
  ]
};

// Sosyal giriş ile Firebase Auth
import {
  signInWithPopup,
  GoogleAuthProvider,
  FacebookAuthProvider
} from 'firebase/auth';

const googleProvider = new GoogleAuthProvider();
const facebookProvider = new FacebookAuthProvider();

// Sağlayıcıları yapılandır
googleProvider.addScope('email');
googleProvider.addScope('profile');
facebookProvider.addScope('email');

// Sosyal giriş uygulaması
const signInWithGoogle = async () => {
  try {
    const result = await signInWithPopup(auth, googleProvider);
    const user = result.user;

    // Token'ı doğrulama için backend'e gönder
    const token = await user.getIdToken();
    await verifyTokenOnBackend(token);

    return user;
  } catch (error) {
    console.error('Google giriş hatası:', error);
    throw error;
  }
};

// Özel kullanıcı metadata'sı ile Supabase Auth
const { data: { user }, error } = await supabase.auth.signUp({
  email: 'user@example.com',
  password: 'securepassword',
  options: {
    data: {
      full_name: 'John Doe',
      company: 'Startup Inc',
      role: 'admin'
    }
  }
});

// Özel mantık için doğrudan veritabanı sorguları
const { data: users, error } = await supabase
  .from('users')
  .select('*')
  .eq('company_id', companyId)
  .order('created_at', { ascending: false });

// Lambda trigger'ları ile Cognito
import { CognitoJwtVerifier } from 'aws-jwt-verify';

const verifier = CognitoJwtVerifier.create({
  userPoolId: process.env.COGNITO_USER_POOL_ID,
  tokenUse: 'access',
  clientId: process.env.COGNITO_CLIENT_ID,
});

// Cognito auth ile Lambda fonksiyonu
export const handler = async (event) => {
  try {
    const token = event.headers.Authorization?.replace('Bearer ', '');
    const payload = await verifier.verify(token);

    // Kullanıcı kimliği doğrulandı, iş mantığı ile devam et
    const userId = payload.sub;
    const result = await processUserRequest(userId, event.body);

    return {
      statusCode: 200,
      body: JSON.stringify(result)
    };
  } catch (error) {
    return {
      statusCode: 401,
      body: JSON.stringify({ error: 'Yetkisiz' })
    };
  }
};

// Kullanıcı verisi için migrasyon script'i
const migrateUsersToAuth0 = async () => {
  const users = await getUsersFromCustomDB();

  for (const user of users) {
    try {
      // Auth0'da kullanıcı oluştur
      const auth0User = await auth0Management.users.create({
        email: user.email,
        password: generateTemporaryPassword(),
        email_verified: user.emailVerified,
        user_metadata: {
          migrated_from: 'custom_jwt',
          original_user_id: user.id
        }
      });

      // Yerel veritabanını Auth0 kullanıcı ID'si ile güncelle
      await updateUserAuth0Id(user.id, auth0User.user_id);

      console.log(`Kullanıcı taşındı: ${user.email}`);
    } catch (error) {
      console.error(`${user.email} kullanıcısını taşıma başarısız:`, error);
    }
  }
};

// Firebase'den Auth0'a migrasyon
const migrateFromFirebase = async () => {
  const firebaseUsers = await getFirebaseUsers();

  for (const firebaseUser of firebaseUsers) {
    try {
      // Auth0'da kullanıcı oluştur
      const auth0User = await auth0Management.users.create({
        email: firebaseUser.email,
        email_verified: firebaseUser.emailVerified,
        user_metadata: {
          firebase_uid: firebaseUser.uid,
          migrated_at: new Date().toISOString()
        }
      });

      // Özel claim'leri taşı
      if (firebaseUser.customClaims) {
        await auth0Management.users.update(
          { user_id: auth0User.user_id },
          { app_metadata: firebaseUser.customClaims }
        );
      }

    } catch (error) {
      console.error(`${firebaseUser.email} için migrasyon başarısız:`, error);
    }
  }
};

// Güvenli token işleme
const secureTokenStorage = {
  // Token'ları güvenli sakla
  storeTokens: (accessToken: string, refreshToken: string) => {
    // Güvenli depolama kullan (hassas veriler için localStorage değil)
    if (isMobile()) {
      // Keychain (iOS) veya Keystore (Android) kullan
      SecureStore.setItemAsync('access_token', accessToken);
      SecureStore.setItemAsync('refresh_token', refreshToken);
    } else {
      // Web için httpOnly çerezler kullan
      document.cookie = `access_token=${accessToken}; HttpOnly; Secure; SameSite=Strict`;
    }
  },

  // Token'ları düzenli olarak döndür
  rotateTokens: async () => {
    const refreshToken = await getRefreshToken();
    const response = await fetch('/api/auth/refresh', {
      method: 'POST',
      headers: { 'Authorization': `Bearer ${refreshToken}` }
    });

    if (response.ok) {
      const { accessToken, refreshToken: newRefreshToken } = await response.json();
      secureTokenStorage.storeTokens(accessToken, newRefreshToken);
    }
  }
};

// Auth endpoint'leri için rate limiting
const rateLimit = require('express-rate-limit');

const authLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 dakika
  max: 5, // Pencere başına 5 deneme
  message: 'Çok fazla kimlik doğrulama denemesi, lütfen daha sonra tekrar deneyin',
  standardHeaders: true,
  legacyHeaders: false,
  // Dağıtık sistemler için rate limit verisini Redis'te sakla
  store: new RedisStore({
    client: redisClient,
    prefix: 'auth_rate_limit:'
  })
});

app.use('/api/auth/login', authLimiter);
app.use('/api/auth/register', authLimiter);

// Redis tabanlı token önbellekleme
class TokenCache {
  private redis: Redis;
  private readonly CACHE_TTL = 3600; // 1 saat

  constructor() {
    this.redis = new Redis(process.env.REDIS_URL);
  }

  async cacheToken(userId: string, token: string): Promise<void> {
    await this.redis.setex(`token:${userId}`, this.CACHE_TTL, token);
  }

  async getCachedToken(userId: string): Promise<string | null> {
    return await this.redis.get(`token:${userId}`);
  }

  async invalidateToken(userId: string): Promise<void> {
    await this.redis.del(`token:${userId}`);
  }
}

// Auth için veritabanı bağlantı havuzu
const pool = new Pool({
  host: process.env.DB_HOST,
  port: parseInt(process.env.DB_PORT),
  database: process.env.DB_NAME,
  user: process.env.DB_USER,
  password: process.env.DB_PASSWORD,
  // Auth sorguları için optimize et
  max: 20,
  idleTimeoutMillis: 30000,
  connectionTimeoutMillis: 2000,
  // Üretim için SSL'i etkinleştir
  ssl: process.env.NODE_ENV === 'production' ? { rejectUnauthorized: false } : false
});

// Idempotent kullanıcı oluşturma
const createUserIfNotExists = async (auth0User: any) => {
  const existingUser = await db.user.findUnique({
    where: { auth0Id: auth0User.user_id }
  });

  if (existingUser) {
    return existingUser;
  }

  try {
    return await db.user.create({
      data: {
        auth0Id: auth0User.user_id,
        email: auth0User.email,
        emailVerified: auth0User.email_verified,
        metadata: auth0User.user_metadata
      }
    });
  } catch (error) {
    // Yarış durumunu ele al
    if (error.code === 'P2002') {
      return await db.user.findUnique({
        where: { auth0Id: auth0User.user_id }
      });
    }
    throw error;
  }
};

// Saat kayması toleransı ile token doğrulama
const validateToken = async (token: string) => {
  try {
    const decoded = jwt.verify(token, process.env.AUTH0_PUBLIC_KEY, {
      algorithms: ['RS256'],
      clockTolerance: 30, // 30 saniye tolerans
      issuer: `https://${process.env.AUTH0_DOMAIN}/`,
      audience: process.env.AUTH0_AUDIENCE
    });

    return decoded;
  } catch (error) {
    console.error('Token doğrulama hatası:', error);
    throw new Error('Geçersiz token');
  }
};