experimental_taintUniqueValue

taintUniqueValue(errMessage, lifetime, value)

• குறிப்பு
  • taintUniqueValue(message, lifetime, value)
• பயன்பாடு
  • Token Client Components-க்கு pass செய்யப்படுவதைத் தடுக்கவும்

குறிப்பு

taintUniqueValue(message, lifetime, value)

Password, token, key, அல்லது hash Client-க்கு அப்படியே pass செய்ய அனுமதிக்கப்படக்கூடாத ஒன்று என்று React-இல் register செய்ய, அந்த value உடன் taintUniqueValue-ஐ call செய்யுங்கள்:

import {experimental_taintUniqueValue} from 'react';

experimental_taintUniqueValue(
  'Do not pass secret keys to the client.',
  process,
  process.env.SECRET_KEY
);

மேலும் உதாரணங்களை கீழே பார்க்கவும்.

Parameters

• message: value Client Component-க்கு pass செய்யப்பட்டால் காட்ட வேண்டிய message. value Client Component-க்கு pass செய்யப்பட்டால் throw ஆகும் Error-ன் ஒரு பகுதியாக இந்த message காட்டப்படும்.

• lifetime: value எவ்வளவு நேரம் tainted ஆக இருக்க வேண்டும் என்பதை காட்டும் எந்த object-வும். இந்த object இன்னும் இருக்கும் வரை, value எந்த Client Component-க்கும் அனுப்பப்படுவது தடுக்கப்படும். உதாரணமாக, globalThis pass செய்தால் app-ன் lifetime முழுவதும் value block செய்யப்படும். பொதுவாக lifetime என்பது value-ஐ properties-ல் கொண்டிருக்கும் object ஆகும்.

• value: ஒரு string, bigint, அல்லது TypedArray. value cryptographic token, private key, hash, அல்லது நீண்ட password போன்ற high entropy கொண்ட characters அல்லது bytes-ன் unique sequence ஆக இருக்க வேண்டும். value எந்த Client Component-க்கும் அனுப்பப்படுவது தடுக்கப்படும்.

Returns

experimental_taintUniqueValue undefined return செய்கிறது.

Caveats

• Tainted values-இலிருந்து புதிய values derive செய்வது tainting protection-ஐ பலவீனப்படுத்தலாம். Tainted values-ஐ uppercase செய்வது, tainted string values-ஐ பெரிய string-களில் concatenate செய்வது, tainted values-ஐ base64-க்கு convert செய்வது, tainted values-இன் substring எடுப்பது, மற்றும் இதுபோன்ற transformations மூலம் உருவாகும் புதிய values tainted அல்ல; அவற்றின் மீது explicit-ஆக taintUniqueValue call செய்தால் மட்டுமே tainted ஆகும்.
• PIN codes அல்லது phone numbers போன்ற low-entropy values-ஐப் பாதுகாக்க taintUniqueValue பயன்படுத்த வேண்டாம். ஒரு request-இல் உள்ள எந்த value-யும் attacker-னால் கட்டுப்படுத்தப்பட்டால், secret-ன் அனைத்து சாத்தியமான values-ஐ enumerate செய்து எந்த value tainted என்பதை infer செய்ய முடியும்.

பயன்பாடு

Token Client Components-க்கு pass செய்யப்படுவதைத் தடுக்கவும்

Passwords, session tokens, அல்லது பிற unique values போன்ற sensitive information தவறுதலாக Client Components-க்கு pass செய்யப்படாததை உறுதிசெய்ய, taintUniqueValue function ஒரு பாதுகாப்பு layer வழங்குகிறது. ஒரு value tainted ஆனால், அதை Client Component-க்கு pass செய்யும் எந்த முயற்சியும் error-ஆக முடியும்.

lifetime argument, value எவ்வளவு காலம் tainted ஆக இருக்கும் என்பதை வரையறுக்கிறது. காலவரையின்றி tainted ஆக இருக்க வேண்டிய values-க்கு, globalThis அல்லது process போன்ற objects lifetime argument ஆக பயன்படலாம். இந்த objects உங்கள் app execution முழு காலத்திற்கும் இருக்கும் lifespan கொண்டவை.

import {experimental_taintUniqueValue} from 'react';

experimental_taintUniqueValue(
  'Do not pass a user password to the client.',
  globalThis,
  process.env.SECRET_KEY
);

Tainted value-ன் lifespan ஒரு object-இன் lifespan-ஐ சார்ந்திருந்தால், lifetime அந்த value-ஐ encapsulate செய்யும் object ஆக இருக்க வேண்டும். இதனால் encapsulating object-ன் lifetime முழுவதும் tainted value பாதுகாக்கப்பட்டிருப்பது உறுதியாகும்.

import {experimental_taintUniqueValue} from 'react';

export async function getUser(id) {
  const user = await db`SELECT * FROM users WHERE id = ${id}`;
  experimental_taintUniqueValue(
    'Do not pass a user session token to the client.',
    user,
    user.session.token
  );
  return user;
}

இந்த உதாரணத்தில், user object lifetime argument ஆக செயல்படுகிறது. இந்த object global cache-இல் store செய்யப்பட்டாலோ அல்லது மற்றொரு request மூலம் access செய்யக்கூடியதாக இருந்தாலோ, session token தொடர்ந்து tainted ஆக இருக்கும்.

import {experimental_taintUniqueValue} from 'react';

const password = 'correct horse battery staple';

experimental_taintUniqueValue(
  'Do not pass the password to the client.',
  globalThis,
  password
);

const uppercasePassword = password.toUpperCase() // `uppercasePassword` tainted அல்ல

export async function Dashboard(props) {
  // DO NOT DO THIS
  return <Overview password={process.env.API_PASSWORD} />;
}

"use client";

import {useEffect} from '...'

export async function Overview({ password }) {
  useEffect(() => {
    const headers = { Authorization: password };
    fetch(url, { headers }).then(...);
  }, [password]);
  ...
}

import "server-only";

export function fetchAPI(url) {
  const headers = { Authorization: process.env.API_PASSWORD };
  return fetch(url, { headers });
}

import "server-only";
import {experimental_taintUniqueValue} from 'react';

experimental_taintUniqueValue(
  'Do not pass the API token password to the client. ' +
    'Instead do all fetches on the server.'
  process,
  process.env.API_PASSWORD
);