// ❌ КАТЕГОРИЧНО НЕБЕЗПЕЧНА ПРАКТИКА (до OAuth 2.0)
interface TwitterCredentials {
  username: string;
  password: string;
}

async function postToTwitter(credentials: TwitterCredentials, message: string) {
  // Застосунок зберігає пароль користувача від Twitter!
  await twitterAPI.authenticate(credentials.username, credentials.password);
  await twitterAPI.postTweet(message);
}

// Frontend (React)
function LoginPage() {
  const handleGoogleLogin = () => {
    // Перенаправлення на backend ендпоінт
    window.location.href = 'https://api.example.com/auth/google';
  };

  return (
    <button onClick={handleGoogleLogin} className="btn btn-google">
      <img src="/google-icon.svg" alt="" />
      Login with Google
    </button>
  );
}

// Backend (NestJS)
import { Controller, Get, Res } from '@nestjs/common';
import { Response } from 'express';
import { randomBytes } from 'crypto';

@Controller('auth')
export class AuthController {
  @Get('google')
  initiateGoogleAuth(@Res() res: Response) {
    // 1. Генерація state для захисту від CSRF
    const state = randomBytes(16).toString('hex');
    
    // Зберігаємо state у session або Redis
    // req.session.oauthState = state;

    // 2. Параметри авторизації
    const params = new URLSearchParams({
      client_id: process.env.GOOGLE_CLIENT_ID,
      redirect_uri: 'https://api.example.com/auth/google/callback',
      response_type: 'code',
      scope: 'openid email profile', // Запитувані дозволи
      state: state,
      access_type: 'offline', // Для отримання Refresh Token
      prompt: 'consent', // Завжди показувати екран підтвердження
    });

    // 3. Redirect браузера користувача на Google
    const authUrl = `https://accounts.google.com/o/oauth2/v2/auth?${params.toString()}`;
    res.redirect(authUrl);
  }
}

┌─────────────────────────────────────────────┐
│  Google                              [×]    │
├─────────────────────────────────────────────┤
│                                             │
│  ivan.petrenko@gmail.com                    │
│                                             │
│  TaskMaster wants to access your            │
│  Google Account                             │
│                                             │
│  This will allow TaskMaster to:             │
│  ✓ View your email address                 │
│  ✓ View your basic profile info            │
│                                             │
│  By continuing, you allow this app to use   │
│  your information in accordance with their  │
│  terms of service and privacy policy.       │
│                                             │
│  [Cancel]              [Allow]              │
└─────────────────────────────────────────────┘

GET /auth/google/callback?code=4/0AX4XfWh...&state=a3f9c8e7b2d4f1e8 HTTP/1.1
Host: api.example.com

// Backend (NestJS)
@Get('google/callback')
async handleGoogleCallback(
  @Query('code') code: string,
  @Query('state') state: string,
  @Res() res: Response,
) {
  // 1. Валідація state (захист від CSRF)
  // const savedState = req.session.oauthState;
  // if (state !== savedState) {
  //   throw new UnauthorizedException('Invalid state parameter');
  // }

  if (!code) {
    throw new BadRequestException('Authorization code not provided');
  }

  // 2. Обмін code на Access Token
  const tokens = await this.exchangeCodeForTokens(code);

  // 3. Отримання профілю користувача з Google API
  const userProfile = await this.fetchGoogleProfile(tokens.access_token);

  // 4. Створення або оновлення користувача у БД
  const user = await this.authService.findOrCreateUser({
    email: userProfile.email,
    firstName: userProfile.given_name,
    lastName: userProfile.family_name,
    picture: userProfile.picture,
    googleId: userProfile.sub,
  });

  // 5. Генерація власного JWT токена
  const jwtToken = this.authService.generateJWT(user);

  // 6. Redirect на frontend з токеном
  res.redirect(`https://app.example.com/auth/callback?token=${jwtToken}`);
}

// src/auth/oauth.service.ts
import axios from 'axios';

async exchangeCodeForTokens(code: string) {
  const params = new URLSearchParams({
    code: code,
    client_id: process.env.GOOGLE_CLIENT_ID,
    client_secret: process.env.GOOGLE_CLIENT_SECRET, // ✅ Секрет надсилається лише з backend
    redirect_uri: 'https://api.example.com/auth/google/callback',
    grant_type: 'authorization_code',
  });

  const response = await axios.post(
    'https://oauth2.googleapis.com/token',
    params.toString(),
    {
      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    }
  );

  return response.data;
  // {
  //   access_token: "ya29.a0AfH6SMB...",
  //   expires_in: 3599,
  //   refresh_token: "1//0gH6SMB...", // Якщо запитували access_type=offline
  //   scope: "openid https://www.googleapis.com/auth/userinfo.email ...",
  //   token_type: "Bearer",
  //   id_token: "eyJhbGciOiJSUzI1NiIsImtpZCI6..."
  // }
}

async fetchGoogleProfile(accessToken: string) {
  const response = await axios.get(
    'https://www.googleapis.com/oauth2/v3/userinfo',
    {
      headers: { Authorization: `Bearer ${accessToken}` },
    }
  );

  return response.data;
  // {
  //   sub: "108012345678901234567",  // Унікальний ID користувача у Google
  //   name: "Іван Петренко",
  //   given_name: "Іван",
  //   family_name: "Петренко",
  //   picture: "https://lh3.googleusercontent.com/a/...",
  //   email: "ivan.petrenko@gmail.com",
  //   email_verified: true,
  //   locale: "uk"
  // }
}

import { decode } from 'jsonwebtoken';

const idToken = tokens.id_token;
const payload = decode(idToken); // Або verify() для перевірки підпису

console.log(payload);
// {
//   iss: "https://accounts.google.com",
//   azp: "YOUR_CLIENT_ID",
//   aud: "YOUR_CLIENT_ID",
//   sub: "108012345678901234567",
//   email: "ivan.petrenko@gmail.com",
//   email_verified: true,
//   at_hash: "...",
//   name: "Іван Петренко",
//   picture: "...",
//   given_name: "Іван",
//   family_name: "Петренко",
//   locale: "uk",
//   iat: 1693564800,
//   exp: 1693568400
// }

const params = new URLSearchParams({
  client_id: process.env.GOOGLE_CLIENT_ID,
  redirect_uri: 'https://api.example.com/auth/google/callback',
  response_type: 'code',
  scope: 'openid email profile', // ✅ Лише базові дані
  state: state,
});

const params = new URLSearchParams({
  client_id: process.env.GOOGLE_CLIENT_ID,
  redirect_uri: 'https://api.example.com/auth/google/callback',
  response_type: 'code',
  scope: [
    'openid',
    'email',
    'profile',
    'https://www.googleapis.com/auth/drive.readonly', // Читання Drive
    'https://www.googleapis.com/auth/calendar',        // Керування Calendar
  ].join(' '),
  state: state,
});

{
  "iss": "https://accounts.google.com",
  "azp": "YOUR_CLIENT_ID.apps.googleusercontent.com",
  "aud": "YOUR_CLIENT_ID.apps.googleusercontent.com",
  "sub": "108012345678901234567",
  "email": "ivan.petrenko@gmail.com",
  "email_verified": true,
  "at_hash": "HK6E_P6Dh8Y93mRNtsDB1Q",
  "name": "Іван Петренко",
  "picture": "https://lh3.googleusercontent.com/a/ACg8ocKx...",
  "given_name": "Іван",
  "family_name": "Петренко",
  "locale": "uk",
  "iat": 1693564800,
  "exp": 1693568400
}

// src/auth/oauth.service.ts
import { JwtService } from '@nestjs/jwt';
import axios from 'axios';
import * as jwksClient from 'jwks-rsa';

@Injectable()
export class OAuthService {
  private jwksClient: jwksClient.JwksClient;

  constructor() {
    // Клієнт для завантаження публічних ключів Google
    this.jwksClient = jwksClient({
      jwksUri: 'https://www.googleapis.com/oauth2/v3/certs',
      cache: true,
      cacheMaxAge: 86400000, // 24 години
    });
  }

  async verifyGoogleIdToken(idToken: string) {
    const decoded = jwt.decode(idToken, { complete: true });

    if (!decoded) {
      throw new UnauthorizedException('Invalid ID token');
    }

    // Отримання публічного ключа за kid (Key ID)
    const key = await this.jwksClient.getSigningKey(decoded.header.kid);
    const publicKey = key.getPublicKey();

    // Верифікація підпису та claims
    const verified = jwt.verify(idToken, publicKey, {
      audience: process.env.GOOGLE_CLIENT_ID,
      issuer: 'https://accounts.google.com',
      algorithms: ['RS256'],
    });

    return verified;
  }
}

# .env
GOOGLE_CLIENT_ID=123456789-abcdefghijklmnop.apps.googleusercontent.com
GOOGLE_CLIENT_SECRET=GOCSPX-AbCdEfGhIjKlMnOpQrStUvWxYz
GOOGLE_CALLBACK_URL=https://api.example.com/auth/google/callback

// src/auth/strategies/google.strategy.ts
import { Injectable } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { Strategy, VerifyCallback } from 'passport-google-oauth20';
import { ConfigService } from '@nestjs/config';

@Injectable()
export class GoogleStrategy extends PassportStrategy(Strategy, 'google') {
  constructor(private config: ConfigService) {
    super({
      clientID: config.get<string>('GOOGLE_CLIENT_ID'),
      clientSecret: config.get<string>('GOOGLE_CLIENT_SECRET'),
      callbackURL: config.get<string>('GOOGLE_CALLBACK_URL'),
      scope: ['openid', 'email', 'profile'],
      passReqToCallback: false, // Якщо true, перший параметр validate() буде request
    });
  }

  /**
   * Метод validate() викликається після успішної авторизації
   * 
   * @param accessToken - Access Token від Google
   * @param refreshToken - Refresh Token (якщо запитували access_type=offline)
   * @param profile - Профіль користувача з Google
   * @param done - Callback для передачі даних у req.user
   */
  async validate(
    accessToken: string,
    refreshToken: string,
    profile: any,
    done: VerifyCallback,
  ): Promise<any> {
    const { id, name, emails, photos } = profile;

    // Формування об'єкта користувача
    const user = {
      googleId: id,
      email: emails[0].value,
      emailVerified: emails[0].verified,
      firstName: name.givenName,
      lastName: name.familyName,
      picture: photos[0].value,
      accessToken,
      refreshToken,
    };

    // Передаємо user до req.user
    done(null, user);
  }
}

{
  id: '108012345678901234567',
  displayName: 'Іван Петренко',
  name: {
    familyName: 'Петренко',
    givenName: 'Іван'
  },
  emails: [
    {
      value: 'ivan.petrenko@gmail.com',
      verified: true
    }
  ],
  photos: [
    {
      value: 'https://lh3.googleusercontent.com/a/ACg8ocKx...'
    }
  ],
  provider: 'google',
  _raw: '{"sub":"108012345678901234567",...}',
  _json: {
    sub: '108012345678901234567',
    name: 'Іван Петренко',
    given_name: 'Іван',
    family_name: 'Петренко',
    picture: 'https://...',
    email: 'ivan.petrenko@gmail.com',
    email_verified: true,
    locale: 'uk'
  }
}

// src/auth/guards/google-auth.guard.ts
import { Injectable } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';

@Injectable()
export class GoogleAuthGuard extends AuthGuard('google') {}

// src/auth/auth.controller.ts
import { Controller, Get, UseGuards, Req, Res } from '@nestjs/common';
import { Response, Request } from 'express';
import { GoogleAuthGuard } from './guards/google-auth.guard';
import { AuthService } from './auth.service';

@Controller('auth')
export class AuthController {
  constructor(private authService: AuthService) {}

  /**
   * GET /auth/google
   * Ініціація OAuth потоку — redirect на Google
   */
  @Get('google')
  @UseGuards(GoogleAuthGuard)
  async googleAuth() {
    // Guard автоматично перенаправляє на Google
    // Цей метод ніколи не викликається
  }

  /**
   * GET /auth/google/callback
   * Обробка callback від Google
   */
  @Get('google/callback')
  @UseGuards(GoogleAuthGuard)
  async googleAuthCallback(
    @Req() req: Request,
    @Res() res: Response,
  ) {
    // req.user встановлено GoogleStrategy.validate()
    const googleUser = req.user as any;

    // Створення або оновлення користувача у БД
    const user = await this.authService.findOrCreateOAuthUser({
      provider: 'google',
      providerId: googleUser.googleId,
      email: googleUser.email,
      emailVerified: googleUser.emailVerified,
      firstName: googleUser.firstName,
      lastName: googleUser.lastName,
      picture: googleUser.picture,
    });

    // Генерація власного JWT токена
    const jwtToken = this.authService.generateJWT(user);

    // Redirect на frontend з токеном
    res.redirect(`https://app.example.com/auth/callback?token=${jwtToken}`);
  }
}

// src/auth/auth.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { User } from '../users/entities/user.entity';

interface OAuthUserData {
  provider: string;
  providerId: string;
  email: string;
  emailVerified: boolean;
  firstName: string;
  lastName: string;
  picture: string;
}

@Injectable()
export class AuthService {
  constructor(
    @InjectRepository(User)
    private userRepository: Repository<User>,
  ) {}

  async findOrCreateOAuthUser(data: OAuthUserData): Promise<User> {
    // 1. Пошук користувача за providerId (наприклад, Google ID)
    let user = await this.userRepository.findOne({
      where: {
        provider: data.provider,
        providerId: data.providerId,
      },
    });

    if (user) {
      // 2. Оновлення даних при кожному вході (фото могло змінитися)
      user.firstName = data.firstName;
      user.lastName = data.lastName;
      user.picture = data.picture;
      user.lastLoginAt = new Date();
      await this.userRepository.save(user);
      return user;
    }

    // 3. Перевірка, чи не існує користувач з таким email (пов'язаний з іншим провайдером)
    const existingEmailUser = await this.userRepository.findOne({
      where: { email: data.email },
    });

    if (existingEmailUser && !existingEmailUser.providerId) {
      // Email вже використовується для локального облікового запису
      throw new ConflictException(
        'Email is already registered with email/password. Please log in with your password.'
      );
    }

    // 4. Створення нового користувача
    user = this.userRepository.create({
      email: data.email,
      emailVerified: data.emailVerified,
      firstName: data.firstName,
      lastName: data.lastName,
      picture: data.picture,
      provider: data.provider,
      providerId: data.providerId,
      roles: ['user'],
      lastLoginAt: new Date(),
    });

    await this.userRepository.save(user);
    return user;
  }
}

// src/users/entities/user.entity.ts
import { Entity, Column, PrimaryGeneratedColumn, CreateDateColumn } from 'typeorm';

@Entity('users')
export class User {
  @PrimaryGeneratedColumn('uuid')
  id: string;

  @Column({ unique: true })
  email: string;

  @Column({ default: false })
  emailVerified: boolean;

  @Column({ nullable: true })
  passwordHash: string; // Null для OAuth користувачів

  @Column({ nullable: true })
  provider: string; // 'google', 'github', 'facebook', null для локальних

  @Column({ nullable: true })
  providerId: string; // ID користувача у провайдера

  @Column({ nullable: true })
  firstName: string;

  @Column({ nullable: true })
  lastName: string;

  @Column({ nullable: true })
  picture: string;

  @Column('simple-array', { default: 'user' })
  roles: string[];

  @CreateDateColumn()
  createdAt: Date;

  @Column({ type: 'timestamp', nullable: true })
  lastLoginAt: Date;
}

// src/auth/auth.module.ts
import { Module } from '@nestjs/common';
import { PassportModule } from '@nestjs/passport';
import { JwtModule } from '@nestjs/jwt';
import { TypeOrmModule } from '@nestjs/typeorm';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { AuthService } from './auth.service';
import { AuthController } from './auth.controller';
import { User } from '../users/entities/user.entity';
import { GoogleStrategy } from './strategies/google.strategy';
import { JwtStrategy } from './strategies/jwt.strategy';

@Module({
  imports: [
    TypeOrmModule.forFeature([User]),
    PassportModule,
    JwtModule.registerAsync({
      imports: [ConfigModule],
      inject: [ConfigService],
      useFactory: (config: ConfigService) => ({
        secret: config.get<string>('JWT_SECRET'),
        signOptions: { expiresIn: '15m' },
      }),
    }),
  ],
  controllers: [AuthController],
  providers: [
    AuthService,
    GoogleStrategy,  // ✅ Реєструємо Google Strategy
    JwtStrategy,
  ],
  exports: [AuthService],
})
export class AuthModule {}

npm install passport-github2
npm install --save-dev @types/passport-github2

// src/auth/strategies/github.strategy.ts
import { Injectable } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { Strategy } from 'passport-github2';
import { ConfigService } from '@nestjs/config';

@Injectable()
export class GitHubStrategy extends PassportStrategy(Strategy, 'github') {
  constructor(private config: ConfigService) {
    super({
      clientID: config.get<string>('GITHUB_CLIENT_ID'),
      clientSecret: config.get<string>('GITHUB_CLIENT_SECRET'),
      callbackURL: config.get<string>('GITHUB_CALLBACK_URL'),
      scope: ['user:email'], // Запит доступу до email
    });
  }

  async validate(
    accessToken: string,
    refreshToken: string,
    profile: any,
    done: any,
  ) {
    const { id, username, emails, photos } = profile;

    const user = {
      githubId: id,
      username: username,
      email: emails?.[0]?.value || null,
      picture: photos?.[0]?.value || null,
      accessToken,
    };

    done(null, user);
  }
}

@Get('github')
@UseGuards(AuthGuard('github'))
async githubAuth() {}

@Get('github/callback')
@UseGuards(AuthGuard('github'))
async githubAuthCallback(@Req() req, @Res() res: Response) {
  const githubUser = req.user;
  
  const user = await this.authService.findOrCreateOAuthUser({
    provider: 'github',
    providerId: githubUser.githubId,
    email: githubUser.email,
    emailVerified: false, // GitHub не гарантує верифікацію
    firstName: githubUser.username,
    lastName: '',
    picture: githubUser.picture,
  });

  const jwtToken = this.authService.generateJWT(user);
  res.redirect(`https://app.example.com/auth/callback?token=${jwtToken}`);
}

1. Зловмисник логінеться через Google → отримує callback:
   https://api.example.com/auth/google/callback?code=ATTACKER_CODE&state=xyz

2. Зловмисник надсилає жертві посилання:
   https://api.example.com/auth/google/callback?code=ATTACKER_CODE&state=xyz

3. Жертва переходить за посиланням → застосунок створює JWT для облікового запису зловмисника.

4. Жертва тепер автентифікована як зловмисник → всі дії виконуються від імені зловмисника.

import { randomBytes } from 'crypto';

@Get('google')
initiateGoogleAuth(@Req() req, @Res() res: Response) {
  const state = randomBytes(16).toString('hex');
  
  // Зберігаємо state у session або Redis з TTL 10 хвилин
  req.session.oauthState = state;

  const authUrl = `https://accounts.google.com/o/oauth2/v2/auth?...&state=${state}`;
  res.redirect(authUrl);
}

@Get('google/callback')
async handleCallback(@Query('state') state: string, @Req() req) {
  if (state !== req.session.oauthState) {
    throw new UnauthorizedException('Invalid state parameter — possible CSRF attack');
  }

  // Видаляємо використаний state
  delete req.session.oauthState;

  // Продовжуємо обробку...
}

// ❌ НЕБЕЗПЕЧНО
@Get('google')
initiateGoogleAuth(@Query('return_to') returnTo: string, @Res() res) {
  const authUrl = `https://accounts.google.com/o/oauth2/v2/auth?...&state=${returnTo}`;
  res.redirect(authUrl);
}

@Get('google/callback')
async handleCallback(@Query('state') returnTo: string, @Res() res) {
  const jwtToken = '...';
  res.redirect(`${returnTo}?token=${jwtToken}`); // ❌ Редірект на довільний URL
}

GET /auth/google?return_to=https://evil.com/fake-login
→ Користувач авторизується
→ Redirect на https://evil.com/fake-login?token=REAL_JWT
→ Зловмисник краде токен

const ALLOWED_REDIRECT_URLS = [
  'https://app.example.com',
  'https://app.example.com/dashboard',
  'http://localhost:3000', // Для розробки
];

function validateRedirectUrl(url: string): boolean {
  try {
    const parsedUrl = new URL(url);
    return ALLOWED_REDIRECT_URLS.some(allowed => 
      parsedUrl.origin === new URL(allowed).origin
    );
  } catch {
    return false;
  }
}

@Get('google/callback')
async handleCallback(@Query('state') returnTo: string, @Res() res) {
  if (!validateRedirectUrl(returnTo)) {
    throw new BadRequestException('Invalid redirect URL');
  }

  const jwtToken = '...';
  res.redirect(`${returnTo}?token=${jwtToken}`);
}

// ❌ КАТЕГОРИЧНО НЕБЕЗПЕЧНО
const params = {
  client_id: 'YOUR_CLIENT_ID',
  client_secret: 'YOUR_CLIENT_SECRET', // ❌ Видно у DevTools
  grant_type: 'authorization_code',
  code: authCode,
};

fetch('https://oauth2.googleapis.com/token', {
  method: 'POST',
  body: JSON.stringify(params),
});

// ❌ НЕБЕЗПЕЧНО: декодування без верифікації
const idToken = req.body.id_token;
const payload = jwt.decode(idToken); // Немає перевірки підпису!

const user = {
  email: payload.email, // Може бути admin@example.com
  roles: payload.roles, // Може бути ['admin']
};

// ✅ БЕЗПЕЧНО
const verified = jwt.verify(idToken, publicKey, {
  audience: process.env.GOOGLE_CLIENT_ID,
  issuer: 'https://accounts.google.com',
  algorithms: ['RS256'],
});

// src/pages/AuthCallbackPage.tsx
import React, { useEffect } from 'react';
import { useNavigate, useSearchParams } from 'react-router-dom';
import { useAuth } from '../contexts/AuthContext';

export function AuthCallbackPage() {
  const [searchParams] = useSearchParams();
  const navigate = useNavigate();
  const { setAccessToken } = useAuth();

  useEffect(() => {
    const token = searchParams.get('token');
    const error = searchParams.get('error');

    if (error) {
      // Обробка помилки OAuth (користувач відхилив дозволи)
      console.error('OAuth error:', error);
      navigate('/login?error=oauth_failed');
      return;
    }

    if (token) {
      // Збереження JWT токена
      setAccessToken(token);
      localStorage.setItem('access_token', token);

      // Перенаправлення на домашню сторінку
      navigate('/dashboard');
    } else {
      // Невідома помилка
      navigate('/login?error=unknown');
    }
  }, [searchParams, navigate, setAccessToken]);

  return (
    <div className="auth-callback-loading">
      <div className="spinner"></div>
      <p>Completing authentication...</p>
    </div>
  );
}

// src/components/SocialLoginButtons.tsx
import React from 'react';

const BACKEND_URL = 'https://api.example.com';

export function SocialLoginButtons() {
  const handleGoogleLogin = () => {
    window.location.href = `${BACKEND_URL}/auth/google`;
  };

  const handleGitHubLogin = () => {
    window.location.href = `${BACKEND_URL}/auth/github`;
  };

  const handleFacebookLogin = () => {
    window.location.href = `${BACKEND_URL}/auth/facebook`;
  };

  return (
    <div className="social-login">
      <button
        onClick={handleGoogleLogin}
        className="btn btn-google"
      >
        <img src="/icons/google.svg" alt="" />
        Continue with Google
      </button>

      <button
        onClick={handleGitHubLogin}
        className="btn btn-github"
      >
        <img src="/icons/github.svg" alt="" />
        Continue with GitHub
      </button>

      <button
        onClick={handleFacebookLogin}
        className="btn btn-facebook"
      >
        <img src="/icons/facebook.svg" alt="" />
        Continue with Facebook
      </button>
    </div>
  );
}

.btn-google {
  @apply flex items-center justify-center gap-3 w-full px-6 py-3 bg-white border-2 border-gray-300 rounded-lg hover:bg-gray-50 transition-colors;
}

.btn-github {
  @apply flex items-center justify-center gap-3 w-full px-6 py-3 bg-gray-900 text-white rounded-lg hover:bg-gray-800 transition-colors;
}

.btn-facebook {
  @apply flex items-center justify-center gap-3 w-full px-6 py-3 bg-blue-600 text-white rounded-lg hover:bg-blue-700 transition-colors;
}