Como Criar uma API em Conformidade com a HIPAA em 2026 para Aplicativos de Saúde Seguros

TL;DR

A conformidade HIPAA para APIs exige a implementação de controles de segurança rigorosos para as Informações de Saúde Protegidas (PHI), incluindo criptografia em trânsito e em repouso, registro de auditoria, controles de acesso e acordos de associados de negócios. Este guia abrange padrões de arquitetura de API, requisitos de autenticação, implementação de trilhas de auditoria e verificação de conformidade para aplicativos de saúde que lidam com PHI.

Introdução

Violações de dados de saúde custam, em média, US$ 10,93 milhões por incidente. Para desenvolvedores que criam aplicativos de saúde, a segurança da API não é opcional—é um requisito legal sob o HIPAA (Health Insurance Portability and Accountability Act).

Aqui está a realidade: 79% das violações de dados de saúde envolvem acesso não autorizado por meio de APIs e vulnerabilidades de aplicativos. Uma arquitetura de API compatível com HIPAA, projetada adequadamente, previne violações, permite trilhas de auditoria e protege a privacidade do paciente.

Este guia detalha todo o processo de conformidade de API HIPAA. Você aprenderá os requisitos de tratamento de PHI, padrões de criptografia, implementação de controle de acesso, registro de auditoria e documentação de conformidade. Ao final, você terá uma arquitetura de API compatível com HIPAA pronta para produção.

O Que É HIPAA e Por Que É Importante para APIs?

HIPAA é uma lei federal que estabelece padrões nacionais para a proteção de informações de saúde sensíveis do paciente. A Regra de Segurança do HIPAA aborda especificamente as informações de saúde eletrônicas protegidas (ePHI) transmitidas por meio de APIs.

Quem Deve Cumprir

Principais Regras HIPAA para APIs

Regra de Privacidade: Governa o uso e a divulgação de PHI

• Padrão mínimo necessário
• Direitos de acesso do paciente
• Requisitos de autorização

Regra de Segurança: Salvaguardas técnicas para ePHI

• Controles de acesso
• Controles de auditoria
• Controles de integridade
• Segurança da transmissão

Regra de Notificação de Violação: Requisitos de resposta a incidentes

• Prazo de notificação de 60 dias
• Documentação de avaliação de risco
• Procedimentos de mitigação

Visão Geral da Arquitetura da API

Uma arquitetura de API compatível com HIPAA inclui:

┌─────────────────────────────────────────────────────────────────┐
│                    PILHA DE API COMPATÍVEL COM HIPAA             │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐         │
│  │   CLIENTE   │───▶│   GATEWAY   │───▶│  BANCO DE   │         │
│  │   (Aplicativo)│    │   DA API    │    │  DADOS      │         │
│  └─────────────┘    └─────────────┘    └─────────────┘         │
│        │                  │                  │                  │
│        ▼                  ▼                  ▼                  │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐         │
│  │   OAuth 2.0 │    │   WAF +     │    │   Registro  │         │
│  │   + MFA     │    │   Limite de │    │   de        │         │
│  │             │    │   Taxa      │    │   Auditoria │         │
│  └─────────────┘    └─────────────┘    └─────────────┘         │
│                                                                  │
│  Todos os dados criptografados: TLS 1.3+ em trânsito, AES-256 em repouso       │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Primeiros Passos: Fundação da Conformidade

Passo 1: Executar Acordos de Associado de Negócios (BAA)

Antes de lidar com qualquer PHI:

1. Identifique todos os fornecedores com acesso a PHI
2. Execute BAA com cada fornecedor
3. Documente subprocessadores em seus BAAs
4. Revise anualmente e atualize conforme necessário

Fornecedores críticos que exigem BAA:

• Hospedagem em nuvem (AWS, GCP, Azure)
• Provedores de banco de dados
• Serviços de registro (logging)
• Provedores de backup
• Gateways de API
• Ferramentas de monitoramento

NÃO use estes sem BAA:

• Google Analytics padrão
• Serviços de nuvem de camada gratuita (free tier)
• Contas de e-mail pessoais
• Canais do Slack não relacionados à saúde

Passo 2: Classificação de Dados

Classifique todos os dados que sua API manipula:

Passo 3: Padrão Mínimo Necessário

As APIs devem expor apenas os dados mínimos necessários:

// RUIM: Retorna todos os dados do paciente
app.get('/api/patients/:id', async (req, res) => {
  const patient = await db.patients.findById(req.params.id);
  res.json(patient); // Retorna tudo
});

// BOM: Filtragem em nível de campo
app.get('/api/patients/:id', async (req, res) => {
  const fields = req.query.fields?.split(',') || ['id', 'name'];
  const allowedFields = ['id', 'name', 'dateOfBirth']; // Lista de permissões

  const patient = await db.patients.findById(req.params.id);
  const filtered = Object.fromEntries(
    Object.entries(patient).filter(([key]) => allowedFields.includes(key))
  );

  res.json(filtered);
});

Implementação de Salvaguardas Técnicas

Controle de Acesso: Autenticação

Implemente autenticação forte:

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

// Autenticação multifator necessária
class HIPAAAuthService {
  async authenticate(username, password, mfaCode) {
    // 1. Verificar credenciais
    const user = await this.getUserByUsername(username);
    if (!user) throw new Error('Invalid credentials');

    const validPassword = await bcrypt.compare(password, user.passwordHash);
    if (!validPassword) throw new Error('Invalid credentials');

    // 2. Verificar MFA (TOTP)
    const validMFA = this.verifyTOTP(user.mfaSecret, mfaCode);
    if (!validMFA) throw new Error('Invalid MFA code');

    // 3. Gerar JWT de curta duração (máx. 15 minutos para acesso a PHI)
    const token = jwt.sign(
      {
        sub: user.id,
        role: user.role,
        mfa_verified: true
      },
      process.env.JWT_SECRET,
      { expiresIn: '15m' }
    );

    // 4. Registrar tentativa de autenticação
    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;
  }
}

Controle de Acesso: Autorização

Implemente controle de acesso baseado em função (RBAC):

// Definições de funções
const ROLES = {
  ADMIN: 'admin',
  PROVIDER: 'provider',
  NURSE: 'nurse',
  BILLING: 'billing',
  PATIENT: 'patient'
};

// Matriz de permissões
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 de autorização
const authorize = (...requiredPermissions) => {
  return async (req, res, next) => {
    const user = req.user; // Do 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: 'Insufficient permissions' });
    }

    next();
  };
};

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

Criptografia em Trânsito

Imponha TLS 1.3 para todas as comunicações de API:

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

// Configuração do servidor
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);

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

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

Criptografia em Repouso

Criptografe todas as PHI armazenadas:

const crypto = require('crypto');

class EncryptionService {
  constructor(key) {
    // Use AWS KMS, GCP KMS, ou Azure Key Vault para gerenciamento de chaves
    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;
  }
}

// Modelo de banco de dados com criptografia
class PatientRecord {
  constructor(db, encryptionService) {
    this.db = db;
    this.encryption = encryptionService;
  }

  async create(data) {
    // Criptografe campos PHI antes do armazenamento
    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);

    // Descriptografar na leitura
    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)
    };
  }
}

Implementação de Controles de Auditoria

Registro de Auditoria Abrangente

Registre todo o acesso a PHI:

const winston = require('winston');

// Logger de auditoria imutável
const auditLogger = winston.createLogger({
  level: 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json()
  ),
  transports: [
    // Escrever em armazenamento somente anexado
    new winston.transports.File({
      filename: '/var/log/hipaa-audit/audit.log',
      maxsize: 52428800, // 50MB
      maxFiles: 365
    }),
    // Também enviar para SIEM
    new winston.transports.Http({
      host: 'siem.internal',
      path: '/api/logs',
      ssl: true
    })
  ]
});

// Middleware de registro de auditoria
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);

  // Também armazenar no banco de dados para consultas
  await db.auditLogs.insert(logEntry);
};

// Middleware de auditoria automático
app.use((req, res, next) => {
  const start = Date.now();

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

    // Registrar todo o acesso a 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();
});

Eventos de Auditoria Obrigatórios

Geração de Relatórios de Auditoria

Gere relatórios de conformidade:

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

// Relatórios semanais agendados
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);
});

Melhores Práticas de Segurança de API

Validação de Entrada

Prevenção de ataques de injeção:

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

// Validação rigorosa para todas as entradas
const validatePatientRequest = [
  body('firstName')
    .trim()
    .notEmpty()
    .matches(/^[a-zA-Z\s'-]+$/)
    .withMessage('Invalid first name format')
    .isLength({ max: 50 }),

  body('dateOfBirth')
    .isISO8601()
    .withMessage('Invalid date format')
    .custom(value => new Date(value) < new Date())
    .withMessage('Date of birth must be in the past'),

  body('ssn')
    .optional()
    .matches(/^\d{3}-\d{2}-\d{4}$/)
    .withMessage('Invalid SSN format'),

  body('email')
    .optional()
    .isEmail()
    .normalizeEmail(),

  param('id')
    .isUUID()
    .withMessage('Invalid patient ID format'),

  (req, res, next) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({
        error: 'Validation failed',
        details: errors.array()
      });
    }
    next();
  }
];

Limitação de Taxa (Rate Limiting)

Previna abusos e ataques de força bruta:

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

// Limites rigorosos para endpoints de autenticação
const authLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutos
  max: 5, // 5 tentativas por janela
  message: { error: 'Too many authentication attempts' },
  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: 'Too many attempts' });
  }
});

// Limites gerais de API
const apiLimiter = rateLimit({
  windowMs: 60 * 1000, // 1 minuto
  max: 100, // 100 requisições por minuto
  message: { error: 'Rate limit exceeded' }
});

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

Tratamento de Erros

Previna vazamento de informações:

// Respostas de erro genéricas
app.use((err, req, res, next) => {
  // Registrar erro completo internamente
  console.error('Error:', {
    message: err.message,
    stack: err.stack,
    path: req.path,
    user: req.user?.id
  });

  // Resposta genérica ao cliente
  res.status(err.status || 500).json({
    error: 'An error occurred processing your request',
    requestId: req.id
  });
});

// Nunca expor em erros:
// - Stack traces
// - Esquema de banco de dados
// - IPs internos
// - Contagem de usuários
// - PHI em mensagens de erro

Violações Comuns da API HIPAA e Como Evitá-las

Violação: Controles de Acesso Inadequados

Cenário: A API permite que qualquer usuário autenticado acesse qualquer registro de paciente.

Correção: Implemente verificações de autorização adequadas:

// RUIM: Sem verificação de autorização
app.get('/api/patients/:id', async (req, res) => {
  const patient = await db.patients.findById(req.params.id);
  res.json(patient);
});

// BOM: Verifique se o usuário tem relacionamento com o paciente
app.get('/api/patients/:id', async (req, res) => {
  const patient = await db.patients.findById(req.params.id);

  // Verifique se o usuário é o paciente
  if (req.user.id === patient.userId) {
    return res.json(patient);
  }

  // Verifique se o usuário é o provedor atribuído
  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: 'Access denied' });
});

Violação: Registros de Auditoria Ausentes

Cenário: Nenhum registro de quem acessou os dados do paciente.

Correção: Registre todo o acesso a PHI conforme mostrado na seção de controles de auditoria acima.

Violação: Transmissão de Dados Não Criptografados

Cenário: A API aceita conexões HTTP.

Correção: Imponha HTTPS com HSTS:

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

Violação: Exposição Excessiva de Dados

Cenário: A API retorna registros completos de pacientes quando apenas o nome é necessário.

Correção: Implemente filtragem em nível de campo:

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

Lista de Verificação de Implantação em Produção

Antes de lidar com PHI ao vivo:

• [ ] Execute BAA com todos os fornecedores
• [ ] Implemente MFA para todos os usuários
• [ ] Habilite TLS 1.3 para todos os endpoints
• [ ] Criptografe todas as PHI em repouso (AES-256)
• [ ] Implemente registro de auditoria abrangente
• [ ] Configure retenção de logs (6+ anos)
• [ ] Configure controles de acesso (RBAC)
• [ ] Implemente limitação de taxa (rate limiting)
• [ ] Crie um plano de resposta a incidentes
• [ ] Documente todos os controles de segurança
• [ ] Realize avaliação de risco de segurança
• [ ] Treine a equipe sobre os requisitos HIPAA
• [ ] Agende auditorias de segurança regulares

Modelo de Avaliação de Risco de Segurança

## Avaliação de Risco de Segurança HIPAA

### Visão Geral do Sistema
- Nome do Sistema: [Nome da API]
- Tipos de PHI Manipulados: [Lista]
- Fluxo de Dados: [Diagrama]

### Avaliação de Ameaças
| Ameaça | Probabilidade | Impacto | Mitigação |
|--------|---------------|---------|-----------|
| Acesso não autorizado | Médio | Alto | MFA, RBAC |
| Violação de dados | Baixo | Crítico | Criptografia |
| Ameaça interna | Médio | Alto | Logs de auditoria |

### Teste de Controle
- [ ] Teste de bypass de autenticação
- [ ] Teste de bypass de autorização
- [ ] Teste de injeção SQL
- [ ] Teste XSS
- [ ] Verificação de criptografia

### Assinatura
Oficial de Segurança: _______________ Data: _______
CTO: _______________ Data: _______

Casos de Uso do Mundo Real

API de Plataforma de Telemedicina

Uma startup de telessaúde constrói consultas por vídeo compatíveis com HIPAA:

• Desafio: Transmissão segura de chamadas de vídeo entre paciente e provedor
• Solução: WebRTC criptografado de ponta a ponta com API de sinalização compatível com HIPAA
• Resultado: Certificação SOC 2 Tipo II, mais de 500 mil consultas sem violação

Implementação chave:

• Autenticação JWT com MFA
• Tokens de sala efêmeros (expiram após a consulta)
• Nenhuma PHI armazenada em logs
• BAA com Twilio para infraestrutura de vídeo

API do Portal do Paciente

Um sistema hospitalar moderniza o acesso do paciente:

• Desafio: Mais de 20 sistemas legados com segurança inconsistente
• Solução: Gateway de API unificado com autenticação e auditoria centralizadas
• Resultado: Fonte única de verdade, relatórios de conformidade simplificados

Implementação chave:

• OAuth 2.0 com SMART on FHIR
• Registro de auditoria centralizado
• Controle de acesso em nível de campo
• Detecção automatizada de violações

Plataforma de Integração de Dados de Saúde

Uma empresa de tecnologia de saúde agrega dados de vários EHRs:

• Desafio: Diferentes modelos de segurança entre os fornecedores de EHR
• Solução: Camada de abstração com controles HIPAA uniformes
• Resultado: Mais de 100 integrações hospitalares, zero descobertas de conformidade

Implementação chave:

• Normalização de dados com criptografia consistente
• Trilhas de auditoria por locatário
• Rastreamento automatizado de BAA
• Painéis de conformidade em tempo real

Conclusão

A conformidade HIPAA para APIs exige decisões de arquitetura deliberadas em torno de autenticação, criptografia, controle de acesso e registro de auditoria. Principais conclusões:

• Execute BAAs com todos os fornecedores antes de lidar com PHI
• Implemente MFA e controle de acesso baseado em função
• Criptografe dados em trânsito (TLS 1.3) e em repouso (AES-256)
• Registre todo o acesso a PHI com retenção de 6 anos
• Aplique o padrão mínimo necessário a todos os endpoints
• Apidog agiliza a documentação da API e os fluxos de trabalho de conformidade.

Seção de Perguntas Frequentes

O que torna uma API compatível com HIPAA?

Uma API é compatível com HIPAA quando implementa salvaguardas técnicas (criptografia, controles de acesso, logs de auditoria), salvaguardas administrativas (políticas, treinamento, BAAs) e salvaguardas físicas exigidas pela Regra de Segurança do HIPAA para proteger ePHI.

Preciso de um BAA para minha API?

Sim, se sua API lida, processa ou armazena PHI em nome de uma entidade abrangida, você é um Associado de Negócios e deve assinar um BAA. Isso se aplica a provedores de nuvem, serviços de API e subprocessadores.

Que criptografia é exigida pelo HIPAA?

O HIPAA exige criptografia "em trânsito" e "em repouso". Use TLS 1.3 para comunicações de API e AES-256 para dados armazenados. Embora a criptografia seja tecnicamente "endereçável" na Regra de Segurança, ela é efetivamente exigida para conformidade.

Por quanto tempo os logs de auditoria HIPAA devem ser retidos?

O HIPAA exige que os logs de auditoria sejam retidos por 6 anos a partir da data de criação ou quando o registro foi efetivo pela última vez, o que for posterior.

Posso usar JWT para autenticação compatível com HIPAA?

Sim, os JWTs são aceitáveis quando implementados corretamente: expiração curta (máximo de 15 minutos para acesso a PHI), armazenamento seguro e rotação de tokens de atualização. Sempre combine com MFA para sistemas em produção.

O que é o padrão mínimo necessário?

O padrão mínimo necessário exige que as APIs exponham apenas a PHI mínima necessária para cumprir o propósito pretendido. Implemente filtragem em nível de campo e controles de acesso baseados em propósito.

Os logs de auditoria precisam ser criptografados?

Sim, os logs de auditoria contendo PHI devem ser criptografados em repouso. Além disso, armazene os logs em armazenamento somente anexado para evitar adulteração.

Como devo lidar com a notificação de violação?

Se ocorrer acesso não autorizado a PHI: 1) Contenha a violação, 2) Avalie o risco usando o teste de 4 fatores, 3) Notifique os indivíduos afetados dentro de 60 dias, 4) Notifique o HHS (imediatamente para mais de 500 indivíduos), 5) Documente tudo.

Posso usar serviços de nuvem para cargas de trabalho HIPAA?

Sim, se o provedor assinar um BAA. AWS, GCP e Azure oferecem serviços elegíveis ao HIPAA. Configure os serviços de acordo com o guia de implementação HIPAA do provedor.

Que penalidades existem para violações HIPAA?

As penalidades civis variam de US$ 100 a US$ 50.000 por violação, com máximos anuais de US$ 1,5 milhão por categoria de violação. As penalidades criminais incluem multas de até US$ 250.000 e prisão de até 10 anos.