Stockage des dossiers médicaux sur Blockchain | de Abhishek Chauhan | janvier 2023

Stockez et partagez en toute sécurité vos dossiers médicaux grâce à la puissance des contrats intelligents

Pourquoi?

Le contrat intelligent pour le stockage des dossiers médicaux à accès restreint peut aider à fournir un moyen sûr et transparent de stocker et d’accéder aux dossiers médicaux.

L’utilisation d’un contrat intelligent pour stocker les dossiers médicaux présente plusieurs avantages par rapport aux méthodes traditionnelles de tenue de dossiers. Par exemple, un contrat intelligent est stocké sur un réseau décentralisé, tel que la blockchain Ethereum, ce qui le rend moins vulnérable à la falsification ou aux violations de données que les bases de données centralisées traditionnelles. De plus, les données stockées dans un contrat intelligent sont transparentes et peuvent être auditées par n’importe qui, ce qui peut contribuer à accroître la confiance et la responsabilité.

Les restrictions d’accès aux dossiers médicaux dans le contrat intelligent garantissent que les utilisateurs autorisés n’accèdent aux dossiers et que les dossiers ne sont accessibles que si le rôle de l’utilisateur est suffisamment élevé et que l’heure actuelle est antérieure à la date d’expiration du dossier. Cela aide à protéger la vie privée des patients et garantit que les parties autorisées n’accèdent qu’à leurs informations médicales.

Dans l’ensemble, l’utilisation d’un contrat intelligent pour stocker les dossiers médicaux peut contribuer à améliorer la sécurité, la transparence et la confidentialité des dossiers médicaux, ce qui peut finalement profiter à la fois aux patients et aux prestataires de soins de santé.

Définissez les variables utilisées pour stocker le propriétaire du contrat, les dossiers médicaux, les utilisateurs autorisés et les restrictions d’accès à chaque dossier. Le records et accessRestrictions les variables sont des mappages, des magasins clé-valeur où les clés et les valeurs peuvent être de n’importe quel type.

Le records mappage mappe une clé de type bytes32 à une valeur de type Record, qui est une structure définie ultérieurement dans le contrat. Le authorizedUsers le mappage associe une adresse à une valeur booléenne indiquant si l’utilisateur peut accéder aux enregistrements. Le accessRestrictions mappage cartes un bytes32 clé d’une valeur de type Restrictionsqui est également une structure définie ultérieurement dans le contrat.

pragma solidity ^0.7.0;
// It is important to thoroughly review and test any smart contract before using it.
contract MedicalRecord {
// The address of the owner of the contract.
address private owner;
// The medical records that are being stored.
mapping(bytes32 => Record) private records;
// The authorized users who are allowed to access the records.
mapping(address => bool) private authorizedUsers;
// The restrictions on access to each record.
mapping(bytes32 => Restrictions) private accessRestrictions;

Les lignes ci-dessous définissent le Record et Restrictions structs, qui sont utilisés pour stocker les données d’un seul dossier médical, et les restrictions d’accès à un seul dossier, respectivement. Le Record struct a deux champs : dataqui est un bytes valeur qui stocke les données réelles du dossier médical, et timestampqui est un uint256 valeur qui stocke l’heure à laquelle l’enregistrement a été ajouté ou mis à jour pour la dernière fois. Le Restrictions struct a trois champs : authorizedUsersqui est un mappage qui stocke les utilisateurs autorisés à accéder à l’enregistrement, minRolequi est un uint8 valeur qui stocke le rôle minimum requis pour accéder à l’enregistrement, et expirationDatequi est un uint256 valeur qui stocke la date d’expiration de l’enregistrement.

// The roles that a user can have.
// The data for a single medical record.
struct Record {
bytes data;
uint256 timestamp;
}
// The restrictions on access to a single record.
struct Restrictions {
// The users who are allowed to access the record.
mapping(address => bool) authorizedUsers;
// The minimum role required to access the record.
uint8 minRole;
// The expiration date for the record.
uint256 expirationDate;
}

Maintenant, définissez un enum (énumération) type nommé Roles, qui est utilisé pour représenter les différents rôles qu’un utilisateur peut avoir. Le enum a trois valeurs possibles : Patient, Doctoret Administrator.

// The roles that a user can have.
enum Roles {
Patient,
Doctor,
Administrator
}

Créer un nom de mappage userRoles qui mappe une adresse à une valeur de type Roleslequel est enum défini précédemment. Ce mappage est utilisé pour stocker le rôle de chaque utilisateur. Voici à quoi cela ressemble :

// The role of each user.
mapping(address => Roles) private userRoles;

Créez un constructeur du contrat, qui est appelé lorsque le contrat est déployé. Le constructeur définit le owner variable à l’adresse de l’utilisateur déployant le contrat. Voici comment procéder :

// The constructor sets the owner of the contract.
constructor() public {
owner = msg.sender;
}

Maintenant, créez des fonctions pour permettre au propriétaire du contrat d’autoriser ou de révoquer l’autorisation d’un utilisateur à accéder aux enregistrements et de définir le rôle d’un utilisateur. Le authorizedUsers le mappage est mis à jour pour refléter les modifications du statut d’autorisation. Le userRoles le mappage est également mis à jour pour refléter les changements de rôle. Voici à quoi cela ressemble :

// Only the owner can authorize a user to access records.
function authorizeUser(address user) public onlyOwner {
authorizedUsers[user] = true;
}
// Only the owner can remove a user's authorization to access records.
function removeAuthorization(address user) public onlyOwner {
authorizedUsers[user] = false;
}
// Only the owner can set the role of a user.
function setUserRole(address user, Roles role) public onlyOwner {
userRoles[user] = role;
}

Maintenant, créez une fonction qui permet aux utilisateurs autorisés de récupérer un dossier médical. La fonction prend une clé de type bytes32 comme entrée, qui est utilisée pour identifier l’enregistrement. La fonction extrait d’abord l’enregistrement et ses restrictions du stockage à l’aide de la records et accessRestrictions mappages. La fonction vérifie ensuite si l’heure actuelle est antérieure à la date d’expiration de l’enregistrement, si le rôle de l’utilisateur est égal ou supérieur au rôle minimum requis pour accéder à l’enregistrement et si l’utilisateur est autorisé à accéder à l’enregistrement.

Si l’une de ces conditions n’est pas remplie, la fonction renvoie une erreur. La fonction renvoie les données de l’enregistrement si toutes les conditions sont remplies. Voici ce que vous pouvez voir :

// Only authorized users can access a record if the current time is before the record's expiration date
// and the user's role is equal to or higher than the minimum role required to access the record.
function getRecord(bytes32 key) public view onlyAuthorized returns (bytes memory) {
Record storage record = records[key];
Restrictions storage restrictions = accessRestrictions[key];
require(block.timestamp < restrictions.expirationDate, "This record has expired.");
require(uint8(userRoles[msg.sender]) >= restrictions.minRole, "Your role is not high enough to access this record.");
require(restrictions.authorizedUsers[msg.sender], "You are not authorized to access this record.");
return record.data;
}

setRecord permet au propriétaire d’ajouter ou de mettre à jour un dossier médical. La fonction prend une clé de type bytes32 et les données de l’enregistrement en entrée et la date d’expiration. Il ressemble à ceci :

// Only the owner can add or update a record.
function setRecord(bytes32 key, bytes memory data, uint256 expirationDate, uint8 minRole, address[] memory authorizedUsers) public onlyOwner {
Record storage record = records[key];
record.data = data;
record.timestamp = block.timestamp;
Restrictions storage restrictions = accessRestrictions[key];
restrictions.expirationDate = expirationDate;
restrictions.minRole = minRole;
for (uint i = 0; i < authorizedUsers.length; i++) {
restrictions.authorizedUsers[authorizedUsers[i]] = true;
}
}

deleteRecord fonction permet au propriétaire de supprimer un dossier médical. La fonction prend une clé de type bytes32 en tant qu’entrée et supprime l’enregistrement et ses restrictions du stockage à l’aide de la delete mot-clé. Voici comment procéder :

// Only the owner can delete a record.
function deleteRecord(bytes32 key) public onlyOwner {
delete records[key];
delete accessRestrictions[key];
}

Les lignes suivantes définissent deux modifier les fonctions: onlyOwner et onlyAuthorized. UNE modifier est une fonction qui peut être utilisée pour modifier le comportement d’autres fonctions. Le onlyOwner Le modificateur peut être appliqué à une fonction pour limiter l’appel de la fonction uniquement par le propriétaire du contrat.

Le onlyAuthorized Le modificateur peut être appliqué à une fonction pour restreindre l’appel de la fonction uniquement par les utilisateurs autorisés. Le modifier les fonctions utilisent les require mot-clé pour appliquer les restrictions. Si les conditions spécifiées dans le require l’instruction ne sont pas remplies, la fonction renvoie une erreur.

// Only the owner can call these functions.
modifier onlyOwner {
require(msg.sender == owner, "Only the owner can perform this action.");
_;
}
// Only authorized users can call these functions.
modifier onlyAuthorized {
require(authorizedUsers[msg.sender], "You are not authorized to perform this action.");
_;
}
}