Walse

Posted on Mar 25 • Originally published at apidog.com

Cara Membuat API Sesuai HIPAA di 2026 untuk Aplikasi Kesehatan Aman

Inti Masalah (TL;DR)

Kepatuhan HIPAA untuk API mengharuskan kontrol keamanan ketat terhadap Informasi Kesehatan yang Dilindungi (PHI), seperti enkripsi saat transit dan saat disimpan, pencatatan audit, kontrol akses, serta perjanjian rekan bisnis. Artikel ini memandu pola arsitektur API, autentikasi, implementasi jejak audit, dan verifikasi kepatuhan untuk aplikasi kesehatan yang menangani PHI.

Coba Apidog sekarang

Pendahuluan

Pelanggaran data pada sektor kesehatan rata-rata merugikan $10,93 juta per insiden. Untuk developer yang membangun aplikasi kesehatan, keamanan API adalah kewajiban hukum sesuai HIPAA (Health Insurance Portability and Accountability Act).

79% pelanggaran data kesehatan terjadi akibat akses tidak sah melalui API dan celah aplikasi. Arsitektur API yang benar dan patuh HIPAA mencegah pelanggaran, memungkinkan jejak audit, dan melindungi privasi pasien.

Panduan ini membahas proses kepatuhan API HIPAA secara end-to-end: penanganan PHI, standar enkripsi, kontrol akses, pencatatan audit, dan dokumentasi. Tujuan akhirnya adalah memiliki arsitektur API siap produksi dan sesuai HIPAA.

💡 Desain endpoint yang aman, validasi enkripsi, audit pola akses, dan dokumentasikan kontrol kepatuhan secara terpusat di Apidog. Bagikan spesifikasi API dengan tim kepatuhan dan pertahankan dokumentasi siap audit.

Apa Itu HIPAA dan Mengapa Penting untuk API?

HIPAA adalah undang-undang federal yang menetapkan standar nasional perlindungan informasi kesehatan pasien. Aturan Keamanan HIPAA mengatur ePHI yang ditransmisikan melalui API.

Siapa yang Harus Mematuhi

Jenis Entitas	Contoh	Implikasi API
Entitas Tercakup	Penyedia layanan, rencana kesehatan	Kewajiban HIPAA
Rekan Bisnis	Penyedia API, cloud, vendor software	BAA wajib, kewajiban
Subkontraktor	Subprosesor, layanan API bawahan	BAA wajib

Aturan HIPAA Utama untuk API

Aturan Privasi: Penggunaan dan pengungkapan PHI

Standar minimum yang diperlukan
Hak akses pasien
Persyaratan otorisasi

Aturan Keamanan: Pengamanan teknis untuk ePHI

Kontrol akses
Kontrol audit
Integritas
Keamanan transmisi

Aturan Pemberitahuan Pelanggaran: Respons insiden

Notifikasi maksimal 60 hari
Dokumentasi risiko
Prosedur mitigasi

Ikhtisar Arsitektur API

┌─────────────────────────────────────────────────────────────────┐
│                    HIPAA-COMPLIANT API STACK                   │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌───────────┐   ┌────────────┐   ┌──────────────┐             │
│  │  KLIEN    │──▶│   API      │──▶│   DATABASE   │             │
│  │(Aplikasi) │   │  Gateway   │   │ (Terenkripsi)│             │
│  └───────────┘   └────────────┘   └──────────────┘             │
│        │                │                 │                    │
│        ▼                ▼                 ▼                    │
│  ┌───────────┐   ┌────────────┐   ┌──────────────┐             │
│  │ OAuth2+MFA│   │  WAF+      │   │   Audit      │             │
│  │           │   │ Pembatasan │   │   Logging    │             │
│  └───────────┘   └────────────┘   └──────────────┘             │
│                                                                 │
│ Semua data terenkripsi: TLS 1.3+ saat transit, AES-256 saat disimpan │
└─────────────────────────────────────────────────────────────────┘

Memulai: Fondasi Kepatuhan

Langkah 1: Laksanakan Perjanjian Rekan Bisnis (BAA)

Sebelum menangani PHI:

Identifikasi semua vendor yang mengakses PHI
Laksanakan BAA dengan setiap vendor
Dokumentasikan subprosesor di BAA
Tinjau tahunan dan update sesuai kebutuhan

Vendor penting yang wajib BAA:

Cloud hosting (AWS, GCP, Azure)
Penyedia database
Layanan logging
Penyedia backup
API gateway
Alat monitoring

JANGAN gunakan tanpa BAA:

Google Analytics standar
Layanan cloud gratis
Email pribadi
Slack non-kesehatan

Langkah 2: Klasifikasi Data

Klasifikasikan semua data yang ditangani API:

Jenis Data	Klasifikasi	Perlindungan
Nama pasien + Tanggal Lahir	PHI	Kontrol HIPAA penuh
Nomor rekam medis	PHI	Kontrol HIPAA penuh
Kode diagnosis (ICD-10)	PHI	Kontrol HIPAA penuh
Catatan perawatan	PHI	Kontrol HIPAA penuh
Waktu janji (tanpa ID pasien)	Bukan PHI	Kontrol standar
Data agregat, de-identifikasi	Bukan PHI	Kontrol standar

Langkah 3: Standar Minimum yang Diperlukan

Ekspose hanya data minimal yang dibutuhkan:

// BURUK: Mengembalikan semua data pasien
app.get('/api/patients/:id', async (req, res) => {
  const patient = await db.patients.findById(req.params.id);
  res.json(patient); // Semua data dikirim
});

// BAIK: Hanya bidang yang dibutuhkan
app.get('/api/patients/:id', async (req, res) => {
  const fields = req.query.fields?.split(',') || ['id', 'name'];
  const allowedFields = ['id', 'name', 'dateOfBirth'];
  const patient = await db.patients.findById(req.params.id);
  const filtered = Object.fromEntries(
    Object.entries(patient).filter(([key]) => allowedFields.includes(key))
  );
  res.json(filtered);
});

Implementasi Pengamanan Teknis

Kontrol Akses: Autentikasi

Gunakan autentikasi multifaktor (MFA):

const crypto = require('crypto');
const jwt = require('jsonwebtoken');
const bcrypt = require('bcrypt');

class HIPAAAuthService {
  async authenticate(username, password, mfaCode) {
    const user = await this.getUserByUsername(username);
    if (!user) throw new Error('Kredensial tidak valid');
    const validPassword = await bcrypt.compare(password, user.passwordHash);
    if (!validPassword) throw new Error('Kredensial tidak valid');
    const validMFA = this.verifyTOTP(user.mfaSecret, mfaCode);
    if (!validMFA) throw new Error('Kode MFA tidak valid');
    const token = jwt.sign(
      { sub: user.id, role: user.role, mfa_verified: true },
      process.env.JWT_SECRET,
      { expiresIn: '15m' }
    );
    await this.auditLog('AUTH_SUCCESS', { userId: user.id, ip: req.ip });
    return { token, expiresIn: 900 };
  }
  verifyTOTP(secret, token) {
    const period = 30;
    const digits = 6;
    const now = Math.floor(Date.now() / 1000);
    const counter = Math.floor(now / period);
    const buffer = Buffer.alloc(8);
    buffer.writeUInt32BE(0, 0);
    buffer.writeUInt32BE(counter, 4);
    const hmac = crypto.createHmac('sha1', secret).update(buffer).digest();
    const offset = hmac[hmac.length - 1] & 0xf;
    const code = (
      ((hmac[offset] & 0x7f) << 24) |
      ((hmac[offset + 1] & 0xff) << 16) |
      ((hmac[offset + 2] & 0xff) << 8) |
      (hmac[offset + 3] & 0xff)
    ) % Math.pow(10, digits);
    return code.toString().padStart(digits, '0') === token;
  }
}

Kontrol Akses: Otorisasi

Implementasi RBAC:

const ROLES = {
  ADMIN: 'admin',
  PROVIDER: 'provider',
  NURSE: 'nurse',
  BILLING: 'billing',
  PATIENT: 'patient'
};
const PERMISSIONS = {
  [ROLES.ADMIN]: ['read:all', 'write:all', 'delete:all'],
  [ROLES.PROVIDER]: ['read:patients', 'write:patients', 'read:labs', 'write:orders'],
  [ROLES.NURSE]: ['read:patients', 'write:vitals', 'read:labs'],
  [ROLES.BILLING]: ['read:billing', 'read:patients:limited'],
  [ROLES.PATIENT]: ['read:self', 'write:self']
};

const authorize = (...requiredPermissions) => {
  return async (req, res, next) => {
    const user = req.user;
    const userPermissions = PERMISSIONS[user.role] || [];
    const hasPermission = requiredPermissions.every(
      perm => userPermissions.includes(perm)
    );
    if (!hasPermission) {
      await auditLog('AUTHZ_DENIED', {
        userId: user.id,
        action: req.method,
        path: req.path,
        required: requiredPermissions
      });
      return res.status(403).json({ error: 'Izin tidak mencukupi' });
    }
    next();
  };
};

app.get('/api/patients/:id/records',
  authenticate,
  authorize('read:patients'),
  getPatientRecords
);

Enkripsi Saat Transit

Terapkan TLS 1.3:

const https = require('https');
const fs = require('fs');
const options = {
  key: fs.readFileSync('server-key.pem'),
  cert: fs.readFileSync('server-cert.pem'),
  ca: fs.readFileSync('ca-cert.pem'),
  minVersion: 'TLSv1.3',
  ciphers: [
    'TLS_AES_256_GCM_SHA384',
    'TLS_CHACHA20_POLY1305_SHA256',
    'TLS_AES_128_GCM_SHA256'
  ].join(':'),
  honorCipherOrder: true
};
const server = https.createServer(options, app);

app.use((req, res, next) => {
  if (!req.secure) {
    return res.redirect(`https://${req.headers.host}${req.url}`);
  }
  next();
});
app.use((req, res, next) => {
  res.setHeader(
    'Strict-Transport-Security',
    'max-age=31536000; includeSubDomains; preload'
  );
  next();
});

Enkripsi Saat Disimpan

Enkripsi PHI di storage:

const crypto = require('crypto');
class EncryptionService {
  constructor(key) {
    this.key = crypto.scryptSync(key, 'salt', 32);
    this.algorithm = 'aes-256-gcm';
  }
  encrypt(plaintext) {
    const iv = crypto.randomBytes(16);
    const cipher = crypto.createCipheriv(this.algorithm, this.key, iv);
    let encrypted = cipher.update(plaintext, 'utf8', 'hex');
    encrypted += cipher.final('hex');
    const authTag = cipher.getAuthTag().toString('hex');
    return {
      encryptedData: encrypted,
      iv: iv.toString('hex'),
      authTag: authTag
    };
  }
  decrypt(encryptedData, iv, authTag) {
    const decipher = crypto.createDecipheriv(
      this.algorithm,
      this.key,
      Buffer.from(iv, 'hex')
    );
    decipher.setAuthTag(Buffer.from(authTag, 'hex'));
    let decrypted = decipher.update(encryptedData, 'hex', 'utf8');
    decrypted += decipher.final('utf8');
    return decrypted;
  }
}

// Model DB dengan enkripsi
class PatientRecord {
  constructor(db, encryptionService) {
    this.db = db;
    this.encryption = encryptionService;
  }
  async create(data) {
    const encryptedData = {
      ...data,
      ssn: this.encryption.encrypt(data.ssn),
      diagnosis: this.encryption.encrypt(data.diagnosis),
      treatmentNotes: this.encryption.encrypt(data.treatmentNotes)
    };
    await this.db.patients.insert(encryptedData);
    await auditLog('PHI_CREATED', { recordType: 'patient' });
  }
  async findById(id) {
    const record = await this.db.patients.findById(id);
    return {
      ...record,
      ssn: this.encryption.decrypt(record.ssn.encryptedData, record.ssn.iv, record.ssn.authTag),
      diagnosis: this.encryption.decrypt(record.diagnosis.encryptedData, record.diagnosis.iv, record.diagnosis.authTag),
      treatmentNotes: this.encryption.decrypt(record.treatmentNotes.encryptedData, record.treatmentNotes.iv, record.treatmentNotes.authTag)
    };
  }
}

Implementasi Kontrol Audit

Pencatatan Audit Komprehensif

Catat semua akses PHI:

const winston = require('winston');
const auditLogger = winston.createLogger({
  level: 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json()
  ),
  transports: [
    new winston.transports.File({
      filename: '/var/log/hipaa-audit/audit.log',
      maxsize: 52428800,
      maxFiles: 365
    }),
    new winston.transports.Http({
      host: 'siem.internal',
      path: '/api/logs',
      ssl: true
    })
  ]
});

const auditLog = async (event, details) => {
  const logEntry = {
    timestamp: new Date().toISOString(),
    event: event,
    actor: details.userId,
    action: details.action,
    resource: details.resource,
    outcome: details.outcome || 'SUCCESS',
    ipAddress: details.ip,
    userAgent: details.userAgent,
    details: details.metadata
  };
  auditLogger.info(logEntry);
  await db.auditLogs.insert(logEntry);
};

app.use((req, res, next) => {
  const start = Date.now();
  res.on('finish', async () => {
    const duration = Date.now() - start;
    if (req.path.includes('/patients') || req.path.includes('/records')) {
      await auditLog('API_ACCESS', {
        userId: req.user?.id || 'anonymous',
        action: req.method,
        resource: req.path,
        outcome: res.statusCode < 400 ? 'SUCCESS' : 'FAILURE',
        ip: req.ip,
        userAgent: req.headers['user-agent'],
        metadata: {
          duration: duration,
          statusCode: res.statusCode,
          queryParams: Object.keys(req.query)
        }
      });
    }
  });
  next();
});

Peristiwa Audit yang Diperlukan

Jenis Peristiwa	Dicatat	Retensi
Autentikasi	Sukses/gagal, status MFA, IP	6 tahun
Otorisasi	Upaya akses ditolak	6 tahun
Akses PHI	Siapa, apa, kapan	6 tahun
Modifikasi PHI	Nilai sebelum/sesudah	6 tahun
Penghapusan PHI	Apa, siapa	6 tahun
Perubahan Sistem	Konfigurasi, user baru	6 tahun
Peristiwa Keamanan	Gagal, batas laju	6 tahun

Pembuatan Laporan Audit

const generateAuditReport = async (startDate, endDate, options = {}) => {
  const query = {
    timestamp: {
      $gte: new Date(startDate),
      $lte: new Date(endDate)
    }
  };
  if (options.userId) query.actor = options.userId;
  if (options.eventType) query.event = options.eventType;
  const logs = await db.auditLogs.find(query).sort({ timestamp: 1 });
  return {
    reportPeriod: { start: startDate, end: endDate },
    generatedAt: new Date().toISOString(),
    summary: {
      totalEvents: logs.length,
      uniqueUsers: new Set(logs.map(l => l.actor)).size,
      failures: logs.filter(l => l.outcome === 'FAILURE').length,
      phiAccess: logs.filter(l => l.event === 'PHI_ACCESS').length
    },
    events: logs
  };
};

cron.schedule('0 0 * * 1', async () => {
  const end = new Date();
  const start = new Date(end.getTime() - 7 * 24 * 60 * 60 * 1000);
  const report = await generateAuditReport(start, end);
  await sendToComplianceTeam(report);
});

Praktik Terbaik Keamanan API

Validasi Input

Hindari injeksi:

const { body, param, query, validationResult } = require('express-validator');
const validatePatientRequest = [
  body('firstName')
    .trim()
    .notEmpty()
    .matches(/^[a-zA-Z\s'-]+$/)
    .withMessage('Format nama depan tidak valid')
    .isLength({ max: 50 }),
  body('dateOfBirth')
    .isISO8601()
    .withMessage('Format tanggal tidak valid')
    .custom(value => new Date(value) < new Date())
    .withMessage('Tanggal lahir harus di masa lalu'),
  body('ssn')
    .optional()
    .matches(/^\d{3}-\d{2}-\d{4}$/)
    .withMessage('Format SSN tidak valid'),
  body('email')
    .optional()
    .isEmail()
    .normalizeEmail(),
  param('id')
    .isUUID()
    .withMessage('Format ID pasien tidak valid'),
  (req, res, next) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({
        error: 'Validasi gagal',
        details: errors.array()
      });
    }
    next();
  }
];

Pembatasan Laju (Rate Limiting)

Cegah brute force:

const rateLimit = require('express-rate-limit');

const authLimiter = rateLimit({
  windowMs: 15 * 60 * 1000,
  max: 5,
  message: { error: 'Terlalu banyak percobaan autentikasi' },
  standardHeaders: true,
  legacyHeaders: false,
  handler: async (req, res) => {
    await auditLog('RATE_LIMIT_EXCEEDED', {
      userId: req.body.username,
      ip: req.ip,
      endpoint: 'auth'
    });
    res.status(429).json({ error: 'Terlalu banyak percobaan' });
  }
});

const apiLimiter = rateLimit({
  windowMs: 60 * 1000,
  max: 100,
  message: { error: 'Batas laju terlampaui' }
});

app.use('/api/auth', authLimiter);
app.use('/api', apiLimiter);

Penanganan Kesalahan

Cegah bocornya info sensitif:

app.use((err, req, res, next) => {
  console.error('Error:', {
    message: err.message,
    stack: err.stack,
    path: req.path,
    user: req.user?.id
  });
  res.status(err.status || 500).json({
    error: 'Terjadi kesalahan saat memproses permintaan Anda',
    requestId: req.id
  });
});
// Jangan pernah tampilkan stack trace, skema DB, IP internal, jumlah user, atau PHI di error.

Pelanggaran API HIPAA Umum dan Cara Menghindarinya

Pelanggaran: Kontrol Akses Tidak Memadai

Skenario: Pengguna bisa mengakses data pasien lain.

Solusi: Periksa otorisasi secara eksplisit:

// BURUK: Tidak ada otorisasi
app.get('/api/patients/:id', async (req, res) => {
  const patient = await db.patients.findById(req.params.id);
  res.json(patient);
});

// BAIK: Cek hubungan pengguna-pasien
app.get('/api/patients/:id', async (req, res) => {
  const patient = await db.patients.findById(req.params.id);
  if (req.user.id === patient.userId) {
    return res.json(patient);
  }
  const assignment = await db.providerAssignments.findOne({
    providerId: req.user.id,
    patientId: patient.id
  });
  if (assignment) {
    return res.json(patient);
  }
  await auditLog('UNAUTHORIZED_ACCESS_ATTEMPT', {
    userId: req.user.id,
    patientId: patient.id
  });
  res.status(403).json({ error: 'Akses ditolak' });
});

Pelanggaran: Catatan Audit Hilang

Skenario: Tidak ada catatan akses data pasien.

Solusi: Catat semua akses PHI (lihat bagian kontrol audit).

Pelanggaran: Transmisi Data Tidak Terenkripsi

Skenario: API menerima koneksi HTTP.

Solusi: Paksa HTTPS dan HSTS:

app.use((req, res, next) => {
  if (!req.secure && process.env.NODE_ENV === 'production') {
    return res.status(403).json({
      error: 'HTTPS diperlukan. Sambungkan melalui https://' + req.headers.host
    });
  }
  res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains');
  next();
});

Pelanggaran: Paparan Data Berlebihan

Skenario: API mengembalikan data pasien berlebihan.

Solusi: Batasi field yang diekspos:

app.get('/api/patients/:id', async (req, res) => {
  const fields = req.query.fields?.split(',') || ['id', 'name'];
  const projection = Object.fromEntries(fields.map(f => [f, 1]));
  const patient = await db.patients.findById(req.params.id, projection);
  res.json(patient);
});

Daftar Periksa Penyebaran Produksi

Sebelum menangani PHI secara langsung:

[ ] Laksanakan BAA dengan semua vendor
[ ] Implementasikan MFA untuk semua user
[ ] Aktifkan TLS 1.3 untuk semua endpoint
[ ] Enkripsi semua PHI saat disimpan (AES-256)
[ ] Implementasikan pencatatan audit komprehensif
[ ] Atur retensi log minimal 6 tahun
[ ] Konfigurasi RBAC
[ ] Implementasikan rate limiting
[ ] Siapkan rencana respons insiden
[ ] Dokumentasikan semua kontrol keamanan
[ ] Lakukan penilaian risiko keamanan
[ ] Latih tim tentang HIPAA
[ ] Jadwalkan audit keamanan rutin

Templat Penilaian Risiko Keamanan

## Penilaian Risiko Keamanan HIPAA

### Ikhtisar Sistem
- Nama Sistem: [Nama API]
- Jenis PHI yang Ditangani: [Daftar]
- Aliran Data: [Diagram]

### Penilaian Ancaman
| Ancaman           | Kemungkinan | Dampak  | Mitigasi          |
|-------------------|-------------|---------|-------------------|
| Akses tidak sah   | Sedang      | Tinggi  | MFA, RBAC         |
| Pelanggaran data  | Rendah      | Kritis  | Enkripsi          |
| Ancaman orang dalam| Sedang     | Tinggi  | Log audit         |

### Pengujian Kontrol
- [ ] Uji bypass autentikasi
- [ ] Uji bypass otorisasi
- [ ] Uji injeksi SQL
- [ ] Uji XSS
- [ ] Verifikasi enkripsi

### Tanda Tangan
Petugas Keamanan: _______________ Tanggal: _______
CTO: _______________ Tanggal: _______

Studi Kasus Dunia Nyata

API Platform Telemedicine

Tantangan: Transmisi aman video pasien-penyedia
Solusi: WebRTC end-to-end terenkripsi, API sinyal patuh HIPAA
Hasil: SOC 2 Tipe II, 500K+ konsultasi tanpa pelanggaran

Implementasi:

Autentikasi JWT + MFA
Token ruangan sementara
Tidak ada PHI di log
BAA dengan Twilio untuk video

API Portal Pasien

Tantangan: 20+ sistem lama, keamanan tidak konsisten
Solusi: API gateway terpadu, autentikasi & audit terpusat
Hasil: Satu sumber data, pelaporan kepatuhan mudah

Implementasi:

OAuth2 + SMART on FHIR
Audit log terpusat
Kontrol akses granular
Deteksi pelanggaran otomatis

Platform Integrasi Data Kesehatan

Tantangan: Model keamanan vendor EHR bervariasi
Solusi: Lapisan abstraksi, kontrol HIPAA seragam
Hasil: 100+ integrasi RS, nol temuan kepatuhan

Implementasi:

Normalisasi data & enkripsi konsisten
Audit per tenant
Pelacakan BAA otomatis
Dasbor kepatuhan real-time

Kesimpulan

Kepatuhan HIPAA untuk API membutuhkan desain arsitektur yang sengaja: autentikasi, enkripsi, kontrol akses, dan audit. Hal yang harus dipastikan:

BAA dengan semua vendor sebelum menangani PHI
MFA dan RBAC untuk kontrol akses
Enkripsi data saat transit (TLS 1.3) & disimpan (AES-256)
Semua akses PHI diaudit dan disimpan 6 tahun
Terapkan standar minimum pada endpoint
Apidog menyederhanakan dokumentasi API dan alur kerja kepatuhan

Bagian FAQ

Apa yang membuat API sesuai HIPAA?

API sesuai HIPAA jika menerapkan pengamanan teknis (enkripsi, kontrol akses, log audit), administratif (kebijakan, pelatihan, BAA), dan fisik sesuai Aturan Keamanan HIPAA untuk melindungi ePHI.

Apakah saya memerlukan BAA untuk API saya?

Ya, jika API Anda memproses/menyimpan PHI atas nama entitas tercakup, Anda adalah Rekan Bisnis dan wajib BAA. Berlaku untuk cloud provider, layanan API, dan subprosesor.

Enkripsi apa yang diperlukan untuk HIPAA?

HIPAA menuntut enkripsi "saat transit" dan "saat disimpan". Gunakan TLS 1.3 untuk komunikasi API dan AES-256 untuk data di storage.

Berapa lama log audit HIPAA harus disimpan?

Log audit wajib disimpan minimal 6 tahun sejak pembuatan atau berlaku terakhir.

Bisakah saya menggunakan JWT untuk autentikasi HIPAA?

Bisa, jika: masa berlaku singkat (maks 15 menit untuk PHI), penyimpanan aman, rotasi refresh token, dan selalu digabung MFA.

Apa itu standar minimum yang diperlukan?

API hanya boleh mengekspos PHI minimum sesuai tujuan. Gunakan pemfilteran field dan kontrol akses berbasis tujuan.

Apakah log audit perlu dienkripsi?

Wajib, jika log mengandung PHI. Simpan di storage hanya-tambah untuk mencegah perubahan.

Bagaimana cara menangani pemberitahuan pelanggaran?

Jika terjadi akses PHI tidak sah: 1) Tangani pelanggaran, 2) Uji risiko 4 faktor, 3) Notifikasi korban dalam 60 hari, 4) Notifikasi HHS (jika 500+ individu), 5) Dokumentasi lengkap.

Bisakah saya menggunakan layanan cloud untuk HIPAA?

Bisa, jika provider menandatangani BAA. AWS, GCP, Azure menawarkan layanan qualified HIPAA. Ikuti panduan konfigurasi masing-masing.

Sanksi apa untuk pelanggaran HIPAA?

Sanksi perdata $100–$50.000/pelanggaran, maksimum $1,5 juta/tahun/kategori. Sanksi pidana: denda $250.000 & penjara hingga 10 tahun.