# DevSecOps - Application Médicale MédiSecure
## Partie 1 : Audit et Mise en Conformité
### A. Contexte Réglementaire
#### 1. RGPD et Données de Santé
##### 1.1 Articles Clés
- **Article 9 : Traitement des données de santé**
* Interdiction de principe du traitement
* Exceptions pour la santé
* Conditions de consentement
* Mesures de protection spécifiques
- **Article 35 : Analyses d'impact (DPIA)**
* Obligation d'analyse préalable
* Contenu de l'analyse
* Consultation de l'autorité de contrôle
* Documentation des mesures
- **Article 32 : Sécurité du traitement**
* Mesures techniques requises
* Mesures organisationnelles
* Niveau de sécurité adapté
* Évaluation régulière
##### 1.2 Sanctions et Implications
- Jusqu'à 4% du CA mondial
- Plafond de 20M€
- Impact réputationnel
- Responsabilité pénale possible
#### 2. HDS (Hébergeur de Données de Santé)
##### 2.1 Certification Obligatoire
- Certification depuis 2018
- Audit initial et surveillance
- Renouvellement périodique
- Périmètre d'application
##### 2.2 Référentiel de Certification
- Processus métier
- Infrastructure
- Organisation
- Sécurité physique
- Sécurité logique
#### 3. Standards Internationaux
##### 3.1 HIPAA (USA)
- Privacy Rule
- Security Rule
- Enforcement Rule
- Breach Notification Rule
##### 3.2 NHS Digital (UK)
- Data Security Standards
- Clinical Safety Standards
- Interoperability Standards
- Service Management Standards
##### 3.3 NIS2 Directive (EU)
- Cybersécurité
- Notification des incidents
- Gestion des risques
- Continuité d'activité
### B. Implémentation de la Conformité
#### 1. Gestion du Consentement
```python
from datetime import datetime, timedelta
import jwt
class ConsentManager:
"""
Gestionnaire de consentement RGPD pour données médicales
"""
def __init__(self, secret_key):
self.secret_key = secret_key
def record_consent(self, user_id, purpose, expiration_days=365):
"""
Enregistre le consentement d'un utilisateur
Args:
user_id: Identifiant unique de l'utilisateur
purpose: Finalité du traitement
expiration_days: Durée de validité du consentement
Returns:
str: Token JWT contenant les informations de consentement
"""
consent_data = {
'user_id': user_id,
'purpose': purpose,
'timestamp': datetime.utcnow().isoformat(),
'expiration': (datetime.utcnow() + timedelta(days=expiration_days)).isoformat(),
'version': '1.0'
}
return jwt.encode(consent_data, self.secret_key, algorithm='HS256')
def verify_consent(self, consent_token):
"""
Vérifie la validité d'un consentement
Args:
consent_token: Token JWT de consentement
Returns:
bool: True si le consentement est valide
"""
try:
decoded = jwt.decode(consent_token, self.secret_key, algorithms=['HS256'])
return datetime.fromisoformat(decoded['expiration']) > datetime.utcnow()
except:
return False
def revoke_consent(self, user_id, purpose):
"""
Révoque le consentement d'un utilisateur
Args:
user_id: Identifiant de l'utilisateur
purpose: Finalité concernée
"""
# Logique de révocation
pass
def audit_consent(self, user_id):
"""
Génère un rapport d'audit des consentements
Args:
user_id: Identifiant de l'utilisateur
Returns:
dict: Historique des consentements
"""
# Logique d'audit
pass
```
#### 2. Chiffrement des Données Sensibles
```python
from cryptography.fernet import Fernet
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
import base64
import json
class HealthDataEncryption:
"""
Gestion du chiffrement des données de santé
"""
def __init__(self, master_key):
self.master_key = master_key
self.kdf = PBKDF2HMAC(
algorithm=hashes.SHA256(),
length=32,
salt=b'medisecure_salt',
iterations=100000,
)
def generate_patient_key(self, patient_id):
"""
Génère une clé unique par patient
Args:
patient_id: Identifiant unique du patient
Returns:
Fernet: Instance de chiffrement unique au patient
"""
patient_specific = f"{patient_id}_{self.master_key}".encode()
key = base64.urlsafe_b64encode(self.kdf.derive(patient_specific))
return Fernet(key)
def encrypt_medical_data(self, patient_id, data):
"""
Chiffre les données médicales d'un patient
Args:
patient_id: Identifiant du patient
data: Données à chiffrer
Returns:
bytes: Données chiffrées
"""
cipher = self.generate_patient_key(patient_id)
return cipher.encrypt(json.dumps(data).encode())
def decrypt_medical_data(self, patient_id, encrypted_data):
"""
Déchiffre les données médicales d'un patient
Args:
patient_id: Identifiant du patient
encrypted_data: Données chiffrées
Returns:
dict: Données déchiffrées
"""
cipher = self.generate_patient_key(patient_id)
decrypted = cipher.decrypt(encrypted_data)
return json.loads(decrypted.decode())
```
#### 3. Gestion des Accès et Authentification
```python
from fastapi import FastAPI, Depends, HTTPException, Security
from fastapi.security import OAuth2PasswordBearer, SecurityScopes
from jose import JWTError, jwt
from datetime import datetime, timedelta
from typing import List, Optional
import logging
class SecurityManager:
"""
Gestionnaire de sécurité pour l'application médicale
"""
def __init__(self, secret_key: str, algorithm: str = "HS256"):
self.secret_key = secret_key
self.algorithm = algorithm
self.logger = logging.getLogger("security_manager")
def create_access_token(self, data: dict, scopes: List[str], expires_delta: Optional[timedelta] = None):
"""
Crée un token JWT avec les autorisations appropriées
Args:
data: Données à inclure dans le token
scopes: Liste des autorisations
expires_delta: Durée de validité du token
"""
to_encode = data.copy()
if expires_delta:
expire = datetime.utcnow() + expires_delta
else:
expire = datetime.utcnow() + timedelta(minutes=15)
to_encode.update({
"exp": expire,
"scopes": scopes,
"iat": datetime.utcnow()
})
return jwt.encode(to_encode, self.secret_key, algorithm=self.algorithm)
def verify_token(self, token: str, required_scopes: List[str] = None):
"""
Vérifie la validité d'un token et ses autorisations
Args:
token: Token JWT à vérifier
required_scopes: Liste des autorisations requises
"""
try:
payload = jwt.decode(token, self.secret_key, algorithms=[self.algorithm])
if required_scopes:
token_scopes = set(payload.get("scopes", []))
for scope in required_scopes:
if scope not in token_scopes:
raise HTTPException(
status_code=403,
detail=f"Permission insuffisante. Requis: {scope}"
)
return payload
except JWTError as e:
self.logger.error(f"Erreur de vérification du token: {str(e)}")
raise HTTPException(status_code=401, detail="Token invalide")
def audit_access(self, user_id: str, resource: str, action: str):
"""
Enregistre une tentative d'accès pour audit
"""
log_entry = {
"timestamp": datetime.utcnow().isoformat(),
"user_id": user_id,
"resource": resource,
"action": action,
"ip_address": self.get_client_ip()
}
self.logger.info(f"Audit log: {log_entry}")
# Stockage dans la base de données d'audit
```
#### 4. Outils d'Audit
##### 4.1 Configuration SonarQube
```yaml
# sonar-project.properties
sonar.projectKey=medisecure
sonar.projectName=MediSecure
sonar.projectVersion=1.0
# Sources
sonar.sources=src
sonar.tests=tests
sonar.exclusions=**/tests/**,**/migrations/**
# Couverture de code
sonar.python.coverage.reportPaths=coverage.xml
sonar.python.xunit.reportPath=test-results.xml
# Qualité
sonar.python.pylint=/path/to/pylint
sonar.python.pylint_config=/path/to/.pylintrc
# Sécurité
sonar.security.sources=src
sonar.security.exclusions=**/test/**
sonar.security.sanitizers=**/sanitizers/**
# Règles personnalisées
sonar.python.rules=/path/to/custom-rules
```
##### 4.2 Configuration OWASP ZAP
```python
from zapv2 import ZAPv2
import time
import logging
class SecurityScanner:
"""
Scanner de sécurité automatisé avec OWASP ZAP
"""
def __init__(self, target_url, api_key):
self.zap = ZAPv2(apikey=api_key, proxies={'http': 'http://127.0.0.1:8080', 'https': 'http://127.0.0.1:8080'})
self.target = target_url
self.logger = logging.getLogger("security_scanner")
def setup_context(self):
"""Configure le contexte de scan"""
context_id = self.zap.context.new_context("medisecure")
self.zap.context.include_in_context("medisecure", f"^{self.target}.*$")
return context_id
def run_scan(self):
"""
Exécute un scan de sécurité complet
"""
try:
# Spider scan
self.logger.info('Démarrage du Spider scan...')
scan_id = self.zap.spider.scan(self.target)
time.sleep(2)
while int(self.zap.spider.status(scan_id)) < 100:
time.sleep(2)
# Active scan
self.logger.info('Démarrage du scan actif...')
scan_id = self.zap.ascan.scan(self.target)
while int(self.zap.ascan.status(scan_id)) < 100:
time.sleep(5)
# Génération du rapport
return self.generate_report()
except Exception as e:
self.logger.error(f"Erreur durant le scan: {str(e)}")
raise
def generate_report(self):
"""
Génère un rapport de sécurité
"""
alerts = self.zap.core.alerts()
report = {
"high_risks": [],
"medium_risks": [],
"low_risks": []
}
for alert in alerts:
risk = alert.get('risk')
if risk == 'High':
report["high_risks"].append(alert)
elif risk == 'Medium':
report["medium_risks"].append(alert)
elif risk == 'Low':
report["low_risks"].append(alert)
return report
```
##### 4.3 Configuration Dependency Check
```yaml
# dependency-check-config.yaml
scan:
dependencies:
# Scan des dépendances Python
python:
enabled: true
path: requirements.txt
# Scan des dépendances JavaScript
node:
enabled: true
path: package.json
output:
format:
- HTML
- JSON
- XML
directory: security-reports
suppression: suppression.xml
# Configuration des règles
rules:
# Niveau de gravité minimum
cvssv3.severity: MEDIUM
# Score CVSS minimum
cvssv3.score: 4.0
cache:
directory: .cache
retention: 7
analyzers:
- experiencePythonPackageVulnerability
- experimentalNodeAudit
# Serveurs NVD
nvd:
urls:
- https://nvd.nist.gov/feeds/json/cve/1.1/nvdcve-1.1-recent.json.gz
```
## Liens utiles
### Références Réglementaires pour les Données de Santé
#### RGPD (Europe)
#### Documents Officiels
- [Texte officiel du RGPD](https://eur-lex.europa.eu/legal-content/FR/TXT/HTML/?uri=CELEX:32016R0679)
- [Article 9 - Traitement des données sensibles](https://gdpr-text.com/fr/read/article-9/)
- [Article 35 - Analyse d'impact (DPIA)](https://gdpr-text.com/fr/read/article-35/)
- [Article 32 - Sécurité du traitement](https://gdpr-text.com/fr/read/article-32/)
#### Guides Pratiques CNIL
- [Guide RGPD du développeur](https://www.cnil.fr/fr/guide-rgpd-du-developpeur)
- [Guide de la sécurité des données personnelles](https://www.cnil.fr/fr/principes-cles/guide-de-la-securite-des-donnees-personnelles)
- [Conformité RGPD : par où commencer](https://www.cnil.fr/fr/rgpd-par-ou-commencer)
- [Outils et méthodes de gestion des risques](https://www.cnil.fr/fr/analyser-les-risques)
#### Outils CNIL
- [PIA (Privacy Impact Assessment) Software](https://www.cnil.fr/fr/outil-pia-telechargez-et-installez-le-logiciel-de-la-cnil)
- [Modèles de registre de traitement](https://www.cnil.fr/fr/RGDP-le-registre-des-activites-de-traitement)
### HDS (Hébergeur de Données de Santé - France)
#### Documents de Référence
- [Référentiel de certification HDS](https://esante.gouv.fr/sites/default/files/media_entity/documents/ans_referentiel_hds_certification.pdf)
- [Procédure de certification](https://esante.gouv.fr/labels-certifications/hds/certification-des-hebergeurs-de-donnees-de-sante)
- [Guide des exigences HDS](https://esante.gouv.fr/sites/default/files/media_entity/documents/ans_referentiel_hds_annexe-exigences.pdf)
#### Ressources ANS (Agence du Numérique en Santé)
- [Liste des hébergeurs certifiés](https://esante.gouv.fr/labels-certifications/hds/liste-des-herbergeurs-certifies)
- [Portail d'accompagnement cybersécurité](https://cyberveille-sante.gouv.fr/)
- [Guide d'accompagnement à la mise en conformité](https://esante.gouv.fr/sites/default/files/media_entity/documents/ans_guide_certification_hds.pdf)
### Standards Internationaux
#### HIPAA (USA)
- [HIPAA Compliance Checklist](https://www.hhs.gov/hipaa/for-professionals/security/guidance/index.html)
- [Guide de sécurité HIPAA](https://www.hhs.gov/sites/default/files/ocr/privacy/hipaa/administrative/securityrule/security101.pdf)
- [Règles de confidentialité](https://www.hhs.gov/hipaa/for-professionals/privacy/laws-regulations/index.html)
#### NHS Digital (UK)
- [Data Security and Protection Toolkit](https://www.dsptoolkit.nhs.uk/)
- [Standards de cybersécurité NHS](https://digital.nhs.uk/cyber-and-data-security)
- [Guide de conformité NHS](https://digital.nhs.uk/data-and-information/looking-after-information/data-security-and-information-governance)
#### NIS2 Directive (EU)
- [Texte officiel de la directive NIS2](https://eur-lex.europa.eu/legal-content/FR/TXT/?uri=CELEX%3A32022L2555)
- [Guide d'implémentation](https://digital-strategy.ec.europa.eu/en/policies/nis2-directive)
- [Mesures de sécurité requises](https://www.enisa.europa.eu/topics/nis-directive)
### Outils de Conformité Recommandés
#### Gestion de la Conformité
- [OneTrust](https://www.onetrust.fr/solutions/healthcare-compliance/)
- [Darktrace](https://www.darktrace.com/solutions/healthcare)
- [IBM Security Guardium](https://www.ibm.com/products/guardium-data-protection)
### Audit et Surveillance
- [Qualys Compliance Suite](https://www.qualys.com/solutions/compliance/)
- [Rapid7 InsightVM](https://www.rapid7.com/products/insightvm/)
- [Tenable.io](https://www.tenable.com/products/tenable-io)
#### Protection des Données
- [Varonis Data Security Platform](https://www.varonis.com/products/data-security-platform)
- [CipherCloud](https://www.ciphercloud.com/solutions/healthcare/)
- [Thales CipherTrust](https://cpl.thalesgroup.com/encryption/ciphertrust-platform)
### Ressources de Formation
#### Formations Certifiantes
- [CISSP Healthcare Security Practitioner](https://www.isc2.org/Certifications/HCISPP)
- [HITRUST Certified CSF Practitioner](https://hitrustalliance.net/hitrust-csf/)
- [Certified HIPAA Professional](https://www.ecfirst.com/certified-hipaa-professional/)
#### Formations Continue
- [ANSSI - SecNumacadémie](https://secnumacademie.gouv.fr/)
- [CNIL - MOOC RGPD](https://atelier-rgpd.cnil.fr/)
- [ANS - Formations e-santé](https://esante-formation.fr/)
### Mise à Jour Réglementaire
#### Sources Officielles
- [Journal officiel de l'UE](https://eur-lex.europa.eu/)
- [Légifrance](https://www.legifrance.gouv.fr/)
- [HHS Office for Civil Rights](https://www.hhs.gov/ocr/index.html)
#### Veille Réglementaire
- [CNIL - Actualités](https://www.cnil.fr/fr/actualites)
- [ANS - Actualités](https://esante.gouv.fr/actualites)
- [ENISA - Publications](https://www.enisa.europa.eu/publications)
Sign in with Wallet
Connect another wallet