Cara Membuat API Sesuai HIPAA di 2026 untuk Aplikasi Kesehatan Aman

Inti Masalah (TL;DR)

Kepatuhan HIPAA untuk API mensyaratkan implementasi kontrol keamanan yang ketat terhadap Informasi Kesehatan yang Dilindungi (PHI), termasuk enkripsi saat transit dan saat disimpan, pencatatan audit, kontrol akses, dan perjanjian rekan bisnis. Panduan ini mencakup pola arsitektur API, persyaratan autentikasi, implementasi jejak audit, dan verifikasi kepatuhan untuk aplikasi perawatan kesehatan yang menangani PHI.

Pendahuluan

Pelanggaran data perawatan kesehatan merugikan rata-rata $10,93 juta per insiden. Bagi pengembang yang membangun aplikasi perawatan kesehatan, keamanan API bukan pilihan—itu adalah persyaratan hukum berdasarkan HIPAA (Health Insurance Portability and Accountability Act).

Inilah kenyataannya: 79% pelanggaran data perawatan kesehatan melibatkan akses tidak sah melalui API dan kerentanan aplikasi. Arsitektur API yang dirancang dengan benar dan sesuai HIPAA mencegah pelanggaran, memungkinkan jejak audit, dan melindungi privasi pasien.

Panduan ini membahas proses kepatuhan API HIPAA secara lengkap. Anda akan mempelajari persyaratan penanganan PHI, standar enkripsi, implementasi kontrol akses, pencatatan audit, dan dokumentasi kepatuhan. Pada akhirnya, Anda akan memiliki arsitektur API yang siap produksi dan sesuai HIPAA.

tombol

Apa Itu HIPAA dan Mengapa Penting untuk API?

HIPAA adalah undang-undang federal yang menetapkan standar nasional untuk melindungi informasi kesehatan pasien yang sensitif. Aturan Keamanan HIPAA secara khusus membahas informasi kesehatan elektronik yang dilindungi (ePHI) yang ditransmisikan melalui API.

Siapa yang Harus Mematuhi

Aturan HIPAA Utama untuk API

Aturan Privasi: Mengatur penggunaan dan pengungkapan PHI

• Standar minimum yang diperlukan
• Hak akses pasien
• Persyaratan otorisasi

Aturan Keamanan: Pengamanan teknis untuk ePHI

• Kontrol akses
• Kontrol audit
• Kontrol integritas
• Keamanan transmisi

Aturan Pemberitahuan Pelanggaran: Persyaratan respons insiden

• Jendela pemberitahuan 60 hari
• Dokumentasi penilaian risiko
• Prosedur mitigasi

Ikhtisar Arsitektur API

Arsitektur API yang sesuai HIPAA meliputi:

┌─────────────────────────────────────────────────────────────────┐
│                    HIPAA-COMPLIANT API STACK                     │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐         │
│  │   KLIEN     │───▶│   API       │───▶│  DATABASE   │         │
│  │   (Aplikasi)│    │   Gateway   │    │  (Terenkripsi)│         │
│  └─────────────┘    └─────────────┘    └─────────────┘         │
│        │                  │                  │                  │
│        ▼                  ▼                  ▼                  │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐         │
│  │   OAuth 2.0 │    │   WAF +     │    │   Audit     │         │
│  │   + MFA     │    │   Pembatas  │    │   Logging   │         │
│  │             │    │   Laju      │    │             │         │
│  └─────────────┘    └─────────────┘    └─────────────┘         │
│                                                                  │
│  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 apa pun:

1. Identifikasi semua vendor dengan akses PHI
2. Laksanakan BAA dengan setiap vendor
3. Dokumentasikan subprosesor dalam BAA Anda
4. Tinjau setiap tahun dan perbarui sesuai kebutuhan

Vendor penting yang memerlukan BAA:

• Cloud hosting (AWS, GCP, Azure)
• Penyedia database
• Layanan pencatatan (logging services)
• Penyedia pencadangan (backup providers)
• API gateway
• Alat pemantauan (monitoring tools)

JANGAN gunakan ini tanpa BAA:

• Google Analytics standar
• Layanan cloud tingkat gratis
• Akun email pribadi
• Saluran Slack non-perawatan kesehatan

Langkah 2: Klasifikasi Data

Klasifikasikan semua data yang ditangani API Anda:

Langkah 3: Standar Minimum yang Diperlukan

API harus mengekspos hanya data minimum yang diperlukan:

// 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); // Mengembalikan semuanya
});

// BAIK: Pemfilteran tingkat bidang
app.get('/api/patients/:id', async (req, res) => {
  const fields = req.query.fields?.split(',') || ['id', 'name'];
  const allowedFields = ['id', 'name', 'dateOfBirth']; // Daftar yang diizinkan

  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

Implementasikan autentikasi yang kuat:

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

// Diperlukan autentikasi multifaktor
class HIPAAAuthService {
  async authenticate(username, password, mfaCode) {
    // 1. Verifikasi kredensial
    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');

    // 2. Verifikasi MFA (TOTP)
    const validMFA = this.verifyTOTP(user.mfaSecret, mfaCode);
    if (!validMFA) throw new Error('Kode MFA tidak valid');

    // 3. Hasilkan JWT berumur pendek (maksimal 15 menit untuk akses PHI)
    const token = jwt.sign(
      {
        sub: user.id,
        role: user.role,
        mfa_verified: true
      },
      process.env.JWT_SECRET,
      { expiresIn: '15m' }
    );

    // 4. Catat upaya autentikasi
    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

Implementasikan kontrol akses berbasis peran (RBAC):

// Definisi peran
const ROLES = {
  ADMIN: 'admin',
  PROVIDER: 'provider',
  NURSE: 'nurse',
  BILLING: 'billing',
  PATIENT: 'patient'
};

// Matriks izin
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']
};

// Middleware otorisasi
const authorize = (...requiredPermissions) => {
  return async (req, res, next) => {
    const user = req.user; // Dari middleware JWT
    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();
  };
};

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

Enkripsi Saat Transit

Terapkan TLS 1.3 untuk semua komunikasi API:

const https = require('https');
const fs = require('fs');

// Konfigurasi server
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);

// Paksa pengalihan HTTPS
app.use((req, res, next) => {
  if (!req.secure) {
    return res.redirect(`https://${req.headers.host}${req.url}`);
  }
  next();
});

// Header HSTS
app.use((req, res, next) => {
  res.setHeader(
    'Strict-Transport-Security',
    'max-age=31536000; includeSubDomains; preload'
  );
  next();
});

Enkripsi Saat Disimpan

Enkripsi semua PHI yang disimpan:

const crypto = require('crypto');

class EncryptionService {
  constructor(key) {
    // Gunakan AWS KMS, GCP KMS, atau Azure Key Vault untuk manajemen kunci
    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 database dengan enkripsi
class PatientRecord {
  constructor(db, encryptionService) {
    this.db = db;
    this.encryption = encryptionService;
  }

  async create(data) {
    // Enkripsi bidang PHI sebelum penyimpanan
    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);

    // Dekripsi saat membaca
    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 ke PHI:

const winston = require('winston');

// Pencatat audit yang tidak dapat diubah
const auditLogger = winston.createLogger({
  level: 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json()
  ),
  transports: [
    // Tulis ke penyimpanan hanya-tambah
    new winston.transports.File({
      filename: '/var/log/hipaa-audit/audit.log',
      maxsize: 52428800, // 50MB
      maxFiles: 365
    }),
    // Juga kirim ke SIEM
    new winston.transports.Http({
      host: 'siem.internal',
      path: '/api/logs',
      ssl: true
    })
  ]
});

// Middleware pencatatan audit
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);

  // Juga simpan di database untuk kueri
  await db.auditLogs.insert(logEntry);
};

// Middleware audit otomatis
app.use((req, res, next) => {
  const start = Date.now();

  res.on('finish', async () => {
    const duration = Date.now() - start;

    // Catat semua akses PHI
    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

Pembuatan Laporan Audit

Hasilkan laporan kepatuhan:

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
  };
};

// Laporan mingguan terjadwal
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

Cegah serangan injeksi:

const { body, param, query, validationResult } = require('express-validator');

// Validasi ketat untuk semua input
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 penyalahgunaan dan serangan brute force:

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

// Batas ketat untuk endpoint autentikasi
const authLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 menit
  max: 5, // 5 percobaan per jendela
  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' });
  }
});

// Batas API umum
const apiLimiter = rateLimit({
  windowMs: 60 * 1000, // 1 menit
  max: 100, // 100 permintaan per menit
  message: { error: 'Batas laju terlampaui' }
});

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

Penanganan Kesalahan

Cegah kebocoran informasi:

// Respons kesalahan generik
app.use((err, req, res, next) => {
  // Catat kesalahan penuh secara internal
  console.error('Error:', {
    message: err.message,
    stack: err.stack,
    path: req.path,
    user: req.user?.id
  });

  // Respons generik kepada klien
  res.status(err.status || 500).json({
    error: 'Terjadi kesalahan saat memproses permintaan Anda',
    requestId: req.id
  });
});

// Jangan pernah mengungkapkan dalam kesalahan:
// - Jejak tumpukan (stack traces)
// - Skema database
// - IP internal
// - Jumlah pengguna
// - PHI dalam pesan kesalahan

Pelanggaran API HIPAA Umum dan Cara Menghindarinya

Pelanggaran: Kontrol Akses yang Tidak Memadai

Skenario: API memungkinkan setiap pengguna yang terautentikasi untuk mengakses catatan pasien mana pun.

Perbaikan: Implementasikan pemeriksaan otorisasi yang tepat:

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

// BAIK: Verifikasi pengguna memiliki hubungan dengan pasien
app.get('/api/patients/:id', async (req, res) => {
  const patient = await db.patients.findById(req.params.id);

  // Periksa apakah pengguna adalah pasien itu sendiri
  if (req.user.id === patient.userId) {
    return res.json(patient);
  }

  // Periksa apakah pengguna adalah penyedia yang ditugaskan
  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 siapa yang mengakses data pasien.

Perbaikan: Catat semua akses PHI seperti yang ditunjukkan di bagian kontrol audit di atas.

Pelanggaran: Transmisi Data Tidak Terenkripsi

Skenario: API menerima koneksi HTTP.

Perbaikan: Terapkan HTTPS dengan 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 catatan pasien lengkap padahal hanya nama yang diperlukan.

Perbaikan: Implementasikan pemfilteran tingkat bidang:

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 pengguna
• [ ] Aktifkan TLS 1.3 untuk semua endpoint
• [ ] Enkripsi semua PHI saat disimpan (AES-256)
• [ ] Implementasikan pencatatan audit komprehensif
• [ ] Atur retensi log (6+ tahun)
• [ ] Konfigurasi kontrol akses (RBAC)
• [ ] Implementasikan pembatasan laju (rate limiting)
• [ ] Buat rencana respons insiden
• [ ] Dokumentasikan semua kontrol keamanan
• [ ] Lakukan penilaian risiko keamanan
• [ ] Latih staf tentang persyaratan 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

Startup telehealth membangun konsultasi video yang sesuai HIPAA:

• Tantangan: Transmisi aman panggilan video pasien-penyedia
• Solusi: WebRTC terenkripsi end-to-end dengan API sinyal yang sesuai HIPAA
• Hasil: Bersertifikat SOC 2 Tipe II, 500 ribu+ konsultasi tanpa pelanggaran

Implementasi kunci:

• Autentikasi JWT dengan MFA
• Token ruangan sementara (kadaluarsa setelah konsultasi)
• Tidak ada PHI yang disimpan dalam log
• BAA dengan Twilio untuk infrastruktur video

API Portal Pasien

Sistem rumah sakit memodernisasi akses pasien:

• Tantangan: 20+ sistem lama dengan keamanan yang tidak konsisten
• Solusi: Gateway API terpadu dengan autentikasi dan audit terpusat
• Hasil: Sumber kebenaran tunggal, pelaporan kepatuhan yang disederhanakan

Implementasi kunci:

• OAuth 2.0 dengan SMART on FHIR
• Pencatatan audit terpusat
• Kontrol akses tingkat bidang
• Deteksi pelanggaran otomatis

Platform Integrasi Data Kesehatan

Perusahaan teknologi kesehatan mengagregasi data dari beberapa EHR:

• Tantangan: Model keamanan yang berbeda di antara vendor EHR
• Solusi: Lapisan abstraksi dengan kontrol HIPAA yang seragam
• Hasil: 100+ integrasi rumah sakit, nol temuan kepatuhan

Implementasi kunci:

• Normalisasi data dengan enkripsi yang konsisten
• Jejak audit per-tenant
• Pelacakan BAA otomatis
• Dasbor kepatuhan real-time

Kesimpulan

Kepatuhan HIPAA untuk API mensyaratkan keputusan arsitektur yang disengaja seputar autentikasi, enkripsi, kontrol akses, dan pencatatan audit. Poin-poin penting:

• Laksanakan BAA dengan semua vendor sebelum menangani PHI
• Implementasikan MFA dan kontrol akses berbasis peran
• Enkripsi data saat transit (TLS 1.3) dan saat disimpan (AES-256)
• Catat semua akses PHI dengan retensi 6 tahun
• Terapkan standar minimum yang diperlukan untuk semua endpoint
• Apidog menyederhanakan dokumentasi API dan alur kerja kepatuhan.

tombol

Bagian FAQ

Apa yang membuat API sesuai HIPAA?

API sesuai HIPAA ketika mengimplementasikan pengamanan teknis (enkripsi, kontrol akses, log audit), pengamanan administratif (kebijakan, pelatihan, BAA), dan pengamanan fisik yang disyaratkan oleh Aturan Keamanan HIPAA untuk melindungi ePHI.

Apakah saya memerlukan BAA untuk API saya?

Ya, jika API Anda menangani, memproses, atau menyimpan PHI atas nama entitas yang tercakup, Anda adalah Rekan Bisnis dan harus menandatangani BAA. Ini berlaku untuk penyedia cloud, layanan API, dan subprosesor.

Enkripsi apa yang diperlukan untuk HIPAA?

HIPAA mensyaratkan enkripsi "saat transit" dan "saat disimpan". Gunakan TLS 1.3 untuk komunikasi API dan AES-256 untuk data yang disimpan. Meskipun enkripsi secara teknis "dapat dialamatkan" dalam Aturan Keamanan, itu secara efektif diperlukan untuk kepatuhan.

Berapa lama log audit HIPAA harus disimpan?

HIPAA mensyaratkan log audit disimpan selama 6 tahun sejak tanggal pembuatan atau ketika catatan terakhir berlaku, mana yang lebih kemudian.

Bisakah saya menggunakan JWT untuk autentikasi yang sesuai HIPAA?

Ya, JWT dapat diterima jika diimplementasikan dengan benar: masa berlaku singkat (maksimal 15 menit untuk akses PHI), penyimpanan aman, dan rotasi token penyegaran. Selalu gabungkan dengan MFA untuk sistem produksi.

Apa itu standar minimum yang diperlukan?

Standar minimum yang diperlukan mensyaratkan API mengekspos hanya PHI minimum yang dibutuhkan untuk mencapai tujuan yang dimaksudkan. Implementasikan pemfilteran tingkat bidang dan kontrol akses berbasis tujuan.

Apakah log audit perlu dienkripsi?

Ya, log audit yang berisi PHI harus dienkripsi saat disimpan. Selain itu, simpan log dalam penyimpanan hanya-tambah untuk mencegah perubahan yang tidak sah.

Bagaimana cara menangani pemberitahuan pelanggaran?

Jika terjadi akses PHI yang tidak sah: 1) Tangani pelanggaran, 2) Nilai risiko menggunakan uji 4 faktor, 3) Beri tahu individu yang terkena dampak dalam waktu 60 hari, 4) Beri tahu HHS (segera untuk 500+ individu), 5) Dokumentasikan semuanya.

Bisakah saya menggunakan layanan cloud untuk beban kerja HIPAA?

Ya, jika penyedia menandatangani BAA. AWS, GCP, dan Azure semuanya menawarkan layanan yang memenuhi syarat HIPAA. Konfigurasi layanan sesuai dengan panduan implementasi HIPAA penyedia.

Sanksi apa yang ada untuk pelanggaran HIPAA?

Sanksi perdata berkisar dari $100 hingga $50.000 per pelanggaran, dengan maksimum tahunan $1,5 juta per kategori pelanggaran. Sanksi pidana meliputi denda hingga $250.000 dan hukuman penjara hingga 10 tahun.