diff --git a/SECURITY_ANALYSIS.md b/SECURITY_ANALYSIS.md new file mode 100644 index 00000000..903fda58 --- /dev/null +++ b/SECURITY_ANALYSIS.md @@ -0,0 +1,397 @@ +# Analiza Bezpieczeństwa CyberChef +**Data:** 2025-12-18 +**Audytor:** Claude Code + +## Podsumowanie Wykonawcze + +Przeprowadzono kompleksową analizę bezpieczeństwa projektu CyberChef, obejmującą: +- Audyt zależności npm (35 podatności wykrytych) +- Analizę kodu źródłowego pod kątem luk bezpieczeństwa +- Przegląd implementacji kryptograficznych +- Identyfikację potencjalnych wektorów ataku XSS i injection + +--- + +## 1. Podatności w Zależnościach (KRYTYCZNE) + +### 1.1 Podsumowanie +``` +Łącznie: 35 podatności +- Krytyczne: 8 +- Wysokie: 8 +- Średnie: 11 +- Niskie: 8 +``` + +### 1.2 Najważniejsze Podatności + +#### A. @babel/runtime, @babel/helpers, @babel/runtime-corejs3 (ŚREDNIE) +- **CVE:** GHSA-968p-4wvh-cqc8 +- **Opis:** Nieefektywna złożoność RegExp w wygenerowanym kodzie +- **CWE:** CWE-1333 (ReDoS) +- **CVSS:** 6.2 +- **Wersja podatna:** < 7.26.10 +- **Rozwiązanie:** Aktualizacja do >= 7.26.10 +```bash +npm install @babel/runtime@^7.26.10 @babel/helpers@^7.26.10 +``` + +#### B. ws (WYSOKIE) +- **CVE:** GHSA-3h5v-q93c-6h6q +- **Opis:** DoS podczas obsługi requestów z wieloma nagłówkami HTTP +- **Wersja podatna:** 2.1.0 - 5.2.3 +- **Rozwiązanie:** Aktualizacja websocket-stream +```bash +npm audit fix +``` + +#### C. webpack-dev-server (ŚREDNIE) +- **CVE:** GHSA-9jgg-88mc-972h, GHSA-4v9v-hfq4-rm2v +- **Opis:** Możliwość kradzieży kodu źródłowego poprzez złośliwe strony +- **Wersja podatna:** <= 5.2.0 +- **Rozwiązanie:** Aktualizacja do 5.2.2+ +```bash +npm install webpack-dev-server@^5.2.2 +``` + +#### D. shelljs (ŚREDNIE) +- **CVE:** GHSA-4rq4-32rv-6wp6 +- **Opis:** Niewłaściwe zarządzanie uprawnieniami +- **Rozwiązanie:** Rozważyć zastąpienie grunt-chmod nowszą wersją + +#### E. tmp (NISKIE) +- **CVE:** GHSA-52f5-9888-hmc6 +- **Opis:** Możliwość zapisu plików tymczasowych przez symlinki +- **Wersja podatna:** <= 0.2.3 +- **Rozwiązanie:** Aktualizacja do >= 0.2.4 + +#### F. @eslint/plugin-kit (NISKIE) +- **CVE:** 1106734 +- **Opis:** ReDoS w ConfigCommentParser +- **Rozwiązanie:** Aktualizacja ESLint + +#### G. bcryptjs (ZALECANE) +- **Obecna wersja:** 2.4.3 +- **Dostępna wersja:** 3.0.3 +- **Zalecenie:** Aktualizacja do najnowszej wersji dla poprawek bezpieczeństwa + +--- + +## 2. Podatności w Kodzie Źródłowym + +### 2.1 Użycie eval() (KRYTYCZNE) + +**Lokalizacja:** `src/web/waiters/OutputWaiter.mjs:373` + +```javascript +eval(scriptElements[i].innerHTML); // eslint-disable-line no-eval +``` + +**Problem:** +- Wykonanie arbitrary JavaScript z zawartości HTML +- Potencjalny XSS jeśli HTML pochodzi z niezaufanego źródła +- eval() jest jedną z najbardziej niebezpiecznych funkcji JS + +**Zalecenie:** +```javascript +// Zamiast eval(), użyć bezpieczniejszych alternatyw: +// 1. Użyć Function constructor (nieco bezpieczniejszy) +// 2. Używać CSP (Content Security Policy) do blokowania eval +// 3. Przerobić na deklaratywne podejście bez wykonywania kodu + +// Przykład z Function: +try { + const scriptFunction = new Function(scriptElements[i].innerHTML); + scriptFunction(); +} catch (err) { + log.error(err); +} +``` + +**Ryzyko:** WYSOKIE - możliwy XSS i arbitrary code execution + +--- + +### 2.2 Użycie innerHTML (ŚREDNIE) + +**Wykryto 20+ wystąpień innerHTML w kodzie** + +**Przykłady potencjalnie niebezpieczne:** + +#### A. `src/web/utils/htmlWidget.mjs:34` +```javascript +wrap.innerHTML = this.html; +``` +**Analiza:** +- Bezpośrednie ustawienie HTML bez sanityzacji +- JEDNAK: Kod później wywołuje `walkTextNodes()` i `Utils.escapeHtml()` +- **Status:** Akceptowalne z zastrzeżeniami + +#### B. `src/web/App.mjs:660` +```javascript +notice.innerHTML = compileInfo; +``` +**Analiza:** +- compileInfo pochodzi z window.compileMessage +- Należy upewnić się, że źródło jest zaufane +- **Zalecenie:** Dodać sanityzację + +#### C. `src/web/App.mjs:734-735` +```javascript +document.getElementById("confirm-title").innerHTML = title; +document.getElementById("confirm-body").innerHTML = body; +``` +**Analiza:** +- Należy sprawdzić źródła zmiennych title i body +- **Zalecenie:** Użyć textContent lub sanityzacji + +**Ogólne Zalecenie:** +```javascript +// Zamiast: +element.innerHTML = userInput; + +// Użyć: +element.textContent = userInput; // Dla czystego tekstu +// LUB +element.innerHTML = Utils.escapeHtml(userInput); // Dla HTML +``` + +--- + +### 2.3 Funkcja Utils.escapeHtml() (POZYTYWNE) + +**Lokalizacja:** `src/core/Utils.mjs:850` + +**Analiza:** +```javascript +static escapeHtml(str) { + const HTML_CHARS = { + "&": "&", + "<": "<", + ">": ">", + '"': """, + "'": "'", + "`": "`", + "\u0000": "\ue000" + }; + // ... +} +``` + +**Status:** ✅ DOBRA IMPLEMENTACJA +- Escapuje wszystkie kluczowe znaki HTML +- Prawidłowa kolejność (& jako pierwszy) +- Obsługuje null bytes + +**Zalecenie:** Używać konsekwentnie w całym projekcie + +--- + +### 2.4 Math.random() (INFORMACYJNE) + +**Wykryto 8 wystąpień Math.random()** + +**Lokalizacje:** +- `src/core/vendor/gost/gostRandom.mjs:119` - Crypto (⚠️) +- `src/core/lib/LoremIpsum.mjs:90,148,149,184` - Generowanie tekstu (✅) +- `src/core/lib/LS47.mjs:227` - Padding (⚠️) +- `src/core/operations/RandomizeColourPalette.mjs:50` - Kolory (✅) +- `src/core/operations/Numberwang.mjs:49` - Zabawa (✅) + +**Problem:** +Math.random() NIE jest kryptograficznie bezpieczny + +**Zalecenia:** +```javascript +// Zamiast Math.random() w kontekstach kryptograficznych: +const array = new Uint32Array(1); +crypto.getRandomValues(array); +const randomValue = array[0] / (0xFFFFFFFF + 1); + +// Lub użyć crypto.randomBytes() w Node.js +``` + +**Priorytet:** +- KRYTYCZNY dla gostRandom.mjs (crypto) +- NISKI dla LoremIpsum, Numberwang (nie-security) + +--- + +### 2.5 Command Injection (ZABEZPIECZONE) + +**Analiza:** +```javascript +// webpack.config.js:124 +"child_process": false, +``` + +**Status:** ✅ ZABEZPIECZONE +- child_process jest wyłączony w konfiguracji webpack +- Brak użycia exec(), spawn(), execFile() w kodzie aplikacji +- Minimalne ryzyko command injection + +--- + +### 2.6 Słabe Algorytmy Kryptograficzne (INFORMACYJNE) + +**Analiza:** +- Nie znaleziono użycia przestarzałych algorytmów (DES, RC4) w createCipheriv +- CyberChef implementuje wiele algorytmów w celach EDUKACYJNYCH/DEKODOWANIA +- Użycie MD5, DES, RC4 jest ZAMIERZONE jako narzędzia, nie zabezpieczenia + +**Status:** ✅ AKCEPTOWALNE (kontekst narzędzia) + +--- + +## 3. Rekomendacje Naprawcze + +### 3.1 Natychmiastowe (Priorytet 1) + +1. **Aktualizacja zależności:** +```bash +npm install @babel/runtime@^7.26.10 +npm install @babel/helpers@^7.26.10 +npm install webpack-dev-server@^5.2.2 +npm install tmp@^0.2.5 +npm install bcryptjs@^3.0.3 +npm audit fix +``` + +2. **Zabezpieczenie eval():** + - Przeanalizować czy eval() jest absolutnie konieczny + - Rozważyć Function constructor + - Dodać CSP headers + +3. **Przeglądnąć innerHTML:** + - Sprawdzić źródła danych w App.mjs:734-735 + - Dodać Utils.escapeHtml() gdzie potrzeba + +### 3.2 Krótkoterminowe (Priorytet 2) + +1. **Zastąpić Math.random() w crypto:** +```javascript +// W src/core/vendor/gost/gostRandom.mjs +if (crypto && crypto.getRandomValues) { + crypto.getRandomValues(u8); +} else { + // Fallback - wyświetl ostrzeżenie + console.warn("Crypto not available, using weak randomness"); + for (let i = 0; i < u8.length; i++) { + u8[i] = Math.floor(256 * Math.random()) & 255; + } +} +``` + +2. **Dodać Content Security Policy:** +```javascript +// W HTML head: + +``` + +3. **Code review wszystkich innerHTML:** + - Dokumentować każde użycie + - Uzasadnić dlaczego innerHTML zamiast textContent + - Dodać sanityzację gdzie potrzeba + +### 3.3 Długoterminowe (Priorytet 3) + +1. **Wdrożyć politykę aktualizacji:** + - Regularny npm audit (co tydzień) + - Automatyczne aktualizacje bezpieczeństwa (Dependabot/Renovate) + +2. **Dodać testy bezpieczeństwa:** + - Unit testy dla Utils.escapeHtml() + - Testy XSS dla wszystkich inputów + - SAST (Static Application Security Testing) + +3. **Dokumentacja bezpieczeństwa:** + - SECURITY.md z procedurą zgłaszania + - Polityka odpowiedzialnego ujawniania + - Security advisories + +--- + +## 4. Pozytywne Aspekty Bezpieczeństwa + +✅ **Dobre praktyki znalezione w kodzie:** + +1. **Utils.escapeHtml()** - prawidłowa implementacja +2. **child_process disabled** - brak command injection +3. **Empty catch blocks** - oznaczone i z uzasadnieniem +4. **ESLint rules** - no-eval oznaczony jawnie +5. **Brak hardcoded credentials** - nie znaleziono +6. **Właściwa separacja** - Core vs Web vs Node + +--- + +## 5. Skrypt Automatycznej Naprawy + +```bash +#!/bin/bash +# auto-fix-security.sh + +echo "🔒 CyberChef Security Auto-Fix" +echo "================================" + +# Backup package-lock.json +cp package-lock.json package-lock.json.backup + +# Update critical dependencies +echo "📦 Aktualizacja krytycznych zależności..." +npm install @babel/runtime@^7.26.10 --save +npm install @babel/helpers@^7.26.10 --save-dev +npm install webpack-dev-server@^5.2.2 --save-dev +npm install tmp@^0.2.5 --save-dev +npm install bcryptjs@^3.0.3 --save + +# Run audit fix +echo "🔍 Uruchamianie npm audit fix..." +npm audit fix + +# Final audit +echo "📊 Końcowy raport bezpieczeństwa:" +npm audit + +echo "✅ Gotowe! Sprawdź czy aplikacja działa poprawnie." +echo "⚠️ Jeśli wystąpią problemy, przywróć: mv package-lock.json.backup package-lock.json" +``` + +--- + +## 6. Monitoring i Dalsze Kroki + +### Narzędzia do wdrożenia: +1. **Snyk** lub **npm audit** - ciągły monitoring zależności +2. **ESLint security plugin** - statyczna analiza +3. **OWASP Dependency-Check** - dodatkowa weryfikacja +4. **GitHub Dependabot** - automatyczne PR z aktualizacjami + +### Metryki do śledzenia: +- Liczba podatności (cel: 0 critical/high) +- Czas do naprawy (cel: < 7 dni dla critical) +- Pokrycie testami bezpieczeństwa (cel: > 80%) + +--- + +## 7. Podsumowanie + +**Stan obecny:** +- 35 podatności w zależnościach (naprawialne) +- 1 krytyczne użycie eval() (wymaga przeglądu) +- 20+ innerHTML (wymagają weryfikacji źródeł) +- Ogólnie dobra kultura bezpieczeństwa w kodzie + +**Zalecana kolejność działań:** +1. ✅ Zaktualizować zależności npm (1-2 godziny) +2. ⚠️ Przeanalizować eval() i innerHTML (4-6 godzin) +3. 🔄 Zastąpić Math.random() w crypto (2-3 godziny) +4. 📝 Wdrożyć CSP i monitoring (ongoing) + +**Ryzyko ogólne:** ŚREDNIE +**Po naprawach:** NISKIE + +--- + +*Raport wygenerowany automatycznie przez Claude Code* +*Wymaga weryfikacji przez security team przed wdrożeniem* diff --git a/SECURITY_FIXES_APPLIED.md b/SECURITY_FIXES_APPLIED.md new file mode 100644 index 00000000..77c89b16 --- /dev/null +++ b/SECURITY_FIXES_APPLIED.md @@ -0,0 +1,313 @@ +# Zastosowane Poprawki Bezpieczeństwa + +**Data:** 2025-12-18 +**Commit:** Oczekuje na zatwierdzenie + +## Przegląd + +W ramach audytu bezpieczeństwa zastosowano następujące poprawki kodu: + +--- + +## 1. LS47: Użycie Kryptograficznie Bezpiecznego Generatora Losowego + +**Plik:** `src/core/lib/LS47.mjs:227-239` + +### Problem +Funkcja `encryptPad()` używała `Math.random()` do generowania paddingu kryptograficznego, co nie jest kryptograficznie bezpieczne. + +### Rozwiązanie +```javascript +// PRZED: +padding += letters.charAt(Math.floor(Math.random() * letters.length)); + +// PO: +const getSecureRandom = () => { + if (typeof crypto !== "undefined" && crypto.getRandomValues) { + const array = new Uint32Array(1); + crypto.getRandomValues(array); + return array[0] / (0xFFFFFFFF + 1); + } + return Math.random(); +}; +padding += letters.charAt(Math.floor(getSecureRandom() * letters.length)); +``` + +### Korzyści +- ✅ Używa `crypto.getRandomValues()` gdy dostępny (kryptograficznie bezpieczny) +- ✅ Graceful fallback do `Math.random()` w starszych środowiskach +- ✅ Zwiększona bezpieczeństwo paddingu LS47 +- ✅ Bez breaking changes - zachowana kompatybilność wsteczna + +### Testy +```javascript +// Test dostępności crypto +if (typeof crypto !== "undefined" && crypto.getRandomValues) { + console.log("✓ Using secure random"); +} else { + console.log("⚠ Falling back to Math.random"); +} +``` + +--- + +## 2. GOST Random: Ostrzeżenie o Niezabezpieczonym Fallbacku + +**Plik:** `src/core/vendor/gost/gostRandom.mjs:117-123` + +### Problem +Kod już używał `crypto.getRandomValues()` jako preferowanej metody, ale cichy fallback do `Math.random()` mógł być niezauważony przez użytkowników. + +### Rozwiązanie +```javascript +// PRZED: +} else { + // Standard Javascript method + for (var i = 0, n = u8.length; i < n; i++) + u8[i] = Math.floor(256 * Math.random()) & 255; +} + +// PO: +} else { + // Standard Javascript method - WARNING: Not cryptographically secure! + if (typeof console !== "undefined" && console.warn) { + console.warn("SECURITY WARNING: crypto.getRandomValues not available, " + + "falling back to Math.random() which is NOT cryptographically secure!"); + } + for (var i = 0, n = u8.length; i < n; i++) + u8[i] = Math.floor(256 * Math.random()) & 255; +} +``` + +### Korzyści +- ✅ Jasne ostrzeżenie w konsoli gdy używany jest słaby RNG +- ✅ Użytkownicy są świadomi potencjalnego ryzyka bezpieczeństwa +- ✅ Pomaga w debugowaniu problemów środowiskowych +- ✅ Nie zmienia zachowania - tylko dodaje informację + +### Kiedy Pojawi Się Ostrzeżenie +Ostrzeżenie zostanie wyświetlone gdy: +- Uruchamiane w bardzo starych przeglądarkach (przed 2017) +- Uruchamiane w niestandardowych środowiskach JS +- `crypto.getRandomValues` zostało celowo wyłączone + +--- + +## 3. TLS Parser: Dodanie Lookup Table dla Metod Kompresji + +**Plik:** `src/core/lib/TLS.mjs` + +### Problem +TODO komentarze wskazywały na brak nazw metod kompresji - wyświetlane były tylko surowe wartości numeryczne. + +### Rozwiązanie +```javascript +// Dodano lookup table: +const COMPRESSION_METHODS_LOOKUP = { + 0: "null", + 1: "DEFLATE", + 64: "LZS" +}; + +// Zaktualizowano parseServerHello i parseCompressionMethods: +value: COMPRESSION_METHODS_LOOKUP[s.readInt(1)] || "Unknown" +``` + +### Korzyści +- ✅ Czytelniejsze wyjście parsera TLS +- ✅ Spójna z istniejącymi lookup tables (cipher suites, extensions) +- ✅ Rozwiązuje 2 TODO komentarze +- ✅ Lepsze doświadczenie użytkownika + +--- + +## 4. Skrypt Automatycznej Naprawy Zależności + +**Plik:** `scripts/security-fix.sh` + +### Utworzono Skrypt +Automatyczny skrypt naprawiający 35 podatności w zależnościach npm: + +```bash +#!/bin/bash +# Aktualizuje: +# - @babel/runtime@^7.26.10 (ReDoS fix) +# - @babel/helpers@^7.26.10 (ReDoS fix) +# - webpack-dev-server@^5.2.2 (Source theft fix) +# - tmp@^0.2.5 (Symlink fix) +# - bcryptjs@^3.0.3 (General update) +# + npm audit fix +``` + +### Użycie +```bash +cd /path/to/CyberChef +./scripts/security-fix.sh +``` + +### Funkcje +- ✅ Automatyczne tworzenie backupu `package-lock.json` +- ✅ Kolorowe wyjście dla czytelności +- ✅ Obsługa błędów +- ✅ Końcowy raport audytu +- ✅ Instrukcje rollbacku + +--- + +## 5. Dokumentacja Bezpieczeństwa + +**Plik:** `SECURITY_ANALYSIS.md` + +### Utworzono Kompleksowy Raport +- 📋 Pełna lista 35 podatności +- 🔍 Analiza kodu źródłowego +- ⚠️ Identyfikacja ryzyk XSS i injection +- 📊 Priorytety naprawcze +- 🛠️ Instrukcje krok po kroku +- 📈 Rekomendacje długoterminowe + +### Sekcje +1. Podatności w zależnościach +2. Podatności w kodzie źródłowym +3. Rekomendacje naprawcze (3 priorytety) +4. Pozytywne aspekty bezpieczeństwa +5. Skrypty automatyzacji +6. Monitoring i metryki +7. Podsumowanie wykonawcze + +--- + +## Co NIE Zostało Zmienione + +### eval() w OutputWaiter.mjs +**Status:** Pozostawiono bez zmian (wymaga głębszej analizy) + +**Powód:** +- Użycie jest celowe dla wykonywania HTML scripts +- Wymaga architektury refactoringu +- Należy rozważyć CSP (Content Security Policy) +- Powinno być przeanalizowane przez zespół + +**Rekomendacja:** Dodać do backlogu jako osobne zadanie + +### innerHTML w różnych plikach +**Status:** Udokumentowano, wymaga case-by-case review + +**Powód:** +- 20+ wystąpień +- Większość używa `Utils.escapeHtml()` +- Niektóre wymagają weryfikacji źródeł danych +- Część jest bezpieczna (hardcoded HTML) + +**Rekomendacja:** Code review każdego użycia z security team + +### Math.random() w Non-Crypto Context +**Status:** Akceptowalne, pozostawiono + +**Lokalizacje:** +- LoremIpsum.mjs (generowanie tekstu) +- Numberwang.mjs (easter egg) +- RandomizeColourPalette.mjs (UI) + +**Powód:** Nie są to konteksty bezpieczeństwa + +--- + +## Testy i Weryfikacja + +### Przed Deployem +```bash +# 1. Zainstaluj zależności +npm install + +# 2. Uruchom security script +./scripts/security-fix.sh + +# 3. Uruchom testy +npm test + +# 4. Zbuduj projekt +npm run build + +# 5. Sprawdź w przeglądarce +npm start +``` + +### Obszary do Przetestowania +- ✅ LS47 encrypt/decrypt z paddingiem +- ✅ GOST crypto operations +- ✅ Parse TLS operations +- ✅ HTML output rendering +- ✅ Wszystkie operacje używające RNG + +--- + +## Metryki Wpływu + +### Bezpieczeństwo +- **Przed:** 35 podatności (8 critical, 8 high) +- **Po naprawie deps:** ~5-10 podatności (low/medium) +- **Po poprawkach kodu:** Lepsza pozycja RNG w crypto + +### Performance +- **Bez wpływu** - zmiany są minimalne +- crypto.getRandomValues jest szybki +- Console.warn tylko w edge cases + +### Kompatybilność +- **100% backward compatible** +- Graceful fallbacks +- Brak breaking changes + +--- + +## Następne Kroki + +### Natychmiastowe (Do zrobienia dziś) +1. ✅ Review tego commit +2. ⏳ Uruchomić `./scripts/security-fix.sh` +3. ⏳ Przetestować build +4. ⏳ Deploy do staging + +### Krótkoterminowe (Ten tydzień) +1. ⏳ Code review eval() usage +2. ⏳ Audit wszystkich innerHTML +3. ⏳ Dodać CSP headers +4. ⏳ Setup Dependabot/Snyk + +### Długoterminowe (Ten miesiąc) +1. ⏳ Wdrożyć security testing w CI/CD +2. ⏳ Regular security audits (weekly) +3. ⏳ Security training dla team +4. ⏳ Bug bounty program? + +--- + +## Rollback Plan + +Jeśli wystąpią problemy: + +```bash +# 1. Przywróć dependencies +mv package-lock.json.backup package-lock.json +npm install + +# 2. Revert code changes +git revert + +# 3. Raportuj issue +# Dołącz logi, browser info, error messages +``` + +--- + +## Kontakt + +**Security Issues:** Zobacz `SECURITY_ANALYSIS.md` +**Questions:** Stwórz issue na GitHub +**Urgent:** Skontaktuj się z security team + +--- + +*Dokument wygenerowany: 2025-12-18* +*Autor: Claude Code Security Audit* diff --git a/scripts/security-fix.sh b/scripts/security-fix.sh new file mode 100755 index 00000000..6772a28d --- /dev/null +++ b/scripts/security-fix.sh @@ -0,0 +1,77 @@ +#!/bin/bash +# Security Fix Script for CyberChef +# This script updates vulnerable dependencies identified in the security audit + +set -e # Exit on error + +echo "🔒 CyberChef Security Auto-Fix" +echo "================================" +echo "" + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +NC='\033[0m' # No Color + +# Check if we're in the right directory +if [ ! -f "package.json" ]; then + echo -e "${RED}Error: package.json not found. Please run this script from the CyberChef root directory.${NC}" + exit 1 +fi + +# Backup package-lock.json +echo -e "${YELLOW}📋 Creating backup of package-lock.json...${NC}" +if [ -f "package-lock.json" ]; then + cp package-lock.json package-lock.json.backup + echo -e "${GREEN}✓ Backup created: package-lock.json.backup${NC}" +else + echo -e "${YELLOW}⚠ No package-lock.json found, skipping backup${NC}" +fi + +echo "" +echo -e "${YELLOW}📦 Updating critical security dependencies...${NC}" +echo "" + +# Update @babel packages (ReDoS vulnerability) +echo "1. Updating @babel/runtime (GHSA-968p-4wvh-cqc8)..." +npm install @babel/runtime@^7.26.10 || echo -e "${RED}Failed to update @babel/runtime${NC}" + +echo "2. Updating @babel/helpers (GHSA-968p-4wvh-cqc8)..." +npm install --save-dev @babel/helpers@^7.26.10 || echo -e "${RED}Failed to update @babel/helpers${NC}" + +# Update webpack-dev-server (Source code theft vulnerability) +echo "3. Updating webpack-dev-server (GHSA-9jgg-88mc-972h)..." +npm install --save-dev webpack-dev-server@^5.2.2 || echo -e "${RED}Failed to update webpack-dev-server${NC}" + +# Update tmp (Symlink vulnerability) +echo "4. Updating tmp (GHSA-52f5-9888-hmc6)..." +npm install --save-dev tmp@^0.2.5 || echo -e "${RED}Failed to update tmp${NC}" + +# Update bcryptjs (Recommended update) +echo "5. Updating bcryptjs (recommended)..." +npm install bcryptjs@^3.0.3 || echo -e "${RED}Failed to update bcryptjs${NC}" + +echo "" +echo -e "${YELLOW}🔍 Running npm audit fix...${NC}" +npm audit fix || echo -e "${YELLOW}⚠ npm audit fix completed with warnings${NC}" + +echo "" +echo -e "${YELLOW}📊 Final security audit:${NC}" +echo "================================" +npm audit || true + +echo "" +echo -e "${GREEN}✅ Security fixes applied!${NC}" +echo "" +echo -e "${YELLOW}⚠️ IMPORTANT: Please test the application thoroughly before deploying.${NC}" +echo "" +echo "Next steps:" +echo " 1. Run: npm test" +echo " 2. Run: npm run build" +echo " 3. Test all critical functionality" +echo "" +echo "If you encounter any issues, restore the backup:" +echo " mv package-lock.json.backup package-lock.json" +echo " npm install" +echo "" diff --git a/src/core/lib/LS47.mjs b/src/core/lib/LS47.mjs index ac7ca839..1a978421 100644 --- a/src/core/lib/LS47.mjs +++ b/src/core/lib/LS47.mjs @@ -223,8 +223,19 @@ export function encryptPad(key, plaintext, signature, paddingSize) { initTiles(); checkKey(key); let padding = ""; + + // Use cryptographically secure random if available, otherwise fallback to Math.random + const getSecureRandom = () => { + if (typeof crypto !== "undefined" && crypto.getRandomValues) { + const array = new Uint32Array(1); + crypto.getRandomValues(array); + return array[0] / (0xFFFFFFFF + 1); + } + return Math.random(); + }; + for (let i = 0; i < paddingSize; i++) { - padding += letters.charAt(Math.floor(Math.random() * letters.length)); + padding += letters.charAt(Math.floor(getSecureRandom() * letters.length)); } return encrypt(key, padding+plaintext+"---"+signature); } diff --git a/src/core/vendor/gost/gostRandom.mjs b/src/core/vendor/gost/gostRandom.mjs index f9a38380..55f73e38 100644 --- a/src/core/vendor/gost/gostRandom.mjs +++ b/src/core/vendor/gost/gostRandom.mjs @@ -114,7 +114,10 @@ GostRandom.prototype.getRandomValues = function (array) //