Comprehensive comparison for Authentication technology in Software Development applications

// Drata Integration for Software Development Authentication
// This example demonstrates integrating Drata's compliance monitoring
// with a Node.js authentication system

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

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

// Drata API Configuration
const DRATA_API_KEY = process.env.DRATA_API_KEY;
const DRATA_API_URL = 'https://api.drata.com/v1';
const JWT_SECRET = process.env.JWT_SECRET;

// Drata Event Logger for Compliance Tracking
class DrataComplianceLogger {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.headers = {
      'Authorization': `Bearer ${apiKey}`,
      'Content-Type': 'application/json'
    };
  }

  async logAuthenticationEvent(eventData) {
    try {
      const payload = {
        event_type: 'authentication',
        timestamp: new Date().toISOString(),
        user_id: eventData.userId,
        ip_address: eventData.ipAddress,
        success: eventData.success,
        method: eventData.method,
        metadata: eventData.metadata
      };

      await axios.post(
        `${DRATA_API_URL}/events`,
        payload,
        { headers: this.headers }
      );
    } catch (error) {
      console.error('Failed to log to Drata:', error.message);
      // Don't fail authentication if logging fails
    }
  }

  async logAccessControl(userId, resource, action, granted) {
    try {
      await axios.post(
        `${DRATA_API_URL}/access-logs`,
        {
          user_id: userId,
          resource: resource,
          action: action,
          granted: granted,
          timestamp: new Date().toISOString()
        },
        { headers: this.headers }
      );
    } catch (error) {
      console.error('Failed to log access control:', error.message);
    }
  }
}

const drataLogger = new DrataComplianceLogger(DRATA_API_KEY);

// Authentication Middleware with Drata Integration
const authenticateWithDrata = async (req, res, next) => {
  const token = req.headers.authorization?.split(' ')[1];
  const ipAddress = req.ip || req.connection.remoteAddress;

  if (!token) {
    await drataLogger.logAuthenticationEvent({
      userId: 'unknown',
      ipAddress: ipAddress,
      success: false,
      method: 'jwt',
      metadata: { reason: 'missing_token' }
    });
    return res.status(401).json({ error: 'No token provided' });
  }

  try {
    const decoded = jwt.verify(token, JWT_SECRET);
    req.user = decoded;

    // Log successful authentication to Drata
    await drataLogger.logAuthenticationEvent({
      userId: decoded.userId,
      ipAddress: ipAddress,
      success: true,
      method: 'jwt',
      metadata: {
        roles: decoded.roles,
        session_id: decoded.sessionId
      }
    });

    next();
  } catch (error) {
    await drataLogger.logAuthenticationEvent({
      userId: 'unknown',
      ipAddress: ipAddress,
      success: false,
      method: 'jwt',
      metadata: {
        reason: error.name,
        message: error.message
      }
    });
    return res.status(401).json({ error: 'Invalid token' });
  }
};

// Login Endpoint with Drata Compliance Logging
app.post('/api/auth/login', async (req, res) => {
  const { email, password } = req.body;
  const ipAddress = req.ip || req.connection.remoteAddress;

  try {
    // Simulated user validation (replace with actual DB lookup)
    const user = await validateUserCredentials(email, password);

    if (!user) {
      await drataLogger.logAuthenticationEvent({
        userId: email,
        ipAddress: ipAddress,
        success: false,
        method: 'password',
        metadata: { reason: 'invalid_credentials' }
      });
      return res.status(401).json({ error: 'Invalid credentials' });
    }

    const sessionId = crypto.randomBytes(32).toString('hex');
    const token = jwt.sign(
      {
        userId: user.id,
        email: user.email,
        roles: user.roles,
        sessionId: sessionId
      },
      JWT_SECRET,
      { expiresIn: '8h' }
    );

    // Log successful login to Drata
    await drataLogger.logAuthenticationEvent({
      userId: user.id,
      ipAddress: ipAddress,
      success: true,
      method: 'password',
      metadata: {
        session_id: sessionId,
        mfa_enabled: user.mfaEnabled
      }
    });

    res.json({ token, user: { id: user.id, email: user.email } });
  } catch (error) {
    console.error('Login error:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
});

// Protected Resource with Access Control Logging
app.get('/api/sensitive-data', authenticateWithDrata, async (req, res) => {
  const hasPermission = req.user.roles.includes('admin');

  // Log access attempt to Drata
  await drataLogger.logAccessControl(
    req.user.userId,
    '/api/sensitive-data',
    'read',
    hasPermission
  );

  if (!hasPermission) {
    return res.status(403).json({ error: 'Insufficient permissions' });
  }

  res.json({ data: 'Sensitive information' });
});

// Mock function - replace with actual implementation
async function validateUserCredentials(email, password) {
  // Simulated user lookup and password verification
  return {
    id: '12345',
    email: email,
    roles: ['user', 'admin'],
    mfaEnabled: true
  };
}

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