(trapped) error reading bcrypt version Traceback (most recent call last): File…
- User
(trapped) error reading bcrypt version Traceback (most recent call last): File "/home/roman/Desktop/projects/learn_for_employment/auth/.venv/lib/python3.13/site-packages/passlib/handlers/bcrypt.py", line 620, in _load_backend_mixin version = _bcrypt.about.version ^^^^^^^^^^^^^^^^^ AttributeError: module 'bcrypt' has no attribute 'about' Original: password123 Hash: 12$JfsR9fbTGEPJdPBmLeiCaef/KfUqmx3pR3Xq88lZA0z2sPWe/ywmS Valid? True
Got this error
===
How we compare passwords everytime if salt make hashes different?
===
Rest of code is working perfectly
===
It okay that we access variables outside functions in global space like with fake_db?
===
Is this last message examples its good knowledge for backend junior?
Assistant
Great questions! Let me address each one:
1. The Bcrypt Error (Don't Worry!)
That error is just a warning - your code still works perfectly! It's a version compatibility issue between
passlibandbcrypt. The hash and verification still work fine.Quick fix (optional):
pip install bcrypt==4.0.1But honestly, since it's working, you can ignore it for learning purposes.
2. Salt + Different Hashes = How Does Verification Work?
Excellent question! This confused me when I first learned it too.
Here's the magic: The salt is stored INSIDE the hash itself.
Look at your hash:
$2b$12$JfsR9fbTGEPJdPBmLeiCaef/KfUqmx3pR3Xq88lZA0z2sPWe/ywmSLet me break this down:
$2b$= bcrypt algorithm version12$= cost factor (how slow/secure)JfsR9fbTGEPJdPBmLeiCae= the salt (22 characters)f/KfUqmx3pR3Xq88lZA0z2sPWe/ywmS= the actual hash
When verifying:
- Extract the salt from the stored hash
- Hash the user's input password with that same salt
- Compare the results
Test this yourself:
from passlib.context import CryptContext pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto") # Hash the same password twice hash1 = pwd_context.hash("password123") hash2 = pwd_context.hash("password123") print(f"Hash 1: {hash1}") print(f"Hash 2: {hash2}") print(f"Different? {hash1 != hash2}") # True - different salts! # But both verify correctly print(f"Hash 1 verifies: {pwd_context.verify('password123', hash1)}") # True print(f"Hash 2 verifies: {pwd_context.verify('password123', hash2)}") # TrueThe salt makes each hash unique, but verification extracts the salt from the stored hash to recreate the same result.
3. Global Variables (fake_db) - Is This OK?
For learning/prototyping: Yes, totally fine!
For production: No, here's why:
# ❌ Problems with global state: fake_db = {} # This gets shared across ALL requests @app.post("/register") def register(user: UserCreate): fake_db[user.username] = user # What if two users register simultaneously?Issues:
- Race conditions: Multiple requests can modify
fake_dbat the same time - Memory leaks: Data never gets cleaned up
- No persistence: Restart the server = lose all users
- Testing: Hard to reset state between tests
Better approaches:
# ✅ Dependency injection with database from sqlalchemy.orm import Session @app.post("/register") def register(user: UserCreate, db: Session = Depends(get_db)): # Each request gets its own database session db_user = User(username=user.username, hashed_password=hash_password(user.password)) db.add(db_user) db.commit()For now: Keep using
fake_dbwhile learning. It's perfect for understanding the concepts without database complexity.4. Is This Good Junior Backend Knowledge?
Absolutely YES! This covers core concepts every backend developer needs:
What You've Learned (Junior+ Level):
✅ Password Security: Hashing, salting, why never store plaintext
✅ JWT Fundamentals: Structure, signing, verification
✅ Authentication Flow: Register → Login → Protected endpoints
✅ FastAPI Patterns: Dependencies, Pydantic models, error handling
✅ HTTP Status Codes: 401 vs 409 vs 201
✅ Security Headers:Authorization: Bearer,WWW-AuthenticateWhat Makes You Stand Out:
- You understand WHY we hash passwords (not just HOW)
- You grasp the stateless nature of JWTs vs sessions
- You can explain the complete auth flow from user input to database
Next Level (Mid-Level):
- Refresh tokens
- Role-based authorization (RBAC)
- OAuth2 flows (Google/GitHub login)
- Rate limiting
- Database migrations
- Environment configuration
For a junior position, what you've built is solid. You can confidently discuss:
- "How do you secure user passwords?" → Bcrypt hashing with salts
- "How does token-based auth work?" → JWT creation, verification, stateless design
- "What happens when a user logs in?" → Walk through the entire flow
Pro tip: In interviews, mention the security considerations you understand (never store plaintext, token expiration, signature verification). That shows you think beyond just "making it work."
Want to tackle any of the next-level topics, or shall we refine what you've built?
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.