You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
'Do not pass ALL environment variables to the client.',
48
+
'Ne passez pas TOUTES les variables d’environnement au client.',
49
49
process.env
50
50
);
51
51
```
52
52
53
-
[See more examples below.](#usage)
53
+
[Voir plus d'exemples ci-dessous](#usage).
54
54
55
-
#### Parameters {/*parameters*/}
55
+
#### Paramètres {/*parameters*/}
56
56
57
-
*`message`: The message you want to display if the object gets passed to a Client Component. This message will be displayed as a part of the Error that will be thrown if the object gets passed to a Client Component.
57
+
*`message` : le message que vous souhaitez afficher si l'objet est passé à un Composant Client. Ce message fera partie de l'erreur qui sera levée si l'objet est passé à un Composant Client.
58
58
59
-
*`object`: The object to be tainted. Functions and class instances can be passed to `taintObjectReference` as `object`. Functions and classes are already blocked from being passed to Client Components but the React's default error message will be replaced by what you defined in `message`. When a specific instance of a Typed Array is passed to `taintObjectReference` as `object`, any other copies of the Typed Array will not be tainted.
59
+
*`object` : l'objet a « ternir ». Les fonctions et instances de classes peuvent être passées en tant qu'`object` à `taintObjectReference`. React empêche d'entrée de jeu leur passage aux Composants Clients, mais ça remplacera le message d'erreur par défaut avec ce que vous aurez passé comme `message`. Notez que lorsqu'une instance précise d'un tableau typé *(Typed Array, NdT)* est passée comme `object` à `taintObjectReference`, les copies de ce tableau typé ne seront quant à elles pas ternies.
-Recreating or cloning a tainted object creates a new untained object which main contain sensetive data. For example, if you have a tainted`user`object, `const userInfo = {name: user.name, ssn: user.ssn}`or`{...user}`will create new objects which are not tainted. `taintObjectReference`only protects against simple mistakes when the object is passed through to a Client Component unchanged.
67
+
-Recréer ou cloner un objet terni produit un nouvel objet intact, susceptible de contenir des données sensibles. Si par exemple vous avez un objet`user`terni, `const userInfo = {name: user.name, ssn: user.ssn}`ou`{...user}`produiront de nouveaux objets qui ne seront, eux, pas ternis. `taintObjectReference`ne protège que contre les bévues simples lorsque l'objet est passé tel quel à un Composant Client.
68
68
69
69
<Pitfall>
70
70
71
-
**Do not rely on just tainting for security.**Tainting an object doesn't prevent leaking of every possible derived value. For example, the clone of a tainted object will create a new untained object. Using data from a tainted object (e.g.`{secret: taintedObj.secret}`) will create a new value or object that is not tainted. Tainting is a layer of protection, a secure app will have multiple layers of protection, well designed APIs, and isolation patterns.
71
+
**Ne comptez pas sur le ternissement pour garantir la sécurité.**Ternir un objet n'empêche pas la fuite de toute donnée dérivée imaginable. Un clone de l'objet terni créera par exemple un objet intact. L'utilisation de données d'un objet terni (ex.`{secret: taintedObj.secret}`) crée une nouvelle valeur, ou un nouvel objet, qui ne sera pas terni·e. Le ternissement est une couche de protection, mais une appli sécurisée aura plusieurs couches de protection complémentaires, des API soigneusement conçues et des mécanismes d'isolation en place.
72
72
73
73
</Pitfall>
74
74
75
75
---
76
76
77
-
## Usage {/*usage*/}
77
+
## Utilisation {/*usage*/}
78
78
79
-
### Prevent user data from unintentionally reaching the client {/*prevent-user-data-from-unintentionally-reaching-the-client*/}
79
+
### Empêcher des données utilisateur d'atteindre le client par inadvertance {/*prevent-user-data-from-unintentionally-reaching-the-client*/}
80
80
81
-
A Client Component should never accept objects that carry sensitive data. Ideally, the data fetching functions should not expose data that the current user should not have access to. Sometimes mistakes happen during refactoring. To protect against this mistakes happening down the line we can "taint" the user object in our data API.
81
+
Un Composant Client ne devrait jamais accepter des objets comportant des données sensibles. Dans l'idéal, les fonctions de chargement de données ne devraient pas exposer des données auxquelles l'utilisateur actif n'a pas accès. Mais des erreurs peuvent survenir lors d'une refonte du code. Pour se protéger contre des erreurs en aval nous pouvons « ternir » l'objet utilisateur dans notre API de données.
constuser=await db`SELECT * FROM users WHERE id = ${id}`;
88
88
experimental_taintObjectReference(
89
-
'Do not pass the entire user object to the client. '+
90
-
'Instead, pick off the specific properties you need for this use case.',
89
+
'Ne passez pas l’objet utilisateur entier au client. '+
90
+
'Récupérez plutôt les propriétés spécifiques à votre scénario.',
91
91
user,
92
92
);
93
93
return user;
94
94
}
95
95
```
96
96
97
-
Now whenever anyone tries to pass this object to a Client Component, an error will be thrown with the passed in error message instead.
97
+
Désormais, si un code serveur quelconque essaie de passer cet objet à un Composant Client, une erreur sera levée avec le message d'erreur fourni.
98
98
99
99
<DeepDive>
100
100
101
-
#### Protecting against leaks in data fetching {/*protecting-against-leaks-in-data-fetching*/}
101
+
#### Se protéger contre les fuites lors du chargement de données {/*protecting-against-leaks-in-data-fetching*/}
102
102
103
-
If you're running a Server Components environment that has access to sensitive data, you have to be careful not to pass objects straight through:
103
+
Si votre environnement de Composants Serveur a accès à des données sensibles, vous devez être attentif·ve à ne pas passer des objets directement :
104
104
105
105
```js
106
106
// api.js
@@ -116,7 +116,7 @@ import { InfoCard } from 'components.js';
116
116
117
117
exportasyncfunctionProfile(props) {
118
118
constuser=awaitgetUser(props.userId);
119
-
//DO NOT DO THIS
119
+
//NE FAITES PAS ÇA
120
120
return<InfoCard user={user} />;
121
121
}
122
122
```
@@ -130,24 +130,24 @@ export async function InfoCard({ user }) {
130
130
}
131
131
```
132
132
133
-
Ideally, the `getUser`should not expose data that the current user should not have access to. To prevent passing the `user`object to a Client Component down the line we can "taint" the user object:
133
+
Dans l'idéal, `getUser`ne devait pas exposer de données auxquelles l'utilisateur courant n'a pas accès. Pour empêcher le passage en aval de l'objet `user`à un Composant Client, nous pouvons décider de « ternir » cet objet :
0 commit comments