Journal de développement de contrats intelligents en Rust (7) Précision des calculs pour la sécurité des contrats

Cet article présentera le contrôle d'accès dans les smart contracts Rust sous deux aspects :

1. La visibilité des méthodes de contrat
2. Contrôle d'accès des fonctions de privilège

1. Visibilité des fonctions de contrat

La visibilité des fonctions de contrat détermine qui peut appeler ces fonctions. Bien régler la visibilité est essentiel pour protéger les parties clés du contrat.

Dans les smart contracts Rust, la visibilité des fonctions se décline principalement en plusieurs types :

• pub fn: fonction publique, peut être appelée depuis l'extérieur du contrat
• fn: fonction interne, ne peut être appelée que dans le contrat
• pub(crate) fn: restriction d'appel à l'intérieur de crate

De plus, il est possible de le définir comme méthode interne en définissant des méthodes dans un bloc de code impl Contract séparé :

rouille #[near_bindgen] impl Contrat { pub fn increment(&mut self) { self.internal_increment(); } }

impl Contrat { pub fn internal_increment(&mut self) { self.counter += 1; } }

Pour les fonctions de rappel, il est nécessaire de les définir comme pub et d'utiliser le macro #[private] pour limiter les appels uniquement à partir du contrat lui-même:

rouille #[near_bindgen] impl Contrat { #[private] pub fn resolve_transfer(&mut self) { // logique de rappel } }

2. Contrôle d'accès des fonctions privilégiées

En plus de définir la visibilité des fonctions, il est également nécessaire d'établir un mécanisme de liste blanche de contrôle d'accès pour restreindre l'appel des fonctions privilégiées.

Il est possible de réaliser un trait Ownable similaire à ce qui suit :

rouille pub trait Ownable { fn assert_owner(&self) { assert_eq!(env::predecessor_account_id(), self.get_owner()); } AccountId; fn set_owner(&mut self, owner: AccountId); }

Ensuite, dans la fonction de privilège, appelez assert_owner() pour vérifier l'identité de l'appelant :

rouille impl Contrat { pub fn privileged_function(&mut self) { self.assert_owner(); // logique de fonction privilège } }

Cela permet de réaliser un contrôle de permission de base pour le propriétaire. Il peut être étendu à des listes blanches multi-utilisateurs ou à plusieurs groupes de listes blanches pour un contrôle d'accès plus précis.

En plus de cela, il convient également de considérer des solutions de contrôle d'accès plus complexes telles que le contrôle de moment d'appel et les mécanismes de multi-signature. Il est essentiel de définir correctement la visibilité des fonctions de contrat et le contrôle d'accès pour garantir la sécurité du contrat.