cryptography
/cryptography
Opisuje kryptografię na poziomie aplikacji: hashowanie haseł (bcrypt, argon2), szyfrowanie AES-GCM, podpisy cyfrowe, zarządzanie kluczami i bezpieczne generowanie losowości.
- Autor
- claude-dev-suite ↗
- Repozytorium
- claude-dev-suite ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 21.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 1
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 21.10.2026, bez odwołań do wycofanych modeli i API.
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
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
- Password Hashing
- Symmetric Encryption (AES-256-GCM)
- HMAC (Message Authentication)
- Secure Random Values
- Python
- Anti-Patterns
- Production Checklist
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
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · claude-dev-suite/claude-dev-suite | 100 | MIT |
| yuri-xyz/skills | 100 | MIT |
| Tyler-R-Kendrick/agent-skills | 100 | MIT |
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.