Comprehensive comparison for Authentication technology in Software Development applications

const express = require('express');
const axios = require('axios');
const jwt = require('jsonwebtoken');

const app = express();
app.use(express.json());

// OneTrust Configuration
const ONETRUST_API_URL = process.env.ONETRUST_API_URL || 'https://app.onetrust.com/api';
const ONETRUST_CLIENT_ID = process.env.ONETRUST_CLIENT_ID;
const ONETRUST_CLIENT_SECRET = process.env.ONETRUST_CLIENT_SECRET;
const JWT_SECRET = process.env.JWT_SECRET;

// Cache for OneTrust access token
let oneTrustTokenCache = {
  token: null,
  expiresAt: null
};

// Authenticate with OneTrust and get access token
async function getOneTrustAccessToken() {
  try {
    // Return cached token if still valid
    if (oneTrustTokenCache.token && oneTrustTokenCache.expiresAt > Date.now()) {
      return oneTrustTokenCache.token;
    }

    const response = await axios.post(`${ONETRUST_API_URL}/access/v1/oauth/token`, {
      grant_type: 'client_credentials',
      client_id: ONETRUST_CLIENT_ID,
      client_secret: ONETRUST_CLIENT_SECRET
    }, {
      headers: { 'Content-Type': 'application/json' }
    });

    const { access_token, expires_in } = response.data;
    
    // Cache token with 5 minute buffer before expiration
    oneTrustTokenCache = {
      token: access_token,
      expiresAt: Date.now() + ((expires_in - 300) * 1000)
    };

    return access_token;
  } catch (error) {
    console.error('OneTrust authentication failed:', error.response?.data || error.message);
    throw new Error('Failed to authenticate with OneTrust');
  }
}

// Verify user consent via OneTrust
async function verifyUserConsent(userId, purpose) {
  try {
    const accessToken = await getOneTrustAccessToken();
    
    const response = await axios.get(
      `${ONETRUST_API_URL}/consent/v3/users/${userId}/purposes/${purpose}`,
      {
        headers: {
          'Authorization': `Bearer ${accessToken}`,
          'Content-Type': 'application/json'
        },
        timeout: 5000
      }
    );

    return response.data.status === 'ACTIVE';
  } catch (error) {
    if (error.response?.status === 404) {
      return false; // No consent found
    }
    console.error('Consent verification error:', error.message);
    throw new Error('Unable to verify user consent');
  }
}

// Middleware to validate JWT and check OneTrust consent
async function authenticateWithConsent(requiredPurpose) {
  return async (req, res, next) => {
    try {
      const authHeader = req.headers.authorization;
      
      if (!authHeader || !authHeader.startsWith('Bearer ')) {
        return res.status(401).json({ error: 'Missing or invalid authorization header' });
      }

      const token = authHeader.substring(7);
      const decoded = jwt.verify(token, JWT_SECRET);
      const userId = decoded.userId;

      // Verify user consent in OneTrust
      const hasConsent = await verifyUserConsent(userId, requiredPurpose);
      
      if (!hasConsent) {
        return res.status(403).json({ 
          error: 'User consent required',
          consentPurpose: requiredPurpose,
          message: 'Please provide consent to access this resource'
        });
      }

      req.user = { userId, ...decoded };
      next();
    } catch (error) {
      if (error.name === 'JsonWebTokenError') {
        return res.status(401).json({ error: 'Invalid token' });
      }
      if (error.name === 'TokenExpiredError') {
        return res.status(401).json({ error: 'Token expired' });
      }
      console.error('Authentication error:', error.message);
      return res.status(500).json({ error: 'Authentication failed' });
    }
  };
}

// Protected endpoint requiring marketing consent
app.get('/api/user/preferences', 
  authenticateWithConsent('MARKETING_COMMUNICATIONS'),
  async (req, res) => {
    try {
      // Business logic here
      res.json({ 
        userId: req.user.userId,
        preferences: { emailNotifications: true }
      });
    } catch (error) {
      res.status(500).json({ error: 'Internal server error' });
    }
  }
);

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => console.log(`Server running on port ${PORT}`));