Sertifikat olingYANGIW3Schools ilovasiiOS va AndroidSarguzashtni boshlang

Crypto moduli

ULASHISH

Crypto moduli nima?

Crypto moduli o‘rnatilgan Node.js moduli bo‘lib, kriptografik funksiyalarni ta’minlaydi, jumladan:

  • Xesh funksiyalari (SHA-256, SHA-512 va h.k.)
  • HMAC (xeshga asoslangan xabar autentifikatsiya kodi)
  • Simmetrik shifrlash (AES, DES va h.k.)
  • Asimmetrik shifrlash (RSA, ECDSA va h.k.)
  • Raqamli imzo va tekshirish
  • Xavfsiz tasodifiy sonlarni yaratish

Crypto moduli nozik ma’lumotlarni xavfsiz boshqarishi kerak bo‘lgan ilovalar uchun juda muhimdir.

Crypto moduli OpenSSL kutubxonasini o‘rab oladi (wrapper) va ishonchli, sinovdan o‘tgan kriptografik algoritmlardan foydalanish imkonini beradi.

Ushbu modul ko‘pincha nozik ma’lumotlarni qayta ishlash uchun ishlatiladi, masalan:

  • Foydalanuvchi autentifikatsiyasi va parolni saqlash
  • Ma’lumotlarni xavfsiz uzatish
  • Fayllarni shifrlash va shifrni ochish
  • Xavfsiz aloqa kanallari

Crypto bilan ishlashni boshlash

Crypto modulidan stringni xeshlash uchun foydalanishning tezkor misoli:

Asosiy xeshlash misoli

const crypto = require('crypto');

// Create a SHA-256 hash of a string
const hash = crypto.createHash('sha256')
  .update('Hello, Node.js!')
  .digest('hex');
console.log('SHA-256 Hash:', hash);
O‘zingiz sinab ko‘ring »

Crypto modulini o‘rnatish

Crypto moduli sukut bo‘yicha Node.js tarkibiga kiritilgan.

Uni skriptingizga require qilib ulash orqali foydalanishingiz mumkin:

const crypto = require('crypto');

Xesh funksiyalari

Xeshlash - bu ma’lumotlarni belgilangan uzunlikdagi belgilar stringiga bir tomonlama o‘zgartirish.

Xesh funksiyalari bir nechta muhim xususiyatlarga ega:

  • Deterministik: Bir xil kiritish har doim bir xil natijani beradi
  • Qat’iy uzunlik: Kirish hajmidan qat’i nazar, chiqish har doim bir xil o‘lchamda bo‘ladi
  • Bir tomonlama: Jarayonni orqaga qaytarish juda qiyin
  • Ko‘chki effekti: Kirishdagi kichik o‘zgarishlar chiqishda sezilarli o‘zgarishlarga olib keladi

Keng tarqalgan foydalanish holatlariga quyidagilar kiradi:

  • Parolni saqlash
  • Ma’lumotlar yaxlitligini tekshirish
  • Raqamli imzolar
  • Kontent bo‘yicha manzillash (masalan, Git, IPFS)

Xesh yaratish

const crypto = require('crypto');

// Create a hash object
const hash = crypto.createHash('sha256');

// Update the hash with data
hash.update('Hello, World!');

// Get the digest in hexadecimal format
const digest = hash.digest('hex');
console.log(digest);
O‘zingiz sinab ko‘ring »

Ushbu misolda:

  • createHash() belgilangan algoritm bilan xesh-obyektni yaratadi
  • update() berilgan ma’lumotlar bilan xesh tarkibini yangilaydi
  • digest() dayjestni hisoblab chiqadi va uni belgilangan formatda chiqaradi

Keng tarqalgan xesh algoritmlari

const crypto = require('crypto');
const data = 'Hello, World!';

// MD5 (not recommended for security-critical applications)
const md5 = crypto.createHash('md5').update(data).digest('hex');
console.log('MD5:', md5);

// SHA-1 (not recommended for security-critical applications)
const sha1 = crypto.createHash('sha1').update(data).digest('hex');
console.log('SHA-1:', sha1);

// SHA-256
const sha256 = crypto.createHash('sha256').update(data).digest('hex');
console.log('SHA-256:', sha256);

// SHA-512
const sha512 = crypto.createHash('sha512').update(data).digest('hex');
console.log('SHA-512:', sha512);
O‘zingiz sinab ko‘ring »

Ogohlantirish: MD5 va SHA-1 kriptografik jihatdan zaif hisoblanadi va xavfsizlik uchun muhim ilovalar uchun ishlatilmasligi kerak.

Buning o‘rniga SHA-256, SHA-384 yoki SHA-512 dan foydalaning.

Parol xavfsizligi

Parollar bilan ishlashda brute-force hujumlarining oldini olish uchun ataylab ko‘p hisoblash resursini talab qiladigan qilib ishlab chiqilgan maxsus parol xeshlash funksiyalaridan foydalanish juda muhim.

Oddiy xeshlar nima uchun yetarli emas:

Hech qachon parollarni oddiy matnda yoki MD5 yoki SHA-1 kabi oddiy xeshlar bilan saqlamang.

Ularni rainbow jadvallar yoki brute-force hujumlari yordamida osongina buzish mumkin.

Parol xavfsizligi uchun asosiy tushunchalar

  1. Salt qo‘shish (salting): Xeshlashdan oldin har bir parolga noyob tasodifiy qiymat qo‘shing
  2. Kalitni cho‘zish (key stretching): Brute-force hujumlarining oldini olish uchun xeshlash jarayonini ataylab sekinlashtiring
  3. Ish omili: Xeshlash jarayonining hisoblash intensivligini nazorat qiling

Node.js-da parollarni qanday qilib to‘g‘ri xeshlash mumkin:

Salt nima?
Salt — har bir foydalanuvchi uchun noyob bo‘lgan tasodifiy string.

Ikki foydalanuvchi bir xil parolga ega bo‘lsa ham, ularning xeshlari boshqacha bo‘lishini ta’minlash uchun u xeshlashdan oldin parol bilan birlashtiriladi.

Bu hujumchilarga bir vaqtning o‘zida bir nechta parolni buzish uchun oldindan hisoblangan jadvallardan (masalan, rainbow jadvallardan) foydalanishga yo‘l qo‘ymaydi.

const crypto = require('crypto');

// Function to hash a password
function hashPassword(password) {
  // Generate a random salt (16 bytes)
  const salt = crypto.randomBytes(16).toString('hex');

  // Use scrypt for password hashing (recommended)
  const hash = crypto.scryptSync(password, salt, 64).toString('hex');

  // Return both salt and hash for storage
  return { salt, hash };
}

// Function to verify a password
function verifyPassword(password, salt, hash) {
  const hashedPassword = crypto.scryptSync(password, salt, 64).toString('hex');
  return hashedPassword === hash;
}

// Example usage
const password = 'mySecurePassword';

// Hash the password for storage
const { salt, hash } = hashPassword(password);
console.log('Salt:', salt);
console.log('Hash:', hash);

// Verify a login attempt
const isValid = verifyPassword(password, salt, hash);
console.log('Password valid:', isValid); // true

const isInvalid = verifyPassword('wrongPassword', salt, hash);
console.log('Wrong password valid:', isInvalid); // false
Misolni ishga tushirish »

Eslatma: Parolni ishlab chiqarish muhitida xeshlash uchun bcrypt yoki argon2 kabi xavfsiz parol bilan ishlash uchun mo‘ljallangan maxsus kutubxonadan foydalaning.

HMAC (xeshga asoslangan xabar autentifikatsiya kodi)

HMAC kriptografik xesh funksiyasi va maxfiy kriptografik kalitdan foydalanadigan xabar autentifikatsiya kodining (MAC) maxsus turidir.

U ma’lumotlarning yaxlitligini va autentifikatsiyasini ta’minlaydi.

HMAC-dan qachon foydalanish kerak

  • API so‘rovini tekshirish
  • Xavfsiz cookie’lar va sessiyalar
  • Ma’lumotlar yaxlitligini tekshirish
  • Webhook tekshiruvi

HMAC xavfsizlik xususiyatlari

  • Xabarning yaxlitligi: Xabarga kiritilgan har qanday o‘zgarish boshqa HMAC-ni yaratadi
  • Haqiqiylik: Faqat maxfiy kalitga ega tomonlar haqiqiy HMAC-larni yaratishi mumkin
  • Shifrlash yo‘q: HMAC xabarni shifrlamaydi, faqat uning yaxlitligini tekshiradi
const crypto = require('crypto');

// Secret key
const secretKey = 'mySecretKey';

// Create an HMAC
const hmac = crypto.createHmac('sha256', secretKey);

// Update with data
hmac.update('Hello, World!');

// Get the digest
const hmacDigest = hmac.digest('hex');
console.log('HMAC:', hmacDigest);
O‘zingiz sinab ko‘ring »

Xabarni tekshirish uchun HMAC

const crypto = require('crypto');

// Function to create an HMAC for a message
function createSignature(message, key) {
  const hmac = crypto.createHmac('sha256', key);
  hmac.update(message);
  return hmac.digest('hex');
}

// Function to verify a message's signature
function verifySignature(message, signature, key) {
  const expectedSignature = createSignature(message, key);
  return crypto.timingSafeEqual(
    Buffer.from(signature, 'hex'),
    Buffer.from(expectedSignature, 'hex')
  );
}

// Example usage
const secretKey = 'verySecretKey';
const message = 'Important message to verify';

// Sender creates a signature
const signature = createSignature(message, secretKey);
console.log('Message:', message);
console.log('Signature:', signature);

// Receiver verifies the signature
try {
  const isValid = verifySignature(message, signature, secretKey);
  console.log('Signature valid:', isValid); // true

  // Try with a tampered message
  const isInvalid = verifySignature('Tampered message', signature, secretKey);
  console.log('Tampered message valid:', isInvalid); // false
} catch (error) {
  console.error('Verification error:', error.message);
}
O‘zingiz sinab ko‘ring »

Eslatma: Timing hujumlarining (vaqtga asoslangan hujumlar) oldini olish uchun kriptografik taqqoslash uchun har doim timingSafeEqual() dan foydalaning.

Simmetrik shifrlash

Simmetrik shifrlash ham shifrlash, ham shifrni ochish uchun bir xil kalitdan foydalanadi.

Bu odatda asimmetrik shifrlashdan tezroq va quyidagilar uchun idealdir:

  • Katta hajmdagi ma’lumotlarni shifrlash
  • Ma’lumotlar bazasini shifrlash
  • Fayl tizimini shifrlash
  • Xavfsiz xabar almashish (kalit almashinuvi bilan birgalikda)

Keng tarqalgan simmetrik algoritmlar

Algoritm Kalit o‘lchami Blok o‘lchami Izohlar
AES-256 256 bit 128 bit Joriy standart, keng qo‘llaniladi
ChaCha20 256 bit 512 bit Dasturiy ta’minotda tezroq, TLS 1.3 da ishlatiladi
3DES 168 bit 64 bit Eskirgan (legacy), yangi tizimlar uchun tavsiya etilmaydi
Blowfish 32-448 bit 64 bit Eskirgan (legacy), uning o‘rniga Twofish yoki AES’dan foydalaning

Eslatma: Iloji bo‘lsa, har doim AES-GCM yoki AES-CCM kabi autentifikatsiya qilingan shifrlash rejimlaridan foydalaning, chunki ular ham maxfiylik, ham haqiqiylikni ta’minlaydi.

AES (Advanced Encryption Standard)

const crypto = require('crypto');

// Function to encrypt data
function encrypt(text, key) {
  // Generate a random initialization vector
  const iv = crypto.randomBytes(16);

  // Create cipher with AES-256-CBC
  const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);

  // Encrypt the data
  let encrypted = cipher.update(text, 'utf8', 'hex');
  encrypted += cipher.final('hex');

  // Return both the encrypted data and the IV
  return {
    iv: iv.toString('hex'),
    encryptedData: encrypted
  };
}

// Function to decrypt data
function decrypt(encryptedData, iv, key) {
  // Create decipher
  const decipher = crypto.createDecipheriv(
    'aes-256-cbc',
    key,
    Buffer.from(iv, 'hex')
  );

  // Decrypt the data
  let decrypted = decipher.update(encryptedData, 'hex', 'utf8');
  decrypted += decipher.final('utf8');

  return decrypted;
}

// Example usage
// Note: In a real application, use a properly generated and securely stored key
const key = crypto.scryptSync('secretPassword', 'salt', 32); // 32 bytes = 256 bits
const message = 'This is a secret message';

// Encrypt
const { iv, encryptedData } = encrypt(message, key);
console.log('Original:', message);
console.log('Encrypted:', encryptedData);
console.log('IV:', iv);

// Decrypt
const decrypted = decrypt(encryptedData, iv, key);
console.log('Decrypted:', decrypted);
Misolni ishga tushirish »

Ogohlantirish: Hech qachon bir xil initsializatsiya vektorini (IV) bir xil kalit bilan qayta ishlatmang.

Har bir shifrlash operatsiyasi uchun har doim yangi tasodifiy IV ni yarating.

Boshqa simmetrik algoritmlar

Crypto moduli turli simmetrik shifrlash algoritmlarini qo‘llab-quvvatlaydi.

Mavjud shifrlarni ko‘rishingiz mumkin:

const crypto = require('crypto');

// List available cipher algorithms
console.log(crypto.getCiphers());
O‘zingiz sinab ko‘ring »

Asimmetrik shifrlash

Asimmetrik shifrlash (ochiq kalitli kriptografiya) bir juft matematik bog‘liq kalitlardan foydalanadi:

  • Ochiq kalit: Hammaga ochiq bo‘lishi mumkin, shifrlash uchun ishlatiladi
  • Shaxsiy kalit: Maxfiy saqlanishi kerak, shifrni ochish uchun ishlatiladi

Keng tarqalgan foydalanish holatlari

  • Kalitlarni xavfsiz almashish (masalan, TLS/SSL handshake)
  • Raqamli imzolar
  • Elektron pochtani shifrlash (PGP/GPG)
  • Blokcheyn va kriptovalyutalar

Keng tarqalgan asimmetrik algoritmlar

Algoritm Kalit o‘lchami Xavfsizlik darajasi Izohlar
RSA 2048+ bit Yuqori Keng qo‘llaniladi, yaxshi moslik
ECDSA 256-521 bit Yuqori TLS 1.3 va Bitcoin’da ishlatiladi
Ed25519 256 bit Juda yuqori Zamonaviy, samarali, SSH’da ishlatiladi

Unumdorlik haqida eslatma: Asimmetrik shifrlash simmetrik shifrlashdan ancha sekinroq.

Katta hajmdagi ma’lumotlarni shifrlash uchun gibrid yondashuvdan foydalaning:

  1. Tasodifiy simmetrik kalitni yarating
  2. Ma’lumotlaringizni simmetrik kalit bilan shifrlang
  3. Simmetrik kalitni qabul qiluvchining ochiq kaliti bilan shifrlang
  4. Shifrlangan ma’lumotlarni ham, shifrlangan kalitni ham yuboring

RSA (Rivest-Shamir-Adleman)

const crypto = require('crypto');

// Generate RSA key pair
function generateKeyPair() {
  return crypto.generateKeyPairSync('rsa', {
    modulusLength: 2048, // Key size in bits
    publicKeyEncoding: {
      type: 'spki',
      format: 'pem'
    },
    privateKeyEncoding: {
      type: 'pkcs8',
      format: 'pem'
    }
  });
}

// Encrypt with public key
function encryptWithPublicKey(text, publicKey) {
  const buffer = Buffer.from(text, 'utf8');
  const encrypted = crypto.publicEncrypt(
    {
      key: publicKey,
      padding: crypto.constants.RSA_PKCS1_OAEP_PADDING
    },
    buffer
  );
  return encrypted.toString('base64');
}

// Decrypt with private key
function decryptWithPrivateKey(encryptedText, privateKey) {
  const buffer = Buffer.from(encryptedText, 'base64');
  const decrypted = crypto.privateDecrypt(
    {
      key: privateKey,
      padding: crypto.constants.RSA_PKCS1_OAEP_PADDING
    },
    buffer
  );
  return decrypted.toString('utf8');
}

// Generate keys
const { publicKey, privateKey } = generateKeyPair();
console.log('Public Key:', publicKey.substring(0, 50) + '...');
console.log('Private Key:', privateKey.substring(0, 50) + '...');

// Example usage
const message = 'This message is encrypted with RSA';
const encrypted = encryptWithPublicKey(message, publicKey);
console.log('Encrypted:', encrypted.substring(0, 50) + '...');

const decrypted = decryptWithPrivateKey(encrypted, privateKey);
console.log('Decrypted:', decrypted);
Misolni ishga tushirish »

Eslatma: RSA odatda unumdorlik cheklovlari tufayli kichik hajmdagi ma’lumotlarni (masalan, shifrlash kalitlari) shifrlash uchun ishlatiladi.

Kattaroq ma’lumotlar uchun gibrid yondashuvdan foydalaning: ma’lumotlarni simmetrik algoritm bilan shifrlang (masalan, AES) va simmetrik kalitni RSA bilan shifrlang.

Raqamli imzolar

Raqamli imzolar xabarlar, dasturiy ta’minot yoki raqamli hujjatlarning haqiqiyligi va yaxlitligini tekshirish usulini ta’minlaydi.

const crypto = require('crypto');

// Generate RSA key pair
const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa', {
  modulusLength: 2048,
  publicKeyEncoding: {
    type: 'spki',
    format: 'pem'
  },
  privateKeyEncoding: {
    type: 'pkcs8',
    format: 'pem'
  }
});

// Function to sign a message
function signMessage(message, privateKey) {
  const signer = crypto.createSign('sha256');
  signer.update(message);
  return signer.sign(privateKey, 'base64');
}

// Function to verify a signature
function verifySignature(message, signature, publicKey) {
  const verifier = crypto.createVerify('sha256');
  verifier.update(message);
  return verifier.verify(publicKey, signature, 'base64');
}

// Example usage
const message = 'This message needs to be signed';
const signature = signMessage(message, privateKey);
console.log('Message:', message);
console.log('Signature:', signature.substring(0, 50) + '...');

// Verify the signature
const isValid = verifySignature(message, signature, publicKey);
console.log('Signature valid:', isValid); // true

// Verify with a modified message
const isInvalid = verifySignature('Modified message', signature, publicKey);
console.log('Modified message valid:', isInvalid); // false
Misolni ishga tushirish »

Tasodifiy ma’lumotlarni yaratish

Xavfsiz tasodifiy ma’lumotlarni yaratish kalitlar, salt’lar va initsializatsiya vektorlarini (IV) yaratish kabi ko‘plab kriptografik operatsiyalar uchun muhimdir.

const crypto = require('crypto');

// Generate random bytes
const randomBytes = crypto.randomBytes(16);
console.log('Random bytes:', randomBytes.toString('hex'));

// Generate a random string (Base64)
const randomString = crypto.randomBytes(32).toString('base64');
console.log('Random string:', randomString);

// Generate a random number between 1 and 100
function secureRandomNumber(min, max) {
  // Ensure we have enough randomness
  const range = max - min + 1;
  const bytesNeeded = Math.ceil(Math.log2(range) / 8);
  const maxValue = 256 ** bytesNeeded;

  // Generate random bytes and convert to a number
  const randomBytes = crypto.randomBytes(bytesNeeded);
  const randomValue = randomBytes.reduce((acc, byte, i) => {
    return acc + byte * (256 ** i);
  }, 0);

  // Scale to our range and shift by min
  return min + Math.floor((randomValue * range) / maxValue);
}

// Example: Generate 5 random numbers
for (let i = 0; i < 5; i++) {
  console.log(`Random number ${i+1}:`, secureRandomNumber(1, 100));
}
Misolni ishga tushirish »

Xavfsizlik bo‘yicha eng yaxshi amaliyotlar

Crypto modulidan foydalanganda quyidagi eng yaxshi amaliyotlarni yodda tuting:

  • Zamonaviy algoritmlardan foydalaning: MD5, SHA-1 va boshqa eskirgan algoritmlardan saqlaning.
  • Kalitlarni xavfsiz boshqarish: Kalitlarni xavfsiz saqlang, ularni muntazam almashtirib turing va hech qachon kodga qattiq yozib qo‘ymang (hardcode)
  • Tasodifiy IV dan foydalaning: Har bir shifrlash operatsiyasi uchun yangi tasodifiy IV ni yarating
  • Autentifikatsiya qo‘shish: Iloji bo‘lsa, GCM kabi autentifikatsiya qilingan shifrlash rejimlaridan foydalaning
  • Doimiy vaqtdagi taqqoslashlar: Xavfsizlik uchun muhim qiymatlarni solishtirish uchun har doim crypto.timingSafeEqual() dan foydalaning
  • Kalit hosil qilish (key derivation): Parolga asoslangan kalitlar uchun scrypt, bcrypt yoki PBKDF2 kabi tegishli kalit hosil qilish funksiyalaridan foydalaning
  • Yangilanib turing: Xavfsizlik tuzatishlari va yangi algoritmlarni qo‘llab-quvvatlash uchun Node.js-ni yangilab turing.
  • Standartlarga rioya qiling: Belgilangan kriptografik standartlar va protokollarga rioya qiling

Ogohlantirish: Kriptografiya murakkab va xatolar jiddiy xavfsizlik zaifliklariga olib kelishi mumkin.

Muhim xavfsizlik xususiyatlarini amalga oshirishda xavfsizlik bo‘yicha mutaxassis bilan maslahatlashishni yoki muayyan kriptografik vazifalar uchun mo‘ljallangan ishonchli, keng qo‘llaniladigan kutubxonalardan foydalanishni o‘ylab ko‘ring.

Xulosa

Node.js Crypto moduli kriptografik funksiyalarning keng doirasini taqdim etadi:

  • Ma’lumotlar yaxlitligi va barmoq izlari uchun xesh funksiyalari
  • Autentifikatsiya va yaxlitlikni tekshirish uchun HMAC
  • Umumiy kalitlar yordamida ma’lumotlarni himoya qilish uchun simmetrik shifrlash
  • Xavfsiz aloqa va raqamli imzo uchun asimmetrik shifrlash
  • Kriptografik operatsiyalar uchun tasodifiy ma’lumotlarni yaratish
  • Haqiqiylikni tekshirish uchun raqamli imzolar

Ushbu kriptografik tushunchalarni tushunish va to‘g‘ri amalga oshirish orqali siz nozik ma’lumotlar va aloqalarni himoya qiluvchi xavfsiz ilovalarni yaratishingiz mumkin.


‹ OrqagaKeyingisi

W3Schools Pathfinder

Yutuqlaringizni kuzating – bu bepul!

Ro'yxatdan o'tishKirish