Confidential AI Network Documentation
# Decentralized KMS Architecture for Multi-Tenant Requirements
Version: 1.0.0 Last Updated: December 2024 Status: Production Ready## 🎯 Overview
This document explains how decentralized Key Management System (KMS) works in our multi-tenant Contract Management System, where each tenant (TDP, TDC, CCRP) has their own KMS provider rather than a centralized approach.## ❌ Problems with Centralized KMS
A centralized KMS approach would create several critical issues:### Security Concerns
### Operational Issues
## ✅ Our Decentralized KMS Solution
Each tenant (TDP, TDC, CCRP) has their own KMS provider based on their infrastructure and compliance requirements.### Tenant-Specific KMS Configurations
// Each tenant has their own KMS configuration
const tenantKMSConfigs = {
"tdp-acme-healthcare": {
cloudProvider: "AWS",
kmsProvider: "AWS_KMS",
region: "us-east-1",
keyPrefix: "tdp-acme-healthcare",
vaultUrl: "https://acme-healthcare-kv.vault.aws.amazon.com/",
complianceStandards: ["HIPAA", "SOC2", "ISO27001"],
encryptionAlgorithm: "AES_256_GCM",
keyRotationPolicy: {
automaticRotation: true,
rotationPeriod: "30_DAYS"
}
},
"tdc-ai-research": {
cloudProvider: "AZURE",
kmsProvider: "AZURE_KEY_VAULT",
region: "eastus",
keyPrefix: "tdc-ai-research",
vaultUrl: "https://ai-research-kv.vault.azure.net/",
complianceStandards: ["GDPR", "ISO27001"],
encryptionAlgorithm: "AES_256_GCM",
keyRotationPolicy: {
automaticRotation: true,
rotationPeriod: "90_DAYS"
}
},
"ccrp-secure-analytics": {
cloudProvider: "MULTI_CLOUD",
kmsProviders: ["AWS_KMS", "AZURE_KEY_VAULT", "GCP_KMS"],
regions: ["us-east-1", "eastus", "us-central1"],
keyPrefix: "ccrp-secure-analytics",
complianceStandards: ["DPDP_2023", "GDPR", "HIPAA", "SOC2"],
encryptionAlgorithm: "AES_256_GCM",
crossCloudOrchestration: true,
keyRotationPolicy: {
automaticRotation: true,
rotationPeriod: "60_DAYS"
}
}
};
## 🔐 Decentralized KMS Implementation
### 1. Tenant-Specific Key Management
// Each tenant manages their own keys
class TenantKMSManager {
constructor(tenantId) {
this.tenantId = tenantId;
this.config = tenantKMSConfigs[tenantId];
this.kmsAdapter = this.createKMSAdapter();
}
createKMSAdapter() {
switch(this.config.kmsProvider) {
case 'AWS_KMS':
return new AWSKMSAdapter(this.config);
case 'AZURE_KEY_VAULT':
return new AzureKeyVaultAdapter(this.config);
case 'GCP_KMS':
return new GCPKMSAdapter(this.config);
default:
throw new Error(Unsupported KMS provider: ${this.config.kmsProvider});
}
}
async createKey(keyType, metadata) {
const keyId = ${this.config.keyPrefix}-${keyType}-${Date.now()};
return await this.kmsAdapter.createKey({
keyId,
algorithm: this.config.encryptionAlgorithm,
purpose: keyType,
metadata: {
...metadata,
tenantId: this.tenantId,
createdAt: new Date().toISOString(),
complianceStandards: this.config.complianceStandards
}
});
}
async encrypt(data, keyId) {
return await this.kmsAdapter.encrypt({
keyId,
data,
algorithm: this.config.encryptionAlgorithm
});
}
async decrypt(encryptedData, keyId) {
return await this.kmsAdapter.decrypt({
keyId,
encryptedData: encryptedData.ciphertext,
iv: encryptedData.iv
});
}
async rotateKey(keyId) {
return await this.kmsAdapter.rotateKey({
keyId,
rotationPolicy: this.config.keyRotationPolicy
});
}
async getKeyMetadata(keyId) {
return await this.kmsAdapter.getKeyMetadata(keyId);
}
}
### 2. Cross-Tenant Key Coordination
// Coordinate keys across different tenant KMS providers
class CrossTenantKMSCoordinator {
constructor() {
this.tenantManagers = new Map();
this.keyMappings = new Map();
}
async getTenantManager(tenantId) {
if (!this.tenantManagers.has(tenantId)) {
this.tenantManagers.set(tenantId, new TenantKMSManager(tenantId));
}
return this.tenantManagers.get(tenantId);
}
// Encrypt data in TDP's KMS, transfer to TDC's KMS
async encryptForCrossTenantTransfer(data, sourceTenantId, targetTenantId) {
const sourceManager = await this.getTenantManager(sourceTenantId);
const targetManager = await this.getTenantManager(targetTenantId);
// 1. Create encryption key in source tenant's KMS
const sourceKeyId = await sourceManager.createKey('DATA_ENCRYPTION', {
purpose: 'cross-tenant-transfer',
targetTenantId,
transferProtocol: 'CROSS_TENANT_ENCRYPTED'
});
// 2. Encrypt data using source tenant's KMS
const encryptedData = await sourceManager.encrypt(data, sourceKeyId);
// 3. Create corresponding key in target tenant's KMS
const targetKeyId = await targetManager.createKey('DATA_DECRYPTION', {
purpose: 'cross-tenant-transfer',
sourceTenantId,
sourceKeyId,
transferProtocol: 'CROSS_TENANT_ENCRYPTED'
});
// 4. Set up key mapping for cross-tenant decryption
await this.setupKeyMapping(sourceKeyId, targetKeyId, sourceTenantId, targetTenantId);
return {
encryptedData,
sourceKeyId,
targetKeyId,
transferProtocol: 'CROSS_TENANT_ENCRYPTED',
timestamp: new Date().toISOString()
};
}
// Decrypt data using target tenant's KMS
async decryptCrossTenantData(encryptedData, targetTenantId, sourceKeyId) {
const targetManager = await this.getTenantManager(targetTenantId);
// Get the corresponding key in target tenant's KMS
const targetKeyId = await this.getMappedKey(sourceKeyId, targetTenantId);
return await targetManager.decrypt(encryptedData, targetKeyId);
}
async setupKeyMapping(sourceKeyId, targetKeyId, sourceTenantId, targetTenantId) {
const mappingKey = ${sourceTenantId}:${sourceKeyId}:${targetTenantId};
this.keyMappings.set(mappingKey, {
sourceKeyId,
targetKeyId,
sourceTenantId,
targetTenantId,
createdAt: new Date().toISOString()
});
}
async getMappedKey(sourceKeyId, targetTenantId) {
// Find the mapping for this source key and target tenant
for (const [key, mapping] of this.keyMappings.entries()) {
if (mapping.sourceKeyId === sourceKeyId && mapping.targetTenantId === targetTenantId) {
return mapping.targetKeyId;
}
}
throw new Error(No key mapping found for sourceKeyId: ${sourceKeyId}, targetTenantId: ${targetTenantId});
}
}
### 3. Multi-Cloud KMS for CCRP
// CCRP manages multiple KMS providers for cross-cloud operations
class CCRPMultiCloudKMS {
constructor(ccrpTenantId) {
this.tenantId = ccrpTenantId;
this.config = tenantKMSConfigs[ccrpTenantId];
this.kmsAdapters = this.createMultiCloudAdapters();
}
createMultiCloudAdapters() {
const adapters = {};
for (const provider of this.config.kmsProviders) {
switch(provider) {
case 'AWS_KMS':
adapters.aws = new AWSKMSAdapter({
...this.config,
region: 'us-east-1',
keyPrefix: ${this.config.keyPrefix}-aws
});
break;
case 'AZURE_KEY_VAULT':
adapters.azure = new AzureKeyVaultAdapter({
...this.config,
region: 'eastus',
keyPrefix: ${this.config.keyPrefix}-azure
});
break;
case 'GCP_KMS':
adapters.gcp = new GCPKMSAdapter({
...this.config,
region: 'us-central1',
keyPrefix: ${this.config.keyPrefix}-gcp
});
break;
}
}
return adapters;
}
// Create keys across multiple clouds for redundancy
async createMultiCloudKey(keyType, metadata) {
const keyIds = {};
for (const [cloud, adapter] of Object.entries(this.kmsAdapters)) {
const keyId = ${this.config.keyPrefix}-${keyType}-${cloud}-${Date.now()};
keyIds[cloud] = await adapter.createKey({
keyId,
algorithm: this.config.encryptionAlgorithm,
purpose: keyType,
metadata: {
...metadata,
tenantId: this.tenantId,
cloud,
createdAt: new Date().toISOString(),
multiCloud: true
}
});
}
return keyIds;
}
// Encrypt data with multi-cloud redundancy
async encryptMultiCloud(data, keyIds) {
const encryptedResults = {};
for (const [cloud, keyId] of Object.entries(keyIds)) {
encryptedResults[cloud] = await this.kmsAdapters[cloud].encrypt({
keyId,
data,
algorithm: this.config.encryptionAlgorithm
});
}
return encryptedResults;
}
// Decrypt data from any cloud provider
async decryptMultiCloud(encryptedData, cloud, keyId) {
return await this.kmsAdapters[cloud].decrypt({
keyId,
encryptedData: encryptedData.ciphertext,
iv: encryptedData.iv
});
}
// Cross-cloud key synchronization
async syncKeysAcrossClouds(keyType, metadata) {
const syncResults = {};
for (const [cloud, adapter] of Object.entries(this.kmsAdapters)) {
syncResults[cloud] = await adapter.syncKey({
keyType,
metadata: {
...metadata,
cloud,
crossCloudSync: true
}
});
}
return syncResults;
}
}
### 4. Cross-Cloud Key Coordination
// Handle key coordination across different cloud providers
class CrossCloudKeyCoordinator {
constructor() {
this.tenantManagers = new Map();
this.cloudMappings = new Map();
}
async coordinateKeys(sourceKeyId, sourceTenantId, targetTenantId) {
// 1. Get source tenant's key metadata
const sourceKeyMetadata = await this.getKeyMetadata(sourceKeyId, sourceTenantId);
// 2. Create corresponding key in target tenant's KMS
const targetKeyId = await this.createCorrespondingKey(sourceKeyMetadata, targetTenantId);
// 3. Set up key mapping for cross-cloud operations
await this.setupCloudKeyMapping(sourceKeyId, targetKeyId, sourceTenantId, targetTenantId);
return targetKeyId;
}
async getKeyMetadata(keyId, tenantId) {
const tenantManager = await this.getTenantManager(tenantId);
return await tenantManager.kmsAdapter.getKeyMetadata(keyId);
}
async createCorrespondingKey(sourceMetadata, targetTenantId) {
const targetManager = await this.getTenantManager(targetTenantId);
return await targetManager.createKey(sourceMetadata.purpose, {
...sourceMetadata,
sourceKeyId: sourceMetadata.keyId,
crossCloudMapping: true,
originalTenantId: sourceMetadata.tenantId
});
}
async setupCloudKeyMapping(sourceKeyId, targetKeyId, sourceTenantId, targetTenantId) {
const mappingKey = ${sourceTenantId}:${sourceKeyId}:${targetTenantId};
this.cloudMappings.set(mappingKey, {
sourceKeyId,
targetKeyId,
sourceTenantId,
targetTenantId,
crossCloud: true,
createdAt: new Date().toISOString()
});
}
async getCloudMappedKey(sourceKeyId, targetTenantId) {
for (const [key, mapping] of this.cloudMappings.entries()) {
if (mapping.sourceKeyId === sourceKeyId && mapping.targetTenantId === targetTenantId) {
return mapping.targetKeyId;
}
}
throw new Error(No cloud key mapping found for sourceKeyId: ${sourceKeyId}, targetTenantId: ${targetTenantId});
}
}
## 🔄 Real-World Workflow Example
// Complete multi-tenant KMS workflow
const multiTenantKMSWorkflow = async (contractId) => {
const contract = await getContract(contractId);
const coordinator = new CrossTenantKMSCoordinator();
const cloudCoordinator = new CrossCloudKeyCoordinator();
console.log('🚀 Starting Multi-Tenant KMS Workflow');
// 1. TDP creates dataset encryption key in their AWS KMS
console.log('📦 TDP creating dataset encryption key...');
const tdpManager = await coordinator.getTenantManager('tdp-acme-healthcare');
const datasetKeyId = await tdpManager.createKey('DATASET_ENCRYPTION', {
datasetId: contract.dataset.id,
contractId,
purpose: 'cross-tenant-training'
});
// 2. TDP encrypts dataset using their AWS KMS
console.log('🔐 TDP encrypting dataset...');
const encryptedDataset = await tdpManager.encrypt(contract.dataset, datasetKeyId);
// 3. Cross-tenant transfer: TDP → CCRP
console.log('🔄 Transferring from TDP to CCRP...');
const tdpToCcrpTransfer = await coordinator.encryptForCrossTenantTransfer(
encryptedDataset,
'tdp-acme-healthcare',
'ccrp-secure-analytics'
);
// 4. CCRP decrypts using their multi-cloud KMS
console.log('🔓 CCRP decrypting with multi-cloud KMS...');
const ccrpManager = new CCRPMultiCloudKMS('ccrp-secure-analytics');
const decryptedDataset = await coordinator.decryptCrossTenantData(
tdpToCcrpTransfer.encryptedData,
'ccrp-secure-analytics',
tdpToCcrpTransfer.sourceKeyId
);
// 5. CCRP re-encrypts for TDC using their Azure KMS
console.log('🔄 Transferring from CCRP to TDC...');
const ccrpToTdcTransfer = await coordinator.encryptForCrossTenantTransfer(
decryptedDataset,
'ccrp-secure-analytics',
'tdc-ai-research'
);
// 6. TDC decrypts using their Azure Key Vault
console.log('🔓 TDC decrypting with Azure Key Vault...');
const tdcManager = await coordinator.getTenantManager('tdc-ai-research');
const finalDataset = await coordinator.decryptCrossTenantData(
ccrpToTdcTransfer.encryptedData,
'tdc-ai-research',
ccrpToTdcTransfer.sourceKeyId
);
console.log('✅ Multi-Tenant KMS Workflow Completed');
return {
workflow: 'MULTI_TENANT_KMS_TRANSFER',
steps: [
'TDP_AWS_KMS_ENCRYPTION',
'TDP_TO_CCRP_TRANSFER',
'CCRP_MULTI_CLOUD_DECRYPTION',
'CCRP_TO_TDC_TRANSFER',
'TDC_AZURE_DECRYPTION'
],
finalDataset,
auditTrail: {
tdpEncryption: {
tenantId: 'tdp-acme-healthcare',
keyId: datasetKeyId,
timestamp: new Date().toISOString()
},
crossTenantTransfers: [
tdpToCcrpTransfer,
ccrpToTdcTransfer
],
finalDecryption: {
tenantId: 'tdc-ai-research',
timestamp: new Date().toISOString()
}
}
};
};
## 🎯 Key Benefits of Decentralized KMS
### 1. Tenant Autonomy
### 2. Security Isolation
### 3. Compliance Flexibility
### 4. Vendor Choice
### 5. Performance
### 6. Scalability
## 🔒 Security Features
### Key Rotation
// Automatic key rotation per tenant
const keyRotationWorkflow = async (tenantId) => {
const manager = await getTenantManager(tenantId);
const config = tenantKMSConfigs[tenantId];
if (config.keyRotationPolicy.automaticRotation) {
await manager.rotateKey(keyId);
}
};
### Audit Trail
// Comprehensive audit trail for compliance
const auditTrail = {
keyOperations: [
{
operation: 'CREATE_KEY',
tenantId: 'tdp-acme-healthcare',
keyId: 'tdp-acme-healthcare-dataset-001',
timestamp: '2024-12-15T10:30:00.000Z',
complianceStandards: ['HIPAA', 'SOC2']
},
{
operation: 'CROSS_TENANT_TRANSFER',
sourceTenant: 'tdp-acme-healthcare',
targetTenant: 'ccrp-secure-analytics',
timestamp: '2024-12-15T10:35:00.000Z',
transferProtocol: 'CROSS_TENANT_ENCRYPTED'
}
]
};
### Compliance Verification
// Verify compliance across all tenants
const verifyCompliance = async (contractId) => {
const contract = await getContract(contractId);
const complianceResults = {};
for (const tenantId of Object.keys(contract.parties)) {
const manager = await getTenantManager(tenantId);
const config = tenantKMSConfigs[tenantId];
complianceResults[tenantId] = {
complianceStandards: config.complianceStandards,
keyManagement: await manager.verifyCompliance(),
auditTrail: await manager.getAuditTrail()
};
}
return complianceResults;
};
## 📊 Performance Metrics
### Key Management Performance
### Scalability Metrics
## 🚀 Conclusion
The decentralized KMS architecture ensures that each tenant maintains complete control over their cryptographic keys while enabling secure cross-tenant and cross-cloud operations through coordinated key management. This approach provides the security, compliance, and scalability required for enterprise multi-tenant AI training environments.
Status: Production Ready Compliance: DPDP 2023, GDPR, HIPAA, SOC2, ISO27001 Security: End-to-end encryption with tenant isolation Scalability: Multi-cloud, multi-tenant architecture