Przejdź do treści
Biblioteka skilli
Bezpieczeństwo · Budowanie i kod

cryptography

/cryptography

Opisuje kryptografię na poziomie aplikacji: hashowanie haseł (bcrypt, argon2), szyfrowanie AES-GCM, podpisy cyfrowe, zarządzanie kluczami i bezpieczne generowanie losowości.

Licencja
MIT
Ostatnia zmiana repozytorium
21.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 21.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Opisuje kryptografię na poziomie aplikacji: hashowanie haseł (bcrypt, argon2), szyfrowanie AES-GCM, podpisy cyfrowe, zarządzanie kluczami i bezpieczne generowanie losowości.

Wyzwalacze z opisu

encryptionhashingbcryptargon2AEScryptographydigital signaturekey management
Oryginalny opis (EN)

Application-level cryptography. Password hashing (bcrypt, argon2), encryption (AES-GCM), digital signatures, key management, and secure random generation. USE WHEN: user mentions "encryption", "hashing", "bcrypt", "argon2", "AES", "cryptography", "digital signature", "key management", "HMAC" DO NOT USE FOR: TLS/HTTPS configuration - use infrastructure skills; JWT tokens - use `jwt`; OAuth flows - use `oauth2`

Jak działa

  1. Password Hashing
  2. Symmetric Encryption (AES-256-GCM)
  3. HMAC (Message Authentication)
  4. Secure Random Values
  5. Python
  6. Anti-Patterns
  7. Production Checklist
Sekcje z nagłówków SKILL.md, w oryginale · 133 linii, 430 słów
Podgląd SKILL.md
---
name: cryptography
description: |
  Application-level cryptography. Password hashing (bcrypt, argon2), encryption
  (AES-GCM), digital signatures, key management, and secure random generation.

  USE WHEN: user mentions "encryption", "hashing", "bcrypt", "argon2", "AES",
  "cryptography", "digital signature", "key management", "HMAC"

  DO NOT USE FOR: TLS/HTTPS configuration - use infrastructure skills;
  JWT tokens - use `jwt`; OAuth flows - use `oauth2`
allowed-tools: Read, Grep, Glob, Write, Edit
---
# Cryptography

## Password Hashing

### bcrypt (recommended for most apps)

```typescript
import bcrypt from 'bcrypt';

const SALT_ROUNDS = 12;

async function hashPassword(password: string): Promise<string> {
  return bcrypt.hash(password, SALT_ROUNDS);
}

async function verifyPassword(password: string, hash: string): Promise<boolean> {
  return bcrypt.compare(password, hash);
}
```

### Argon2 (recommended for high-security)

```typescript
import argon2 from 'argon2';

async function hashPassword(password: string): Promise<string> {
  return argon2.hash(password, {
    type: argon2.argon2id,
    memoryCost: 65536,  // 64 MB
    timeCost: 3,
    parallelism: 4,
  });
}

async function verifyPassword(password: string, hash: string): Promise<boolean> {
  return argon2.verify(hash, password);
}
```

## Symmetric Encryption (AES-256-GCM)

```typescript
import { createCipheriv, createDecipheriv, randomBytes } from 'crypto';

const ALGORITHM = 'aes-256-gcm';

function encrypt(plaintext: string, key: Buffer): string {
  const iv = randomBytes(12);
  const cipher = createCipheriv(ALGORITHM, key, iv);
  const encrypted = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
  const authTag = cipher.getAuthTag();
  return Buffer.concat([iv, authTag, encrypted]).toString('base64');
}

function decrypt(ciphertext: string, key: Buffer): string {
  const buf = Buffer.from(ciphertext, 'base64');
  const iv = buf.subarray(0, 12);
  const authTag = buf.subarray(12, 28);
  const encrypted = buf.subarray(28);
  const decipher = createDecipheriv(ALGORITHM, key, iv);
  decipher.setAuthTag(authTag);
  return decipher.update(encrypted) + decipher.final('utf8');
}

// Key from environment (32 bytes for AES-256)
const key = Buffer.from(process.env.ENCRYPTION_KEY!, 'hex');
```

## HMAC (Message Authentication)

```typescript
import { createHmac, timingSafeEqual } from 'crypto';

function signPayload(payload: string, secret: string): string {
  return createHmac('sha256', secret).update(payload).digest('hex');
}

function verifySignature(payload: string, signature: string, secret: string): boolean {
  const expected = signPayload(payload, secret);
  return timingSafeEqual(Buffer.from(signature), Buffer.from(expected));
}
```

## Secure Random Values

```typescript
import { randomBytes, randomUUID } from 'crypto';

const token = randomBytes(32).toString('hex');  // 64-char hex token
const uuid = randomUUID();                       // UUID v4
```

## Python

```python
from passlib.hash import argon2
import os
from cryptography.fernet import Fernet

# Password hashing
hashed = argon2.hash("password")
is_valid = argon2.verify("password", hashed)

# Symmetric encryption
key = Fernet.generate_key()  # Store securely
f = Fernet(key)
encrypted = f.encrypt(b"sensitive data")
decrypted = f.decrypt(encrypted)

# Secure random
token = os.urandom(32).hex()
```

## Anti-Patterns

| Anti-Pattern | Fix |
|--------------|-----|
| MD5/SHA for passwords | Use bcrypt or argon2 |
| ECB mode encryption | Use GCM (authenticated encryption) |
| Hardcoded keys | Use environment variables or KMS |
| `Math.random()` for tokens | Use `crypto.randomBytes()` |
| String comparison for signatures | Use `timingSafeEqual()` to prevent timing attacks |
| Reusing IV/nonce | Generate fresh random IV for each encryption |

## Production Checklist

- [ ] bcrypt (cost 12+) or argon2id for passwords
- [ ] AES-256-GCM for symmetric encryption
- [ ] Keys in environment variables or KMS
- [ ] `crypto.randomBytes` for all random tokens
- [ ] `timingSafeEqual` for signature verification
- [ ] Key rotation plan documented

Wersje

RepozytoriumWynikLicencja
Ta strona · claude-dev-suite/claude-dev-suite100MIT
yuri-xyz/skills100MIT
Tyler-R-Kendrick/agent-skills100MIT

Migawka bazy z 13.11.2026 · wersja paczki ece0917a11d0 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100secure-password-hashing-argon2id-bcrypt
    Przechowuje hasła użytkowników bezpiecznie, haszując je algorytmami Argon2id lub bcrypt.
  • 100crypto-audit
    Audytuje implementację kryptografii: dobór algorytmów, długości kluczy, parametry KDF, nonce, weryfikację podpisów i TLS.
  • 100applied-cryptography-symmetric-aes-gcm-chacha20
    Pomaga szyfrować dane w spoczynku i w transmisji uwierzytelnionymi szyframi AES-256-GCM oraz ChaCha20.
  • 100crypto
    Audytuje kryptografię w kodzie: słabe hashowanie, przechowywanie haseł, zaszyte klucze, TLS, certyfikaty i generowanie liczb losowych, zgodnie z OWASP Top 10 2021 A02.
  • 90crypto-review
    Sprawdza w kodzie kryptografię: szyfrowanie, podpisy, haszowanie haseł, losowość, JWT, TLS i klucze, z poprawką i bezpieczną alternatywą.
  • 100implementing-aes-encryption-for-data-at-rest
    Prowadzi wdrożenie szyfrowania AES-256 w trybie GCM dla danych w spoczynku: wyprowadzanie kluczy, zarządzanie nonce i uwierzytelnione szyfrowanie.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.