Secure Data Deletion

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

// Cryptographic Erasure Service
// Enables instant, verifiable data deletion through key destruction
 
interface UserEncryptionContext {
  userId: string;
  dekId: string;           // Data Encryption Key ID
  kekVersion: number;      // Key Encryption Key version
  createdAt: Date;
}
 
class CryptographicErasureService {
  private kms: KeyManagementService;
  private keyStore: EncryptionKeyRepository;
  private auditLogger: DeletionAuditLogger;
 
  async eraseUserData(userId: string): Promise<ErasureResult> {
    // Get user's encryption context
    const context = await this.keyStore.getUserContext(userId);
    
    if (!context) {
      return { success: false, reason: 'no_encryption_context' };
    }
 
    // Step 1: Disable the DEK (prevent new encryptions/decryptions)
    await this.kms.disableKey(context.dekId);
 
    // Step 2: Schedule permanent key deletion
    const deletionSchedule = await this.kms.scheduleKeyDeletion(
      context.dekId,
      { waitPeriodDays: 7 }  // Mandatory waiting period for recovery
    );
 
    // Step 3: Log the erasure action
    await this.auditLogger.logCryptoErasure({
      userId,
      dekId: context.dekId,
      scheduledDeletionDate: deletionSchedule.deletionDate,
      timestamp: new Date(),
    });
 
    return {
      success: true,
      dekId: context.dekId,
      status: 'scheduled',
      permanentDeletionDate: deletionSchedule.deletionDate,
    };
  }
 
  async confirmKeyDestruction(dekId: string): Promise<boolean> {
    // Verify key is truly deleted from KMS
    const keyStatus = await this.kms.getKeyStatus(dekId);
    
    if (keyStatus.state !== 'DESTROYED') {
      return false;
    }
 
    // Verify key is not recoverable from KMS backups
    const recoverability = await this.kms.checkKeyRecoverability(dekId);
    
    return !recoverability.isRecoverable;
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

// Database Secure Deletion Service
// Ensures complete removal from all database structures
 
class DatabaseSecureDeletionService {
  private db: DatabaseConnection;
  private auditLogger: DeletionAuditLogger;
 
  async secureDeleteRecord(
    table: string,
    recordId: string
  ): Promise<SecureDeletionResult> {
    const result: SecureDeletionResult = {
      recordId,
      table,
      steps: [],
    };
 
    // Step 1: Delete from main table
    await this.db.query(
      `DELETE FROM ${table} WHERE id = $1`,
      [recordId]
    );
    result.steps.push({ step: 'table_delete', success: true });
 
    // Step 2: Force VACUUM to reclaim space (PostgreSQL)
    await this.db.query(`VACUUM ${table}`);
    result.steps.push({ step: 'vacuum', success: true });
 
    // Step 3: Clear query cache
    await this.db.query('DISCARD ALL');
    result.steps.push({ step: 'cache_clear', success: true });
 
    // Step 4: Verify deletion
    const verifyResult = await this.db.query(
      `SELECT COUNT(*) FROM ${table} WHERE id = $1`,
      [recordId]
    );
    
    if (parseInt(verifyResult.rows[0].count) === 0) {
      result.steps.push({ step: 'verify', success: true });
    } else {
      result.steps.push({ 
        step: 'verify', 
        success: false, 
        error: 'Record still exists' 
      });
    }
 
    // Audit log
    await this.auditLogger.log({
      action: 'secure_delete',
      table,
      recordId,
      result,
      timestamp: new Date(),
    });
 
    return result;
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

// Deletion Certification Service
// Generates compliance-ready deletion certificates
 
interface DeletionCertificate {
  certificateId: string;
  recordId: string;
  dataSubjectId: string;
  deletionMethod: DeletionMethod;
  deletedAt: Date;
  verifiedAt: Date;
  systemsChecked: SystemVerification[];
  cryptoErasureDetails?: CryptoErasureDetails;
  signedBy: string;
  signature: string;
}
 
class DeletionCertificationService {
  private verificationService: DeletionVerificationService;
  private cryptoService: CryptographicService;
  private certificateStore: CertificateRepository;
 
  async generateCertificate(
    deletionRequest: DeletionRequest
  ): Promise<DeletionCertificate> {
    // Verify deletion across all systems
    const verification = await this.verificationService
      .verifyCompleteDeletion(deletionRequest.recordId);
 
    if (!verification.isComplete) {
      throw new VerificationFailedError(
        'Cannot certify: deletion incomplete',
        verification.failedSystems
      );
    }
 
    // Build certificate
    const certificate: DeletionCertificate = {
      certificateId: generateSecureId(),
      recordId: deletionRequest.recordId,
      dataSubjectId: deletionRequest.dataSubjectId,
      deletionMethod: deletionRequest.method,
      deletedAt: deletionRequest.deletedAt,
      verifiedAt: new Date(),
      systemsChecked: verification.systemResults,
      signedBy: 'deletion-certification-service',
      signature: '', // Will be signed below
    };
 
    // Add crypto erasure details if applicable
    if (deletionRequest.method === 'cryptographic_erasure') {
      certificate.cryptoErasureDetails = {
        keyId: deletionRequest.dekId,
        keyDestroyedAt: deletionRequest.keyDestructionDate,
        kmsConfirmation: verification.kmsConfirmation,
      };
    }
 
    // Digitally sign the certificate
    certificate.signature = await this.cryptoService.sign(
      JSON.stringify(certificate),
      'deletion-cert-signing-key'
    );
 
    // Store certificate immutably
    await this.certificateStore.store(certificate);
 
    return certificate;
  }
 
  async getCertificate(
    certificateId: string
  ): Promise<DeletionCertificate | null> {
    const cert = await this.certificateStore.get(certificateId);
    
    if (cert) {
      // Verify signature on retrieval
      const isValid = await this.cryptoService.verify(
        JSON.stringify({ ...cert, signature: '' }),
        cert.signature,
        'deletion-cert-signing-key'
      );
      
      if (!isValid) {
        throw new CertificateTamperedError(certificateId);
      }
    }
    
    return cert;
  }
}