Solutions de sécurité HealthTech

1// ✅ Secure FHIR API implementation
2app.get('solution-pages.healthtech./api/fhir/Patient/:id', 
3  authenticate,
4  authorize(['read:patient']),
5  validatePatientAccess,
6  (req, res) => {
7    
8  // Parameterized query to prevent SQL injection
9  const query = 'SELECT id, name, dob FROM patients WHERE id = ? AND authorized_user = ?';
10  
11  // Secure audit logging (no PHI)
12  auditLog.info({
13    action: 'patient_access',
14    user_id: req.user.id,
15    patient_id: req.params.id,
16    timestamp: new Date().toISOString(),
17    ip_address: req.ip
18  });
19  
20  db.query(query, [req.params.id, req.user.id], (err, result) => {
21    if (err) {
22      auditLog.error('Database error during patient access', { user_id: req.user.id });
23      return res.status(500).json({ error: 'Access denied' });
24    }
25    
26    if (!result.length) {
27      return res.status(404).json({ error: 'Patient not found or access denied' });
28    }
29    
30    // Return only authorized, sanitized data
31    res.json({
32      resourceType: 'Patient',
33      id: result[0].id,
34      name: result[0].name,
35      birthDate: result[0].dob
36      // No sensitive PHI exposed
37    });
38  });
39});

1// ❌ Vulnerable FHIR API endpoint
2app.get('solution-pages.healthtech./api/fhir/Patient/:id', (req, res) => {
3  // No authorization check
4  // SQL injection possible
5  const query = `SELECT * FROM patients WHERE id = ${req.params.id}`;
6  
7  // PHI exposed in logs
8  console.log(`Accessing patient: ${req.params.id}`);
9  
10  db.query(query, (err, result) => {
11    if (err) {
12      console.log('Database error:', err);
13      return res.status(500).json({ error: 'Database error' });
14    }
15    
16    // Returning all patient data including sensitive PHI
17    res.json({
18      patient: result[0],
19      ssn: result[0].ssn,
20      medical_history: result[0].medical_history,
21      insurance_info: result[0].insurance_info
22    });
23  });
24});

1# ✅ Secure PHI handling with integrity validation
2import hashlib
3import datetime
4from cryptography.fernet import Fernet
5 
6def update_patient_record_secure(patient_id, new_data, user_id):
7    # Validate user authorization
8    if not has_update_permission(user_id, patient_id):
9        audit_log_security_event('solution-pages.healthtech.unauthorized_update_attempt', user_id, patient_id)
10        raise PermissionError("Insufficient permissions")
11    
12    # Get current record for integrity check
13    current_record = get_patient_record_secure(patient_id)
14    original_hash = calculate_phi_hash(current_record)
15    
16    # Encrypt sensitive data
17    encrypted_data = encrypt_phi(new_data)
18    
19    # Use parameterized query
20    query = "UPDATE patients SET medical_history = ?, updated_by = ?, updated_at = ? WHERE id = ?"
21    cursor.execute(query, (encrypted_data, user_id, datetime.datetime.now(), patient_id))
22    
23    # Verify integrity after update
24    updated_record = get_patient_record_secure(patient_id)
25    new_hash = calculate_phi_hash(updated_record)
26    
27    # Secure audit logging (no PHI)
28    audit_log_phi_access({
29        'action': 'record_update',
30        'patient_id': patient_id,
31        'user_id': user_id,
32        'timestamp': datetime.datetime.now(),
33        'original_hash': original_hash,
34        'new_hash': new_hash
35    })
36    
37    return "Record updated securely"
38 
39def access_patient_data_secure(patient_id, user_id, requested_fields):
40    # Verify minimum necessary access
41    authorized_fields = get_authorized_fields(user_id, patient_id)
42    allowed_fields = set(requested_fields) & set(authorized_fields)
43    
44    if not allowed_fields:
45        raise PermissionError("No authorized fields requested")
46    
47    # Build secure query with only authorized fields
48    field_list = ', '.join(allowed_fields)
49    query = f"SELECT {field_list} FROM patients WHERE id = ?"
50    result = cursor.execute(query, (patient_id,)).fetchone()
51    
52    # Return only authorized, decrypted data
53    decrypted_result = {}
54    for i, field in enumerate(allowed_fields):
55        if field in ENCRYPTED_FIELDS:
56            decrypted_result[field] = decrypt_phi(result[i])
57        else:
58            decrypted_result[field] = result[i]
59    
60    # Audit the access
61    audit_log_phi_access({
62        'action': 'data_access',
63        'patient_id': patient_id,
64        'user_id': user_id,
65        'fields_accessed': list(allowed_fields),
66        'timestamp': datetime.datetime.now()
67    })
68    
69    return decrypted_result

1# ❌ Vulnerable PHI handling
2def update_patient_record(patient_id, new_data):
3    # No integrity validation
4    # No audit trail
5    # Direct database update without checks
6    
7    query = f"UPDATE patients SET medical_history = '{new_data}' WHERE id = {patient_id}"
8    cursor.execute(query)
9    
10    # PHI logged in plaintext
11    print(f"Updated patient {patient_id} with data: {new_data}")
12    
13    return "Record updated successfully"
14 
15def access_patient_data(patient_id, user_id):
16    # No access control validation
17    # No minimum necessary principle
18    query = f"SELECT * FROM patients WHERE id = {patient_id}"
19    result = cursor.execute(query).fetchone()
20    
21    # Return all data regardless of user permissions
22    return {
23        'patient_id': result[0],
24        'name': result[1],
25        'ssn': result[2],
26        'medical_history': result[3],
27        'insurance_info': result[4],
28        'mental_health_notes': result[5]
29    }