API Key Reference

 
// encryption-service.js
require('dotenv').config();
const axios = require('axios');

class EncryptionService {
  constructor() {
    this.baseURL = process.env.API_BASE_URL || 'https://your-api-domain.com/api/v1/crypto';
    this.projectId = process.env.PROJECT_ID;
    this.apiKey = process.env.API_KEY;
    this.passphrase = process.env.PASSPHRASE;
    this.validateConfig();
  }
  
  validateConfig() {
    if (!this.projectId || !this.apiKey || !this.passphrase) {
      throw new Error('Missing required environment variables: PROJECT_ID, API_KEY, PASSPHRASE');
    }
  }
  
  async encrypt(data) {
    try {
      const response = await this.makeRequest('/encrypt', { data });
      return response.data.encrypted_output;
    } catch (error) {
      throw this.handleError('Encryption', error);
    }
  }
  
  async decrypt(encryptedData) {
    try {
      const response = await this.makeRequest('/decrypt', { data: encryptedData });
      return response.data.plaintext;
    } catch (error) {
      throw this.handleError('Decryption', error);
    }
  }
  
  async deepEncrypt(dataObject) {
    try {
      const response = await this.makeRequest('/deep_encrypt', { data: dataObject });
      return { encrypted: response.data.encrypted, meta: response.data.meta };
    } catch (error) {
      throw this.handleError('Deep Encryption', error);
    }
  }
  
  async deepDecrypt(encryptedObject) {
    try {
      const response = await this.makeRequest('/deep_decrypt', { encrypted: encryptedObject });
      return { data: response.data.data, meta: response.data.meta };
    } catch (error) {
      throw this.handleError('Deep Decryption', error);
    }
  }
  
  async makeRequest(endpoint, payload) {
    const response = await axios.post(
      `${this.baseURL}${endpoint}/${this.projectId}`,
      { ...payload, passphrase: this.passphrase },
      {
        headers: {
          'x-api-key': this.apiKey,
          'Content-Type': 'application/json'
        }
      }
    );
    return response.data;
  }
  
  handleError(operation, error) {
    const errorInfo = {
      operation,
      status: error.response?.status,
      message: error.response?.data?.message || error.message,
      details: error.response?.data
    };
    console.error(`${operation} failed:`, errorInfo);
    return new Error(`${operation} failed: ${errorInfo.message} (Status: ${errorInfo.status})`);
  }
}

module.exports = EncryptionService;

// app.js - Usage in Express application
const express = require('express');
const EncryptionService = require('./encryption-service');
const app = express();
app.use(express.json());
const encryptionService = new EncryptionService();

// Endpoint to encrypt user data
app.post('/api/user/create', async (req, res) => {
  try {
    const { username, email, ssn, creditCard } = req.body;
    
    // Deep encrypt sensitive user data
    const sensitiveData = {
      personal: {
        ssn,
        email
      },
      payment: {
        creditCard
      }
    };

const { encrypted, meta } = await encryptionService.deepEncrypt(sensitiveData);
    
    // Store encrypted data in database (pseudocode)
    // await database.users.create({
    //   username,
    //   encryptedData: encrypted,
    //   encryptionMeta: meta
    // });
    
    res.json({
      success: true,
      message: 'User created successfully',
      meta
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: error.message
    });
  }
});


// Endpoint to retrieve and decrypt user data
app.get('/api/user/:id', async (req, res) => {
  try {
    // Retrieve encrypted data from database (pseudocode)
    // const user = await database.users.findById(req.params.id);
    
    const encryptedData = {
      /* encrypted data from database */
    };
    
    const { data, meta } = await encryptionService.deepDecrypt(encryptedData);
    
    res.json({
      success: true,
      data,
      meta
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: error.message
    });
  }
});

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